qmp.c

   1 /*
   2  * QEMU Management Protocol
   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-common.h"
  17 #include "sysemu.h"
  18 #include "qmp-commands.h"
  19 #include "ui/qemu-spice.h"
  20 #include "ui/vnc.h"
  21 #include "kvm.h"
  22 #include "arch_init.h"
  23 #include "hw/qdev.h"
  24 #include "qapi/qmp-input-visitor.h"
  25 #include "qapi/qmp-output-visitor.h"
  26 #include "blockdev.h"
  27
  28 NameInfo *qmp_query_name(Error **errp)
  29 {
  30     NameInfo *info = g_malloc0(sizeof(*info));
  31
  32     if (qemu_name) {
  33         info->has_name = true;
  34         info->name = g_strdup(qemu_name);
  35     }
  36
  37     return info;
  38 }
  39
  40 VersionInfo *qmp_query_version(Error **err)
  41 {
  42     VersionInfo *info = g_malloc0(sizeof(*info));
  43     const char *version = QEMU_VERSION;
  44     char *tmp;
  45
  46     info->qemu.major = strtol(version, &tmp, 10);
  47     tmp++;
  48     info->qemu.minor = strtol(tmp, &tmp, 10);
  49     tmp++;
  50     info->qemu.micro = strtol(tmp, &tmp, 10);
  51     info->package = g_strdup(QEMU_PKGVERSION);
  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     char uuid[64];
  70
  71     snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
  72                    qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
  73                    qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
  74                    qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
  75                    qemu_uuid[14], qemu_uuid[15]);
  76
  77     info->UUID = g_strdup(uuid);
  78     return info;
  79 }
  80
  81 void qmp_quit(Error **err)
  82 {
  83     no_shutdown = 0;
  84     qemu_system_shutdown_request();
  85 }
  86
  87 void qmp_stop(Error **errp)
  88 {
  89     vm_stop(RUN_STATE_PAUSED);
  90 }
  91
  92 void qmp_system_reset(Error **errp)
  93 {
  94     qemu_system_reset_request();
  95 }
  96
  97 void qmp_system_powerdown(Error **erp)
  98 {
  99     qemu_system_powerdown_request();
 100 }
 101
 102 void qmp_cpu(int64_t index, Error **errp)
 103 {
 104     /* Just do nothing */
 105 }
 106
 107 #ifndef CONFIG_VNC
 108 /* If VNC support is enabled, the "true" query-vnc command is
 109    defined in the VNC subsystem */
 110 VncInfo *qmp_query_vnc(Error **errp)
 111 {
 112     error_set(errp, QERR_FEATURE_DISABLED, "vnc");
 113     return NULL;
 114 };
 115 #endif
 116
 117 #ifndef CONFIG_SPICE
 118 /* If SPICE support is enabled, the "true" query-spice command is
 119    defined in the SPICE subsystem. Also note that we use a small
 120    trick to maintain query-spice's original behavior, which is not
 121    to be available in the namespace if SPICE is not compiled in */
 122 SpiceInfo *qmp_query_spice(Error **errp)
 123 {
 124     error_set(errp, QERR_COMMAND_NOT_FOUND, "query-spice");
 125     return NULL;
 126 };
 127 #endif
 128
 129 static void iostatus_bdrv_it(void *opaque, BlockDriverState *bs)
 130 {
 131     bdrv_iostatus_reset(bs);
 132 }
 133
 134 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
 135 {
 136     Error **err = opaque;
 137
 138     if (!error_is_set(err) && bdrv_key_required(bs)) {
 139         error_set(err, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
 140                   bdrv_get_encrypted_filename(bs));
 141     }
 142 }
 143
 144 void qmp_cont(Error **errp)
 145 {
 146     Error *local_err = NULL;
 147
 148     if (runstate_check(RUN_STATE_INMIGRATE)) {
 149         error_set(errp, QERR_MIGRATION_EXPECTED);
 150         return;
 151     } else if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||
 152                runstate_check(RUN_STATE_SHUTDOWN)) {
 153         error_set(errp, QERR_RESET_REQUIRED);
 154         return;
 155     }
 156
 157     bdrv_iterate(iostatus_bdrv_it, NULL);
 158     bdrv_iterate(encrypted_bdrv_it, &local_err);
 159     if (local_err) {
 160         error_propagate(errp, local_err);
 161         return;
 162     }
 163
 164     vm_start();
 165 }
 166
 167 DevicePropertyInfoList *qmp_qom_list(const char *path, Error **errp)
 168 {
 169     DeviceState *dev;
 170     bool ambiguous = false;
 171     DevicePropertyInfoList *props = NULL;
 172     DeviceProperty *prop;
 173
 174     dev = qdev_resolve_path(path, &ambiguous);
 175     if (dev == NULL) {
 176         error_set(errp, QERR_DEVICE_NOT_FOUND, path);
 177         return NULL;
 178     }
 179
 180     QTAILQ_FOREACH(prop, &dev->properties, node) {
 181         DevicePropertyInfoList *entry = g_malloc0(sizeof(*entry));
 182
 183         entry->value = g_malloc0(sizeof(DevicePropertyInfo));
 184         entry->next = props;
 185         props = entry;
 186
 187         entry->value->name = g_strdup(prop->name);
 188         entry->value->type = g_strdup(prop->type);
 189     }
 190
 191     return props;
 192 }
 193
 194 /* FIXME: teach qapi about how to pass through Visitors */
 195 int qmp_qom_set(Monitor *mon, const QDict *qdict, QObject **ret)
 196 {
 197     const char *path = qdict_get_str(qdict, "path");
 198     const char *property = qdict_get_str(qdict, "property");
 199     QObject *value = qdict_get(qdict, "value");
 200     Error *local_err = NULL;
 201     QmpInputVisitor *mi;
 202     DeviceState *dev;
 203
 204     dev = qdev_resolve_path(path, NULL);
 205     if (!dev) {
 206         error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
 207         goto out;
 208     }
 209
 210     mi = qmp_input_visitor_new(value);
 211     qdev_property_set(dev, qmp_input_get_visitor(mi), property, &local_err);
 212
 213     qmp_input_visitor_cleanup(mi);
 214
 215 out:
 216     if (local_err) {
 217         qerror_report_err(local_err);
 218         error_free(local_err);
 219         return -1;
 220     }
 221
 222     return 0;
 223 }
 224
 225 int qmp_qom_get(Monitor *mon, const QDict *qdict, QObject **ret)
 226 {
 227     const char *path = qdict_get_str(qdict, "path");
 228     const char *property = qdict_get_str(qdict, "property");
 229     Error *local_err = NULL;
 230     QmpOutputVisitor *mo;
 231     DeviceState *dev;
 232
 233     dev = qdev_resolve_path(path, NULL);
 234     if (!dev) {
 235         error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
 236         goto out;
 237     }
 238
 239     mo = qmp_output_visitor_new();
 240     qdev_property_get(dev, qmp_output_get_visitor(mo), property, &local_err);
 241     if (!local_err) {
 242         *ret = qmp_output_get_qobject(mo);
 243     }
 244
 245     qmp_output_visitor_cleanup(mo);
 246
 247 out:
 248     if (local_err) {
 249         qerror_report_err(local_err);
 250         error_free(local_err);
 251         return -1;
 252     }
 253
 254     return 0;
 255 }
 256
 257 void qmp_set_password(const char *protocol, const char *password,
 258                       bool has_connected, const char *connected, Error **errp)
 259 {
 260     int disconnect_if_connected = 0;
 261     int fail_if_connected = 0;
 262     int rc;
 263
 264     if (has_connected) {
 265         if (strcmp(connected, "fail") == 0) {
 266             fail_if_connected = 1;
 267         } else if (strcmp(connected, "disconnect") == 0) {
 268             disconnect_if_connected = 1;
 269         } else if (strcmp(connected, "keep") == 0) {
 270             /* nothing */
 271         } else {
 272             error_set(errp, QERR_INVALID_PARAMETER, "connected");
 273             return;
 274         }
 275     }
 276
 277     if (strcmp(protocol, "spice") == 0) {
 278         if (!using_spice) {
 279             /* correct one? spice isn't a device ,,, */
 280             error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
 281             return;
 282         }
 283         rc = qemu_spice_set_passwd(password, fail_if_connected,
 284                                    disconnect_if_connected);
 285         if (rc != 0) {
 286             error_set(errp, QERR_SET_PASSWD_FAILED);
 287         }
 288         return;
 289     }
 290
 291     if (strcmp(protocol, "vnc") == 0) {
 292         if (fail_if_connected || disconnect_if_connected) {
 293             /* vnc supports "connected=keep" only */
 294             error_set(errp, QERR_INVALID_PARAMETER, "connected");
 295             return;
 296         }
 297         /* Note that setting an empty password will not disable login through
 298          * this interface. */
 299         rc = vnc_display_password(NULL, password);
 300         if (rc < 0) {
 301             error_set(errp, QERR_SET_PASSWD_FAILED);
 302         }
 303         return;
 304     }
 305
 306     error_set(errp, QERR_INVALID_PARAMETER, "protocol");
 307 }
 308
 309 void qmp_expire_password(const char *protocol, const char *whenstr,
 310                          Error **errp)
 311 {
 312     time_t when;
 313     int rc;
 314
 315     if (strcmp(whenstr, "now") == 0) {
 316         when = 0;
 317     } else if (strcmp(whenstr, "never") == 0) {
 318         when = TIME_MAX;
 319     } else if (whenstr[0] == '+') {
 320         when = time(NULL) + strtoull(whenstr+1, NULL, 10);
 321     } else {
 322         when = strtoull(whenstr, NULL, 10);
 323     }
 324
 325     if (strcmp(protocol, "spice") == 0) {
 326         if (!using_spice) {
 327             /* correct one? spice isn't a device ,,, */
 328             error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
 329             return;
 330         }
 331         rc = qemu_spice_set_pw_expire(when);
 332         if (rc != 0) {
 333             error_set(errp, QERR_SET_PASSWD_FAILED);
 334         }
 335         return;
 336     }
 337
 338     if (strcmp(protocol, "vnc") == 0) {
 339         rc = vnc_display_pw_expire(NULL, when);
 340         if (rc != 0) {
 341             error_set(errp, QERR_SET_PASSWD_FAILED);
 342         }
 343         return;
 344     }
 345
 346     error_set(errp, QERR_INVALID_PARAMETER, "protocol");
 347 }
 348
 349 #ifdef CONFIG_VNC
 350 void qmp_change_vnc_password(const char *password, Error **errp)
 351 {
 352     if (vnc_display_password(NULL, password) < 0) {
 353         error_set(errp, QERR_SET_PASSWD_FAILED);
 354     }
 355 }
 356
 357 static void qmp_change_vnc_listen(const char *target, Error **err)
 358 {
 359     if (vnc_display_open(NULL, target) < 0) {
 360         error_set(err, QERR_VNC_SERVER_FAILED, target);
 361     }
 362 }
 363
 364 static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
 365                            Error **errp)
 366 {
 367     if (strcmp(target, "passwd") == 0 || strcmp(target, "password") == 0) {
 368         if (!has_arg) {
 369             error_set(errp, QERR_MISSING_PARAMETER, "password");
 370         } else {
 371             qmp_change_vnc_password(arg, errp);
 372         }
 373     } else {
 374         qmp_change_vnc_listen(target, errp);
 375     }
 376 }
 377 #else
 378 void qmp_change_vnc_password(const char *password, Error **errp)
 379 {
 380     error_set(errp, QERR_FEATURE_DISABLED, "vnc");
 381 }
 382 static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
 383                            Error **errp)
 384 {
 385     error_set(errp, QERR_FEATURE_DISABLED, "vnc");
 386 }
 387 #endif /* !CONFIG_VNC */
 388
 389 void qmp_change(const char *device, const char *target,
 390                 bool has_arg, const char *arg, Error **err)
 391 {
 392     if (strcmp(device, "vnc") == 0) {
 393         qmp_change_vnc(target, has_arg, arg, err);
 394     } else {
 395         qmp_change_blockdev(device, target, has_arg, arg, err);
 396     }
 397 }