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