monitor/qmp-cmds.c

   1 /*
   2  * QEMU Management Protocol commands
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <[email protected]>
   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-common.h"
  18 #include "qemu-version.h"
  19 #include "qemu/cutils.h"
  20 #include "qemu/option.h"
  21 #include "monitor/monitor.h"
  22 #include "sysemu/sysemu.h"
  23 #include "qemu/config-file.h"
  24 #include "qemu/uuid.h"
  25 #include "chardev/char.h"
  26 #include "ui/qemu-spice.h"
  27 #include "ui/vnc.h"
  28 #include "sysemu/kvm.h"
  29 #include "sysemu/runstate.h"
  30 #include "sysemu/arch_init.h"
  31 #include "sysemu/blockdev.h"
  32 #include "sysemu/block-backend.h"
  33 #include "qapi/error.h"
  34 #include "qapi/qapi-commands-block-core.h"
  35 #include "qapi/qapi-commands-machine.h"
  36 #include "qapi/qapi-commands-misc.h"
  37 #include "qapi/qapi-commands-ui.h"
  38 #include "qapi/qmp/qerror.h"
  39 #include "hw/mem/memory-device.h"
  40 #include "hw/acpi/acpi_dev_interface.h"
  41
  42 NameInfo *qmp_query_name(Error **errp)
  43 {
  44     NameInfo *info = g_malloc0(sizeof(*info));
  45
  46     if (qemu_name) {
  47         info->has_name = true;
  48         info->name = g_strdup(qemu_name);
  49     }
  50
  51     return info;
  52 }
  53
  54 VersionInfo *qmp_query_version(Error **errp)
  55 {
  56     VersionInfo *info = g_new0(VersionInfo, 1);
  57
  58     info->qemu = g_new0(VersionTriple, 1);
  59     info->qemu->major = QEMU_VERSION_MAJOR;
  60     info->qemu->minor = QEMU_VERSION_MINOR;
  61     info->qemu->micro = QEMU_VERSION_MICRO;
  62     info->package = g_strdup(QEMU_PKGVERSION);
  63
  64     return info;
  65 }
  66
  67 KvmInfo *qmp_query_kvm(Error **errp)
  68 {
  69     KvmInfo *info = g_malloc0(sizeof(*info));
  70
  71     info->enabled = kvm_enabled();
  72     info->present = kvm_available();
  73
  74     return info;
  75 }
  76
  77 UuidInfo *qmp_query_uuid(Error **errp)
  78 {
  79     UuidInfo *info = g_malloc0(sizeof(*info));
  80
  81     info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
  82     return info;
  83 }
  84
  85 void qmp_quit(Error **errp)
  86 {
  87     no_shutdown = 0;
  88     qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_QMP_QUIT);
  89 }
  90
  91 void qmp_stop(Error **errp)
  92 {
  93     /* if there is a dump in background, we should wait until the dump
  94      * finished */
  95     if (dump_in_progress()) {
  96         error_setg(errp, "There is a dump in process, please wait.");
  97         return;
  98     }
  99
 100     if (runstate_check(RUN_STATE_INMIGRATE)) {
 101         autostart = 0;
 102     } else {
 103         vm_stop(RUN_STATE_PAUSED);
 104     }
 105 }
 106
 107 void qmp_system_reset(Error **errp)
 108 {
 109     qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP_SYSTEM_RESET);
 110 }
 111
 112 void qmp_system_powerdown(Error **erp)
 113 {
 114     qemu_system_powerdown_request();
 115 }
 116
 117 void qmp_x_exit_preconfig(Error **errp)
 118 {
 119     if (!runstate_check(RUN_STATE_PRECONFIG)) {
 120         error_setg(errp, "The command is permitted only in '%s' state",
 121                    RunState_str(RUN_STATE_PRECONFIG));
 122         return;
 123     }
 124     qemu_exit_preconfig_request();
 125 }
 126
 127 void qmp_cont(Error **errp)
 128 {
 129     BlockBackend *blk;
 130     BlockJob *job;
 131     Error *local_err = NULL;
 132
 133     /* if there is a dump in background, we should wait until the dump
 134      * finished */
 135     if (dump_in_progress()) {
 136         error_setg(errp, "There is a dump in process, please wait.");
 137         return;
 138     }
 139
 140     if (runstate_needs_reset()) {
 141         error_setg(errp, "Resetting the Virtual Machine is required");
 142         return;
 143     } else if (runstate_check(RUN_STATE_SUSPENDED)) {
 144         return;
 145     } else if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
 146         error_setg(errp, "Migration is not finalized yet");
 147         return;
 148     }
 149
 150     for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
 151         blk_iostatus_reset(blk);
 152     }
 153
 154     for (job = block_job_next(NULL); job; job = block_job_next(job)) {
 155         block_job_iostatus_reset(job);
 156     }
 157
 158     /* Continuing after completed migration. Images have been inactivated to
 159      * allow the destination to take control. Need to get control back now.
 160      *
 161      * If there are no inactive block nodes (e.g. because the VM was just
 162      * paused rather than completing a migration), bdrv_inactivate_all() simply
 163      * doesn't do anything. */
 164     bdrv_invalidate_cache_all(&local_err);
 165     if (local_err) {
 166         error_propagate(errp, local_err);
 167         return;
 168     }
 169
 170     if (runstate_check(RUN_STATE_INMIGRATE)) {
 171         autostart = 1;
 172     } else {
 173         vm_start();
 174     }
 175 }
 176
 177 void qmp_system_wakeup(Error **errp)
 178 {
 179     if (!qemu_wakeup_suspend_enabled()) {
 180         error_setg(errp,
 181                    "wake-up from suspend is not supported by this guest");
 182         return;
 183     }
 184
 185     qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, errp);
 186 }
 187
 188 void qmp_set_password(const char *protocol, const char *password,
 189                       bool has_connected, const char *connected, Error **errp)
 190 {
 191     int disconnect_if_connected = 0;
 192     int fail_if_connected = 0;
 193     int rc;
 194
 195     if (has_connected) {
 196         if (strcmp(connected, "fail") == 0) {
 197             fail_if_connected = 1;
 198         } else if (strcmp(connected, "disconnect") == 0) {
 199             disconnect_if_connected = 1;
 200         } else if (strcmp(connected, "keep") == 0) {
 201             /* nothing */
 202         } else {
 203             error_setg(errp, QERR_INVALID_PARAMETER, "connected");
 204             return;
 205         }
 206     }
 207
 208     if (strcmp(protocol, "spice") == 0) {
 209         if (!qemu_using_spice(errp)) {
 210             return;
 211         }
 212         rc = qemu_spice_set_passwd(password, fail_if_connected,
 213                                    disconnect_if_connected);
 214         if (rc != 0) {
 215             error_setg(errp, QERR_SET_PASSWD_FAILED);
 216         }
 217         return;
 218     }
 219
 220     if (strcmp(protocol, "vnc") == 0) {
 221         if (fail_if_connected || disconnect_if_connected) {
 222             /* vnc supports "connected=keep" only */
 223             error_setg(errp, QERR_INVALID_PARAMETER, "connected");
 224             return;
 225         }
 226         /* Note that setting an empty password will not disable login through
 227          * this interface. */
 228         rc = vnc_display_password(NULL, password);
 229         if (rc < 0) {
 230             error_setg(errp, QERR_SET_PASSWD_FAILED);
 231         }
 232         return;
 233     }
 234
 235     error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
 236 }
 237
 238 void qmp_expire_password(const char *protocol, const char *whenstr,
 239                          Error **errp)
 240 {
 241     time_t when;
 242     int rc;
 243
 244     if (strcmp(whenstr, "now") == 0) {
 245         when = 0;
 246     } else if (strcmp(whenstr, "never") == 0) {
 247         when = TIME_MAX;
 248     } else if (whenstr[0] == '+') {
 249         when = time(NULL) + strtoull(whenstr+1, NULL, 10);
 250     } else {
 251         when = strtoull(whenstr, NULL, 10);
 252     }
 253
 254     if (strcmp(protocol, "spice") == 0) {
 255         if (!qemu_using_spice(errp)) {
 256             return;
 257         }
 258         rc = qemu_spice_set_pw_expire(when);
 259         if (rc != 0) {
 260             error_setg(errp, QERR_SET_PASSWD_FAILED);
 261         }
 262         return;
 263     }
 264
 265     if (strcmp(protocol, "vnc") == 0) {
 266         rc = vnc_display_pw_expire(NULL, when);
 267         if (rc != 0) {
 268             error_setg(errp, QERR_SET_PASSWD_FAILED);
 269         }
 270         return;
 271     }
 272
 273     error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
 274 }
 275
 276 #ifdef CONFIG_VNC
 277 void qmp_change_vnc_password(const char *password, Error **errp)
 278 {
 279     if (vnc_display_password(NULL, password) < 0) {
 280         error_setg(errp, QERR_SET_PASSWD_FAILED);
 281     }
 282 }
 283
 284 static void qmp_change_vnc_listen(const char *target, Error **errp)
 285 {
 286     QemuOptsList *olist = qemu_find_opts("vnc");
 287     QemuOpts *opts;
 288
 289     if (strstr(target, "id=")) {
 290         error_setg(errp, "id not supported");
 291         return;
 292     }
 293
 294     opts = qemu_opts_find(olist, "default");
 295     if (opts) {
 296         qemu_opts_del(opts);
 297     }
 298     opts = vnc_parse(target, errp);
 299     if (!opts) {
 300         return;
 301     }
 302
 303     vnc_display_open("default", errp);
 304 }
 305
 306 static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
 307                            Error **errp)
 308 {
 309     if (strcmp(target, "passwd") == 0 || strcmp(target, "password") == 0) {
 310         if (!has_arg) {
 311             error_setg(errp, QERR_MISSING_PARAMETER, "password");
 312         } else {
 313             qmp_change_vnc_password(arg, errp);
 314         }
 315     } else {
 316         qmp_change_vnc_listen(target, errp);
 317     }
 318 }
 319 #endif /* !CONFIG_VNC */
 320
 321 void qmp_change(const char *device, const char *target,
 322                 bool has_arg, const char *arg, Error **errp)
 323 {
 324     if (strcmp(device, "vnc") == 0) {
 325 #ifdef CONFIG_VNC
 326         qmp_change_vnc(target, has_arg, arg, errp);
 327 #else
 328         error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
 329 #endif
 330     } else {
 331         qmp_blockdev_change_medium(true, device, false, NULL, target,
 332                                    has_arg, arg, false, 0, errp);
 333     }
 334 }
 335
 336 void qmp_add_client(const char *protocol, const char *fdname,
 337                     bool has_skipauth, bool skipauth, bool has_tls, bool tls,
 338                     Error **errp)
 339 {
 340     Chardev *s;
 341     int fd;
 342
 343     fd = monitor_get_fd(cur_mon, fdname, errp);
 344     if (fd < 0) {
 345         return;
 346     }
 347
 348     if (strcmp(protocol, "spice") == 0) {
 349         if (!qemu_using_spice(errp)) {
 350             close(fd);
 351             return;
 352         }
 353         skipauth = has_skipauth ? skipauth : false;
 354         tls = has_tls ? tls : false;
 355         if (qemu_spice_display_add_client(fd, skipauth, tls) < 0) {
 356             error_setg(errp, "spice failed to add client");
 357             close(fd);
 358         }
 359         return;
 360 #ifdef CONFIG_VNC
 361     } else if (strcmp(protocol, "vnc") == 0) {
 362         skipauth = has_skipauth ? skipauth : false;
 363         vnc_display_add_client(NULL, fd, skipauth);
 364         return;
 365 #endif
 366     } else if ((s = qemu_chr_find(protocol)) != NULL) {
 367         if (qemu_chr_add_client(s, fd) < 0) {
 368             error_setg(errp, "failed to add client");
 369             close(fd);
 370             return;
 371         }
 372         return;
 373     }
 374
 375     error_setg(errp, "protocol '%s' is invalid", protocol);
 376     close(fd);
 377 }
 378
 379
 380 MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
 381 {
 382     return qmp_memory_device_list();
 383 }
 384
 385 ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
 386 {
 387     bool ambig;
 388     ACPIOSTInfoList *head = NULL;
 389     ACPIOSTInfoList **prev = &head;
 390     Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);
 391
 392     if (obj) {
 393         AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
 394         AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);
 395
 396         adevc->ospm_status(adev, &prev);
 397     } else {
 398         error_setg(errp, "command is not supported, missing ACPI device");
 399     }
 400
 401     return head;
 402 }
 403
 404 MemoryInfo *qmp_query_memory_size_summary(Error **errp)
 405 {
 406     MemoryInfo *mem_info = g_malloc0(sizeof(MemoryInfo));
 407
 408     mem_info->base_memory = ram_size;
 409
 410     mem_info->plugged_memory = get_plugged_memory_size();
 411     mem_info->has_plugged_memory =
 412         mem_info->plugged_memory != (uint64_t)-1;
 413
 414     return mem_info;
 415 }