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 396 mem_info->base_memory = ram_size; 397 398 mem_info->plugged_memory = get_plugged_memory_size(); 399 mem_info->has_plugged_memory = 400 mem_info->plugged_memory != (uint64_t)-1; 401 402 return mem_info; 403 } 404