Merge remote-tracking branch 'remotes/bonzini-gitlab/tags/for-upstream' into staging
[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/console.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 #endif
255
256 void qmp_add_client(const char *protocol, const char *fdname,
257 bool has_skipauth, bool skipauth, bool has_tls, bool tls,
258 Error **errp)
259 {
260 Chardev *s;
261 int fd;
262
263 fd = monitor_get_fd(monitor_cur(), fdname, errp);
264 if (fd < 0) {
265 return;
266 }
267
268 if (strcmp(protocol, "spice") == 0) {
269 if (!qemu_using_spice(errp)) {
270 close(fd);
271 return;
272 }
273 skipauth = has_skipauth ? skipauth : false;
274 tls = has_tls ? tls : false;
275 if (qemu_spice.display_add_client(fd, skipauth, tls) < 0) {
276 error_setg(errp, "spice failed to add client");
277 close(fd);
278 }
279 return;
280 #ifdef CONFIG_VNC
281 } else if (strcmp(protocol, "vnc") == 0) {
282 skipauth = has_skipauth ? skipauth : false;
283 vnc_display_add_client(NULL, fd, skipauth);
284 return;
285 #endif
286 } else if ((s = qemu_chr_find(protocol)) != NULL) {
287 if (qemu_chr_add_client(s, fd) < 0) {
288 error_setg(errp, "failed to add client");
289 close(fd);
290 return;
291 }
292 return;
293 }
294
295 error_setg(errp, "protocol '%s' is invalid", protocol);
296 close(fd);
297 }
298
299
300 MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
301 {
302 return qmp_memory_device_list();
303 }
304
305 ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
306 {
307 bool ambig;
308 ACPIOSTInfoList *head = NULL;
309 ACPIOSTInfoList **prev = &head;
310 Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);
311
312 if (obj) {
313 AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
314 AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);
315
316 adevc->ospm_status(adev, &prev);
317 } else {
318 error_setg(errp, "command is not supported, missing ACPI device");
319 }
320
321 return head;
322 }
323
324 MemoryInfo *qmp_query_memory_size_summary(Error **errp)
325 {
326 MemoryInfo *mem_info = g_malloc0(sizeof(MemoryInfo));
327 MachineState *ms = MACHINE(qdev_get_machine());
328
329 mem_info->base_memory = ms->ram_size;
330
331 mem_info->plugged_memory = get_plugged_memory_size();
332 mem_info->has_plugged_memory =
333 mem_info->plugged_memory != (uint64_t)-1;
334
335 return mem_info;
336 }
337
338 void qmp_display_reload(DisplayReloadOptions *arg, Error **errp)
339 {
340 switch (arg->type) {
341 case DISPLAY_RELOAD_TYPE_VNC:
342 #ifdef CONFIG_VNC
343 if (arg->u.vnc.has_tls_certs && arg->u.vnc.tls_certs) {
344 vnc_display_reload_certs(NULL, errp);
345 }
346 #else
347 error_setg(errp, "vnc is invalid, missing 'CONFIG_VNC'");
348 #endif
349 break;
350 default:
351 abort();
352 }
353 }