configure: fix --meson=/path/to/meson
[qemu.git] / 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(cur_mon, 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 }