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 } 388