]>
Commit | Line | Data |
---|---|---|
48a32bed | 1 | /* |
f1b3ccfa | 2 | * QEMU Management Protocol commands |
48a32bed AL |
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 | * | |
6b620ca3 PB |
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. | |
48a32bed AL |
14 | */ |
15 | ||
d38ea87a | 16 | #include "qemu/osdep.h" |
a8d25326 | 17 | #include "qemu-common.h" |
f348b6d1 | 18 | #include "qemu/cutils.h" |
922a01a0 | 19 | #include "qemu/option.h" |
a0b1a66e | 20 | #include "monitor/monitor.h" |
9c17d615 | 21 | #include "sysemu/sysemu.h" |
213dcb06 | 22 | #include "qemu/config-file.h" |
cea25275 | 23 | #include "qemu/uuid.h" |
8228e353 | 24 | #include "chardev/char.h" |
fbf796fd LC |
25 | #include "ui/qemu-spice.h" |
26 | #include "ui/vnc.h" | |
9c17d615 | 27 | #include "sysemu/kvm.h" |
54d31236 | 28 | #include "sysemu/runstate.h" |
9c17d615 | 29 | #include "sysemu/arch_init.h" |
9c17d615 | 30 | #include "sysemu/blockdev.h" |
373340b2 | 31 | #include "sysemu/block-backend.h" |
e688df6b | 32 | #include "qapi/error.h" |
27c9188f | 33 | #include "qapi/qapi-commands-acpi.h" |
5a16818b | 34 | #include "qapi/qapi-commands-block.h" |
fa4dcf57 | 35 | #include "qapi/qapi-commands-control.h" |
8ac25c84 | 36 | #include "qapi/qapi-commands-machine.h" |
112ed241 MA |
37 | #include "qapi/qapi-commands-misc.h" |
38 | #include "qapi/qapi-commands-ui.h" | |
cc7a8ea7 | 39 | #include "qapi/qmp/qerror.h" |
2cc0e2e8 | 40 | #include "hw/mem/memory-device.h" |
02419bcb | 41 | #include "hw/acpi/acpi_dev_interface.h" |
48a32bed AL |
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 | } | |
b9c15f16 | 54 | |
292a2602 LC |
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 | ||
efab767e LC |
65 | UuidInfo *qmp_query_uuid(Error **errp) |
66 | { | |
67 | UuidInfo *info = g_malloc0(sizeof(*info)); | |
efab767e | 68 | |
9c5ce8db | 69 | info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid); |
efab767e LC |
70 | return info; |
71 | } | |
72 | ||
7daecb30 | 73 | void qmp_quit(Error **errp) |
7a7f325e LC |
74 | { |
75 | no_shutdown = 0; | |
92548938 | 76 | qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_QMP_QUIT); |
7a7f325e LC |
77 | } |
78 | ||
5f158f21 LC |
79 | void qmp_stop(Error **errp) |
80 | { | |
65d64f36 PX |
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 | ||
1e998146 PB |
88 | if (runstate_check(RUN_STATE_INMIGRATE)) { |
89 | autostart = 0; | |
90 | } else { | |
91 | vm_stop(RUN_STATE_PAUSED); | |
92 | } | |
5f158f21 LC |
93 | } |
94 | ||
38d22653 LC |
95 | void qmp_system_reset(Error **errp) |
96 | { | |
92548938 | 97 | qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP_SYSTEM_RESET); |
38d22653 | 98 | } |
5bc465e4 | 99 | |
ec48595e | 100 | void qmp_system_powerdown(Error **errp) |
5bc465e4 LC |
101 | { |
102 | qemu_system_powerdown_request(); | |
103 | } | |
755f1968 | 104 | |
361ac948 | 105 | void qmp_x_exit_preconfig(Error **errp) |
047f7038 IM |
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 | ||
e42e818b LC |
115 | void qmp_cont(Error **errp) |
116 | { | |
373340b2 | 117 | BlockBackend *blk; |
68d00e42 | 118 | BlockJob *job; |
788cf9f8 | 119 | Error *local_err = NULL; |
e42e818b | 120 | |
65d64f36 PX |
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 | ||
ede085b3 | 128 | if (runstate_needs_reset()) { |
f231b88d | 129 | error_setg(errp, "Resetting the Virtual Machine is required"); |
e42e818b | 130 | return; |
ad02b96a LC |
131 | } else if (runstate_check(RUN_STATE_SUSPENDED)) { |
132 | return; | |
9183dd15 VSO |
133 | } else if (runstate_check(RUN_STATE_FINISH_MIGRATE)) { |
134 | error_setg(errp, "Migration is not finalized yet"); | |
135 | return; | |
e42e818b LC |
136 | } |
137 | ||
373340b2 HR |
138 | for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { |
139 | blk_iostatus_reset(blk); | |
ab31979a | 140 | } |
7c8eece4 | 141 | |
68d00e42 VSO |
142 | for (job = block_job_next(NULL); job; job = block_job_next(job)) { |
143 | block_job_iostatus_reset(job); | |
144 | } | |
145 | ||
76b1c7fe | 146 | /* Continuing after completed migration. Images have been inactivated to |
ace21a58 KW |
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; | |
76b1c7fe KW |
156 | } |
157 | ||
1e998146 PB |
158 | if (runstate_check(RUN_STATE_INMIGRATE)) { |
159 | autostart = 1; | |
160 | } else { | |
161 | vm_start(); | |
162 | } | |
e42e818b | 163 | } |
b4b12c62 | 164 | |
9b9df25a GH |
165 | void qmp_system_wakeup(Error **errp) |
166 | { | |
fb064112 DHB |
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); | |
9b9df25a GH |
174 | } |
175 | ||
fbf796fd LC |
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 { | |
c6bd8c70 | 191 | error_setg(errp, QERR_INVALID_PARAMETER, "connected"); |
fbf796fd LC |
192 | return; |
193 | } | |
194 | } | |
195 | ||
196 | if (strcmp(protocol, "spice") == 0) { | |
b25d81ba | 197 | if (!qemu_using_spice(errp)) { |
fbf796fd LC |
198 | return; |
199 | } | |
08ad2626 | 200 | rc = qemu_spice.set_passwd(password, fail_if_connected, |
fbf796fd | 201 | disconnect_if_connected); |
9272186d | 202 | } else if (strcmp(protocol, "vnc") == 0) { |
fbf796fd LC |
203 | if (fail_if_connected || disconnect_if_connected) { |
204 | /* vnc supports "connected=keep" only */ | |
c6bd8c70 | 205 | error_setg(errp, QERR_INVALID_PARAMETER, "connected"); |
fbf796fd LC |
206 | return; |
207 | } | |
208 | /* Note that setting an empty password will not disable login through | |
209 | * this interface. */ | |
210 | rc = vnc_display_password(NULL, password); | |
9272186d MA |
211 | } else { |
212 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", | |
213 | "'vnc' or 'spice'"); | |
fbf796fd LC |
214 | return; |
215 | } | |
216 | ||
9272186d MA |
217 | if (rc != 0) { |
218 | error_setg(errp, "Could not set password"); | |
219 | } | |
fbf796fd | 220 | } |
9ad5372d LC |
221 | |
222 | void qmp_expire_password(const char *protocol, const char *whenstr, | |
223 | Error **errp) | |
224 | { | |
225 | time_t when; | |
226 | int rc; | |
227 | ||
228 | if (strcmp(whenstr, "now") == 0) { | |
229 | when = 0; | |
230 | } else if (strcmp(whenstr, "never") == 0) { | |
231 | when = TIME_MAX; | |
232 | } else if (whenstr[0] == '+') { | |
233 | when = time(NULL) + strtoull(whenstr+1, NULL, 10); | |
234 | } else { | |
235 | when = strtoull(whenstr, NULL, 10); | |
236 | } | |
237 | ||
238 | if (strcmp(protocol, "spice") == 0) { | |
b25d81ba | 239 | if (!qemu_using_spice(errp)) { |
9ad5372d LC |
240 | return; |
241 | } | |
08ad2626 | 242 | rc = qemu_spice.set_pw_expire(when); |
9272186d | 243 | } else if (strcmp(protocol, "vnc") == 0) { |
9ad5372d | 244 | rc = vnc_display_pw_expire(NULL, when); |
9272186d MA |
245 | } else { |
246 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", | |
247 | "'vnc' or 'spice'"); | |
9ad5372d LC |
248 | return; |
249 | } | |
250 | ||
9272186d MA |
251 | if (rc != 0) { |
252 | error_setg(errp, "Could not set password expire time"); | |
253 | } | |
9ad5372d | 254 | } |
270b243f | 255 | |
333a96ec | 256 | #ifdef CONFIG_VNC |
270b243f LC |
257 | void qmp_change_vnc_password(const char *password, Error **errp) |
258 | { | |
259 | if (vnc_display_password(NULL, password) < 0) { | |
9272186d | 260 | error_setg(errp, "Could not set password"); |
270b243f LC |
261 | } |
262 | } | |
333a96ec | 263 | |
007fcd3e | 264 | static void qmp_change_vnc_listen(const char *target, Error **errp) |
333a96ec | 265 | { |
4db14629 GH |
266 | QemuOptsList *olist = qemu_find_opts("vnc"); |
267 | QemuOpts *opts; | |
268 | ||
269 | if (strstr(target, "id=")) { | |
270 | error_setg(errp, "id not supported"); | |
271 | return; | |
272 | } | |
273 | ||
274 | opts = qemu_opts_find(olist, "default"); | |
275 | if (opts) { | |
276 | qemu_opts_del(opts); | |
277 | } | |
70b94331 | 278 | opts = vnc_parse(target, errp); |
f7801c5c GA |
279 | if (!opts) { |
280 | return; | |
281 | } | |
282 | ||
4db14629 | 283 | vnc_display_open("default", errp); |
333a96ec LC |
284 | } |
285 | ||
286 | static void qmp_change_vnc(const char *target, bool has_arg, const char *arg, | |
287 | Error **errp) | |
288 | { | |
289 | if (strcmp(target, "passwd") == 0 || strcmp(target, "password") == 0) { | |
290 | if (!has_arg) { | |
c6bd8c70 | 291 | error_setg(errp, QERR_MISSING_PARAMETER, "password"); |
333a96ec LC |
292 | } else { |
293 | qmp_change_vnc_password(arg, errp); | |
294 | } | |
295 | } else { | |
296 | qmp_change_vnc_listen(target, errp); | |
297 | } | |
298 | } | |
333a96ec LC |
299 | #endif /* !CONFIG_VNC */ |
300 | ||
301 | void qmp_change(const char *device, const char *target, | |
7daecb30 | 302 | bool has_arg, const char *arg, Error **errp) |
333a96ec LC |
303 | { |
304 | if (strcmp(device, "vnc") == 0) { | |
05eb4a25 | 305 | #ifdef CONFIG_VNC |
7daecb30 | 306 | qmp_change_vnc(target, has_arg, arg, errp); |
05eb4a25 MAL |
307 | #else |
308 | error_setg(errp, QERR_FEATURE_DISABLED, "vnc"); | |
309 | #endif | |
333a96ec | 310 | } else { |
70e2cb3b KW |
311 | qmp_blockdev_change_medium(true, device, false, NULL, target, |
312 | has_arg, arg, false, 0, errp); | |
333a96ec LC |
313 | } |
314 | } | |
5eeee3fa | 315 | |
b224e5e2 LC |
316 | void qmp_add_client(const char *protocol, const char *fdname, |
317 | bool has_skipauth, bool skipauth, bool has_tls, bool tls, | |
318 | Error **errp) | |
319 | { | |
0ec7b3e7 | 320 | Chardev *s; |
b224e5e2 LC |
321 | int fd; |
322 | ||
947e4744 | 323 | fd = monitor_get_fd(monitor_cur(), fdname, errp); |
b224e5e2 LC |
324 | if (fd < 0) { |
325 | return; | |
326 | } | |
327 | ||
328 | if (strcmp(protocol, "spice") == 0) { | |
b25d81ba | 329 | if (!qemu_using_spice(errp)) { |
b224e5e2 LC |
330 | close(fd); |
331 | return; | |
332 | } | |
333 | skipauth = has_skipauth ? skipauth : false; | |
334 | tls = has_tls ? tls : false; | |
864a024c | 335 | if (qemu_spice.display_add_client(fd, skipauth, tls) < 0) { |
b224e5e2 LC |
336 | error_setg(errp, "spice failed to add client"); |
337 | close(fd); | |
338 | } | |
339 | return; | |
340 | #ifdef CONFIG_VNC | |
341 | } else if (strcmp(protocol, "vnc") == 0) { | |
342 | skipauth = has_skipauth ? skipauth : false; | |
343 | vnc_display_add_client(NULL, fd, skipauth); | |
344 | return; | |
345 | #endif | |
346 | } else if ((s = qemu_chr_find(protocol)) != NULL) { | |
347 | if (qemu_chr_add_client(s, fd) < 0) { | |
348 | error_setg(errp, "failed to add client"); | |
349 | close(fd); | |
350 | return; | |
351 | } | |
352 | return; | |
353 | } | |
354 | ||
355 | error_setg(errp, "protocol '%s' is invalid", protocol); | |
356 | close(fd); | |
357 | } | |
ab2d0531 | 358 | |
cff8b2c6 | 359 | |
6f2e2730 IM |
360 | MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp) |
361 | { | |
2cc0e2e8 | 362 | return qmp_memory_device_list(); |
6f2e2730 | 363 | } |
02419bcb IM |
364 | |
365 | ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp) | |
366 | { | |
367 | bool ambig; | |
368 | ACPIOSTInfoList *head = NULL; | |
369 | ACPIOSTInfoList **prev = &head; | |
370 | Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig); | |
371 | ||
372 | if (obj) { | |
373 | AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj); | |
374 | AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj); | |
375 | ||
376 | adevc->ospm_status(adev, &prev); | |
377 | } else { | |
378 | error_setg(errp, "command is not supported, missing ACPI device"); | |
379 | } | |
380 | ||
381 | return head; | |
382 | } | |
9aa3397f VG |
383 | |
384 | MemoryInfo *qmp_query_memory_size_summary(Error **errp) | |
385 | { | |
386 | MemoryInfo *mem_info = g_malloc0(sizeof(MemoryInfo)); | |
b326b6ea | 387 | MachineState *ms = MACHINE(qdev_get_machine()); |
9aa3397f | 388 | |
b326b6ea | 389 | mem_info->base_memory = ms->ram_size; |
9aa3397f VG |
390 | |
391 | mem_info->plugged_memory = get_plugged_memory_size(); | |
392 | mem_info->has_plugged_memory = | |
393 | mem_info->plugged_memory != (uint64_t)-1; | |
394 | ||
395 | return mem_info; | |
396 | } |