qmp-cmds.c - qemu - FORK: QEMU emulator

qmp-cmds.c (16350B)
      1 /*
      2  * QEMU Management Protocol commands
      3  *
      4  * Copyright IBM, Corp. 2011
      5  *
      6  * Authors:
      7  *  Anthony Liguori   <aliguori@us.ibm.com>
      8  *
      9  * This work is licensed under the terms of the GNU GPL, version 2.  See
     10  * the COPYING file in the top-level directory.
     11  *
     12  * Contributions after 2012-01-13 are licensed under the terms of the
     13  * GNU GPL, version 2 or (at your option) any later version.
     14  */
     15 
     16 #include "qemu/osdep.h"
     17 #include "qemu/cutils.h"
     18 #include "qemu/option.h"
     19 #include "monitor/monitor.h"
     20 #include "sysemu/sysemu.h"
     21 #include "qemu/config-file.h"
     22 #include "qemu/uuid.h"
     23 #include "chardev/char.h"
     24 #include "ui/qemu-spice.h"
     25 #include "ui/console.h"
     26 #include "ui/dbus-display.h"
     27 #include "sysemu/kvm.h"
     28 #include "sysemu/runstate.h"
     29 #include "sysemu/runstate-action.h"
     30 #include "sysemu/blockdev.h"
     31 #include "sysemu/block-backend.h"
     32 #include "qapi/error.h"
     33 #include "qapi/qapi-commands-acpi.h"
     34 #include "qapi/qapi-commands-block.h"
     35 #include "qapi/qapi-commands-control.h"
     36 #include "qapi/qapi-commands-machine.h"
     37 #include "qapi/qapi-commands-misc.h"
     38 #include "qapi/qapi-commands-stats.h"
     39 #include "qapi/qapi-commands-ui.h"
     40 #include "qapi/type-helpers.h"
     41 #include "qapi/qmp/qerror.h"
     42 #include "exec/ramlist.h"
     43 #include "hw/mem/memory-device.h"
     44 #include "hw/acpi/acpi_dev_interface.h"
     45 #include "hw/intc/intc.h"
     46 #include "hw/rdma/rdma.h"
     47 #include "monitor/stats.h"
     48 
     49 NameInfo *qmp_query_name(Error **errp)
     50 {
     51     NameInfo *info = g_malloc0(sizeof(*info));
     52 
     53     if (qemu_name) {
     54         info->has_name = true;
     55         info->name = g_strdup(qemu_name);
     56     }
     57 
     58     return info;
     59 }
     60 
     61 KvmInfo *qmp_query_kvm(Error **errp)
     62 {
     63     KvmInfo *info = g_malloc0(sizeof(*info));
     64 
     65     info->enabled = kvm_enabled();
     66     info->present = accel_find("kvm");
     67 
     68     return info;
     69 }
     70 
     71 UuidInfo *qmp_query_uuid(Error **errp)
     72 {
     73     UuidInfo *info = g_malloc0(sizeof(*info));
     74 
     75     info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
     76     return info;
     77 }
     78 
     79 void qmp_quit(Error **errp)
     80 {
     81     shutdown_action = SHUTDOWN_ACTION_POWEROFF;
     82     qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_QMP_QUIT);
     83 }
     84 
     85 void qmp_stop(Error **errp)
     86 {
     87     /* if there is a dump in background, we should wait until the dump
     88      * finished */
     89     if (qemu_system_dump_in_progress()) {
     90         error_setg(errp, "There is a dump in process, please wait.");
     91         return;
     92     }
     93 
     94     if (runstate_check(RUN_STATE_INMIGRATE)) {
     95         autostart = 0;
     96     } else {
     97         vm_stop(RUN_STATE_PAUSED);
     98     }
     99 }
    100 
    101 void qmp_system_reset(Error **errp)
    102 {
    103     qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP_SYSTEM_RESET);
    104 }
    105 
    106 void qmp_system_powerdown(Error **errp)
    107 {
    108     qemu_system_powerdown_request();
    109 }
    110 
    111 void qmp_cont(Error **errp)
    112 {
    113     BlockBackend *blk;
    114     BlockJob *job;
    115     Error *local_err = NULL;
    116 
    117     /* if there is a dump in background, we should wait until the dump
    118      * finished */
    119     if (qemu_system_dump_in_progress()) {
    120         error_setg(errp, "There is a dump in process, please wait.");
    121         return;
    122     }
    123 
    124     if (runstate_needs_reset()) {
    125         error_setg(errp, "Resetting the Virtual Machine is required");
    126         return;
    127     } else if (runstate_check(RUN_STATE_SUSPENDED)) {
    128         return;
    129     } else if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
    130         error_setg(errp, "Migration is not finalized yet");
    131         return;
    132     }
    133 
    134     for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
    135         blk_iostatus_reset(blk);
    136     }
    137 
    138     WITH_JOB_LOCK_GUARD() {
    139         for (job = block_job_next_locked(NULL); job;
    140              job = block_job_next_locked(job)) {
    141             block_job_iostatus_reset_locked(job);
    142         }
    143     }
    144 
    145     /* Continuing after completed migration. Images have been inactivated to
    146      * allow the destination to take control. Need to get control back now.
    147      *
    148      * If there are no inactive block nodes (e.g. because the VM was just
    149      * paused rather than completing a migration), bdrv_inactivate_all() simply
    150      * doesn't do anything. */
    151     bdrv_activate_all(&local_err);
    152     if (local_err) {
    153         error_propagate(errp, local_err);
    154         return;
    155     }
    156 
    157     if (runstate_check(RUN_STATE_INMIGRATE)) {
    158         autostart = 1;
    159     } else {
    160         vm_start();
    161     }
    162 }
    163 
    164 void qmp_system_wakeup(Error **errp)
    165 {
    166     if (!qemu_wakeup_suspend_enabled()) {
    167         error_setg(errp,
    168                    "wake-up from suspend is not supported by this guest");
    169         return;
    170     }
    171 
    172     qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, errp);
    173 }
    174 
    175 void qmp_set_password(SetPasswordOptions *opts, Error **errp)
    176 {
    177     int rc;
    178 
    179     if (opts->protocol == DISPLAY_PROTOCOL_SPICE) {
    180         if (!qemu_using_spice(errp)) {
    181             return;
    182         }
    183         rc = qemu_spice.set_passwd(opts->password,
    184                 opts->connected == SET_PASSWORD_ACTION_FAIL,
    185                 opts->connected == SET_PASSWORD_ACTION_DISCONNECT);
    186     } else {
    187         assert(opts->protocol == DISPLAY_PROTOCOL_VNC);
    188         if (opts->connected != SET_PASSWORD_ACTION_KEEP) {
    189             /* vnc supports "connected=keep" only */
    190             error_setg(errp, QERR_INVALID_PARAMETER, "connected");
    191             return;
    192         }
    193         /* Note that setting an empty password will not disable login through
    194          * this interface. */
    195         rc = vnc_display_password(opts->u.vnc.display, opts->password);
    196     }
    197 
    198     if (rc != 0) {
    199         error_setg(errp, "Could not set password");
    200     }
    201 }
    202 
    203 void qmp_expire_password(ExpirePasswordOptions *opts, Error **errp)
    204 {
    205     time_t when;
    206     int rc;
    207     const char *whenstr = opts->time;
    208 
    209     if (strcmp(whenstr, "now") == 0) {
    210         when = 0;
    211     } else if (strcmp(whenstr, "never") == 0) {
    212         when = TIME_MAX;
    213     } else if (whenstr[0] == '+') {
    214         when = time(NULL) + strtoull(whenstr+1, NULL, 10);
    215     } else {
    216         when = strtoull(whenstr, NULL, 10);
    217     }
    218 
    219     if (opts->protocol == DISPLAY_PROTOCOL_SPICE) {
    220         if (!qemu_using_spice(errp)) {
    221             return;
    222         }
    223         rc = qemu_spice.set_pw_expire(when);
    224     } else {
    225         assert(opts->protocol == DISPLAY_PROTOCOL_VNC);
    226         rc = vnc_display_pw_expire(opts->u.vnc.display, when);
    227     }
    228 
    229     if (rc != 0) {
    230         error_setg(errp, "Could not set password expire time");
    231     }
    232 }
    233 
    234 #ifdef CONFIG_VNC
    235 void qmp_change_vnc_password(const char *password, Error **errp)
    236 {
    237     if (vnc_display_password(NULL, password) < 0) {
    238         error_setg(errp, "Could not set password");
    239     }
    240 }
    241 #endif
    242 
    243 void qmp_add_client(const char *protocol, const char *fdname,
    244                     bool has_skipauth, bool skipauth, bool has_tls, bool tls,
    245                     Error **errp)
    246 {
    247     Chardev *s;
    248     int fd;
    249 
    250     fd = monitor_get_fd(monitor_cur(), fdname, errp);
    251     if (fd < 0) {
    252         return;
    253     }
    254 
    255     if (strcmp(protocol, "spice") == 0) {
    256         if (!qemu_using_spice(errp)) {
    257             close(fd);
    258             return;
    259         }
    260         skipauth = has_skipauth ? skipauth : false;
    261         tls = has_tls ? tls : false;
    262         if (qemu_spice.display_add_client(fd, skipauth, tls) < 0) {
    263             error_setg(errp, "spice failed to add client");
    264             close(fd);
    265         }
    266         return;
    267 #ifdef CONFIG_VNC
    268     } else if (strcmp(protocol, "vnc") == 0) {
    269         skipauth = has_skipauth ? skipauth : false;
    270         vnc_display_add_client(NULL, fd, skipauth);
    271         return;
    272 #endif
    273 #ifdef CONFIG_DBUS_DISPLAY
    274     } else if (strcmp(protocol, "@dbus-display") == 0) {
    275         if (!qemu_using_dbus_display(errp)) {
    276             close(fd);
    277             return;
    278         }
    279         if (!qemu_dbus_display.add_client(fd, errp)) {
    280             close(fd);
    281             return;
    282         }
    283         return;
    284 #endif
    285     } else if ((s = qemu_chr_find(protocol)) != NULL) {
    286         if (qemu_chr_add_client(s, fd) < 0) {
    287             error_setg(errp, "failed to add client");
    288             close(fd);
    289             return;
    290         }
    291         return;
    292     }
    293 
    294     error_setg(errp, "protocol '%s' is invalid", protocol);
    295     close(fd);
    296 }
    297 
    298 
    299 MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
    300 {
    301     return qmp_memory_device_list();
    302 }
    303 
    304 ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
    305 {
    306     bool ambig;
    307     ACPIOSTInfoList *head = NULL;
    308     ACPIOSTInfoList **prev = &head;
    309     Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);
    310 
    311     if (obj) {
    312         AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
    313         AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);
    314 
    315         adevc->ospm_status(adev, &prev);
    316     } else {
    317         error_setg(errp, "command is not supported, missing ACPI device");
    318     }
    319 
    320     return head;
    321 }
    322 
    323 MemoryInfo *qmp_query_memory_size_summary(Error **errp)
    324 {
    325     MemoryInfo *mem_info = g_new0(MemoryInfo, 1);
    326     MachineState *ms = MACHINE(qdev_get_machine());
    327 
    328     mem_info->base_memory = ms->ram_size;
    329 
    330     mem_info->plugged_memory = get_plugged_memory_size();
    331     mem_info->has_plugged_memory =
    332         mem_info->plugged_memory != (uint64_t)-1;
    333 
    334     return mem_info;
    335 }
    336 
    337 void qmp_display_reload(DisplayReloadOptions *arg, Error **errp)
    338 {
    339     switch (arg->type) {
    340     case DISPLAY_RELOAD_TYPE_VNC:
    341 #ifdef CONFIG_VNC
    342         if (arg->u.vnc.has_tls_certs && arg->u.vnc.tls_certs) {
    343             vnc_display_reload_certs(NULL, errp);
    344         }
    345 #else
    346         error_setg(errp, "vnc is invalid, missing 'CONFIG_VNC'");
    347 #endif
    348         break;
    349     default:
    350         abort();
    351     }
    352 }
    353 
    354 void qmp_display_update(DisplayUpdateOptions *arg, Error **errp)
    355 {
    356     switch (arg->type) {
    357     case DISPLAY_UPDATE_TYPE_VNC:
    358 #ifdef CONFIG_VNC
    359         vnc_display_update(&arg->u.vnc, errp);
    360 #else
    361         error_setg(errp, "vnc is invalid, missing 'CONFIG_VNC'");
    362 #endif
    363         break;
    364     default:
    365         abort();
    366     }
    367 }
    368 
    369 static int qmp_x_query_rdma_foreach(Object *obj, void *opaque)
    370 {
    371     RdmaProvider *rdma;
    372     RdmaProviderClass *k;
    373     GString *buf = opaque;
    374 
    375     if (object_dynamic_cast(obj, INTERFACE_RDMA_PROVIDER)) {
    376         rdma = RDMA_PROVIDER(obj);
    377         k = RDMA_PROVIDER_GET_CLASS(obj);
    378         if (k->format_statistics) {
    379             k->format_statistics(rdma, buf);
    380         } else {
    381             g_string_append_printf(buf,
    382                                    "RDMA statistics not available for %s.\n",
    383                                    object_get_typename(obj));
    384         }
    385     }
    386 
    387     return 0;
    388 }
    389 
    390 HumanReadableText *qmp_x_query_rdma(Error **errp)
    391 {
    392     g_autoptr(GString) buf = g_string_new("");
    393 
    394     object_child_foreach_recursive(object_get_root(),
    395                                    qmp_x_query_rdma_foreach, buf);
    396 
    397     return human_readable_text_from_str(buf);
    398 }
    399 
    400 HumanReadableText *qmp_x_query_ramblock(Error **errp)
    401 {
    402     g_autoptr(GString) buf = ram_block_format();
    403 
    404     return human_readable_text_from_str(buf);
    405 }
    406 
    407 static int qmp_x_query_irq_foreach(Object *obj, void *opaque)
    408 {
    409     InterruptStatsProvider *intc;
    410     InterruptStatsProviderClass *k;
    411     GString *buf = opaque;
    412 
    413     if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
    414         intc = INTERRUPT_STATS_PROVIDER(obj);
    415         k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
    416         uint64_t *irq_counts;
    417         unsigned int nb_irqs, i;
    418         if (k->get_statistics &&
    419             k->get_statistics(intc, &irq_counts, &nb_irqs)) {
    420             if (nb_irqs > 0) {
    421                 g_string_append_printf(buf, "IRQ statistics for %s:\n",
    422                                        object_get_typename(obj));
    423                 for (i = 0; i < nb_irqs; i++) {
    424                     if (irq_counts[i] > 0) {
    425                         g_string_append_printf(buf, "%2d: %" PRId64 "\n", i,
    426                                                irq_counts[i]);
    427                     }
    428                 }
    429             }
    430         } else {
    431             g_string_append_printf(buf,
    432                                    "IRQ statistics not available for %s.\n",
    433                                    object_get_typename(obj));
    434         }
    435     }
    436 
    437     return 0;
    438 }
    439 
    440 HumanReadableText *qmp_x_query_irq(Error **errp)
    441 {
    442     g_autoptr(GString) buf = g_string_new("");
    443 
    444     object_child_foreach_recursive(object_get_root(),
    445                                    qmp_x_query_irq_foreach, buf);
    446 
    447     return human_readable_text_from_str(buf);
    448 }
    449 
    450 typedef struct StatsCallbacks {
    451     StatsProvider provider;
    452     StatRetrieveFunc *stats_cb;
    453     SchemaRetrieveFunc *schemas_cb;
    454     QTAILQ_ENTRY(StatsCallbacks) next;
    455 } StatsCallbacks;
    456 
    457 static QTAILQ_HEAD(, StatsCallbacks) stats_callbacks =
    458     QTAILQ_HEAD_INITIALIZER(stats_callbacks);
    459 
    460 void add_stats_callbacks(StatsProvider provider,
    461                          StatRetrieveFunc *stats_fn,
    462                          SchemaRetrieveFunc *schemas_fn)
    463 {
    464     StatsCallbacks *entry = g_new(StatsCallbacks, 1);
    465     entry->provider = provider;
    466     entry->stats_cb = stats_fn;
    467     entry->schemas_cb = schemas_fn;
    468 
    469     QTAILQ_INSERT_TAIL(&stats_callbacks, entry, next);
    470 }
    471 
    472 static bool invoke_stats_cb(StatsCallbacks *entry,
    473                             StatsResultList **stats_results,
    474                             StatsFilter *filter, StatsRequest *request,
    475                             Error **errp)
    476 {
    477     strList *targets = NULL;
    478     strList *names = NULL;
    479     ERRP_GUARD();
    480 
    481     if (request) {
    482         if (request->provider != entry->provider) {
    483             return true;
    484         }
    485         if (request->has_names && !request->names) {
    486             return true;
    487         }
    488         names = request->has_names ? request->names : NULL;
    489     }
    490 
    491     switch (filter->target) {
    492     case STATS_TARGET_VM:
    493         break;
    494     case STATS_TARGET_VCPU:
    495         if (filter->u.vcpu.has_vcpus) {
    496             if (!filter->u.vcpu.vcpus) {
    497                 /* No targets allowed?  Return no statistics.  */
    498                 return true;
    499             }
    500             targets = filter->u.vcpu.vcpus;
    501         }
    502         break;
    503     default:
    504         abort();
    505     }
    506 
    507     entry->stats_cb(stats_results, filter->target, names, targets, errp);
    508     if (*errp) {
    509         qapi_free_StatsResultList(*stats_results);
    510         *stats_results = NULL;
    511         return false;
    512     }
    513     return true;
    514 }
    515 
    516 StatsResultList *qmp_query_stats(StatsFilter *filter, Error **errp)
    517 {
    518     StatsResultList *stats_results = NULL;
    519     StatsCallbacks *entry;
    520     StatsRequestList *request;
    521 
    522     QTAILQ_FOREACH(entry, &stats_callbacks, next) {
    523         if (filter->has_providers) {
    524             for (request = filter->providers; request; request = request->next) {
    525                 if (!invoke_stats_cb(entry, &stats_results, filter,
    526                                      request->value, errp)) {
    527                     break;
    528                 }
    529             }
    530         } else {
    531             if (!invoke_stats_cb(entry, &stats_results, filter, NULL, errp)) {
    532                 break;
    533             }
    534         }
    535     }
    536 
    537     return stats_results;
    538 }
    539 
    540 StatsSchemaList *qmp_query_stats_schemas(bool has_provider,
    541                                          StatsProvider provider,
    542                                          Error **errp)
    543 {
    544     StatsSchemaList *stats_results = NULL;
    545     StatsCallbacks *entry;
    546     ERRP_GUARD();
    547 
    548     QTAILQ_FOREACH(entry, &stats_callbacks, next) {
    549         if (!has_provider || provider == entry->provider) {
    550             entry->schemas_cb(&stats_results, errp);
    551             if (*errp) {
    552                 qapi_free_StatsSchemaList(stats_results);
    553                 return NULL;
    554             }
    555         }
    556     }
    557 
    558     return stats_results;
    559 }
    560 
    561 void add_stats_entry(StatsResultList **stats_results, StatsProvider provider,
    562                      const char *qom_path, StatsList *stats_list)
    563 {
    564     StatsResult *entry = g_new0(StatsResult, 1);
    565 
    566     entry->provider = provider;
    567     if (qom_path) {
    568         entry->has_qom_path = true;
    569         entry->qom_path = g_strdup(qom_path);
    570     }
    571     entry->stats = stats_list;
    572 
    573     QAPI_LIST_PREPEND(*stats_results, entry);
    574 }
    575 
    576 void add_stats_schema(StatsSchemaList **schema_results,
    577                       StatsProvider provider, StatsTarget target,
    578                       StatsSchemaValueList *stats_list)
    579 {
    580     StatsSchema *entry = g_new0(StatsSchema, 1);
    581 
    582     entry->provider = provider;
    583     entry->target = target;
    584     entry->stats = stats_list;
    585     QAPI_LIST_PREPEND(*schema_results, entry);
    586 }
    587 
    588 bool apply_str_list_filter(const char *string, strList *list)
    589 {
    590     strList *str_list = NULL;
    591 
    592     if (!list) {
    593         return true;
    594     }
    595     for (str_list = list; str_list; str_list = str_list->next) {
    596         if (g_str_equal(string, str_list->value)) {
    597             return true;
    598         }
    599     }
    600     return false;
    601 }
	qemu FORK: QEMU emulator
	git clone https://git.neptards.moe/neptards/qemu.git
	Log \| Files \| Refs \| Submodules \| LICENSE