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/console.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 #endif
 255
 256 void qmp_add_client(const char *protocol, const char *fdname,
 257                     bool has_skipauth, bool skipauth, bool has_tls, bool tls,
 258                     Error **errp)
 259 {
 260     Chardev *s;
 261     int fd;
 262
 263     fd = monitor_get_fd(monitor_cur(), fdname, errp);
 264     if (fd < 0) {
 265         return;
 266     }
 267
 268     if (strcmp(protocol, "spice") == 0) {
 269         if (!qemu_using_spice(errp)) {
 270             close(fd);
 271             return;
 272         }
 273         skipauth = has_skipauth ? skipauth : false;
 274         tls = has_tls ? tls : false;
 275         if (qemu_spice.display_add_client(fd, skipauth, tls) < 0) {
 276             error_setg(errp, "spice failed to add client");
 277             close(fd);
 278         }
 279         return;
 280 #ifdef CONFIG_VNC
 281     } else if (strcmp(protocol, "vnc") == 0) {
 282         skipauth = has_skipauth ? skipauth : false;
 283         vnc_display_add_client(NULL, fd, skipauth);
 284         return;
 285 #endif
 286     } else if ((s = qemu_chr_find(protocol)) != NULL) {
 287         if (qemu_chr_add_client(s, fd) < 0) {
 288             error_setg(errp, "failed to add client");
 289             close(fd);
 290             return;
 291         }
 292         return;
 293     }
 294
 295     error_setg(errp, "protocol '%s' is invalid", protocol);
 296     close(fd);
 297 }
 298
 299
 300 MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
 301 {
 302     return qmp_memory_device_list();
 303 }
 304
 305 ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
 306 {
 307     bool ambig;
 308     ACPIOSTInfoList *head = NULL;
 309     ACPIOSTInfoList **prev = &head;
 310     Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);
 311
 312     if (obj) {
 313         AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
 314         AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);
 315
 316         adevc->ospm_status(adev, &prev);
 317     } else {
 318         error_setg(errp, "command is not supported, missing ACPI device");
 319     }
 320
 321     return head;
 322 }
 323
 324 MemoryInfo *qmp_query_memory_size_summary(Error **errp)
 325 {
 326     MemoryInfo *mem_info = g_malloc0(sizeof(MemoryInfo));
 327     MachineState *ms = MACHINE(qdev_get_machine());
 328
 329     mem_info->base_memory = ms->ram_size;
 330
 331     mem_info->plugged_memory = get_plugged_memory_size();
 332     mem_info->has_plugged_memory =
 333         mem_info->plugged_memory != (uint64_t)-1;
 334
 335     return mem_info;
 336 }