monitor/qmp-cmds.c

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