blob: ab74cd729d345fc5c7f975482425f06525db9497 [file] [log] [blame]
Anthony Liguori48a32be2011-09-02 12:34:48 -05001/*
2 * QEMU Management Protocol
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 *
Paolo Bonzini6b620ca2012-01-13 17:44:23 +010012 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
Anthony Liguori48a32be2011-09-02 12:34:48 -050014 */
15
Peter Maydelld38ea872016-01-29 17:50:05 +000016#include "qemu/osdep.h"
Fam Zheng67a1de02016-06-01 17:44:21 +080017#include "qemu-version.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020018#include "qemu/cutils.h"
Markus Armbrustera0b1a662015-03-17 18:16:21 +010019#include "monitor/monitor.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010020#include "sysemu/sysemu.h"
Marc-André Lureau213dcb02016-12-12 20:22:24 +030021#include "qemu/config-file.h"
Fam Zhengcea25272016-09-21 12:27:14 +080022#include "qemu/uuid.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050023#include "qmp-commands.h"
Paolo Bonzinidccfcd02013-04-08 16:55:25 +020024#include "sysemu/char.h"
Luiz Capitulinofbf796f2011-12-07 11:17:51 -020025#include "ui/qemu-spice.h"
26#include "ui/vnc.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010027#include "sysemu/kvm.h"
28#include "sysemu/arch_init.h"
Anthony Liguorib4b12c62011-12-12 14:29:34 -060029#include "hw/qdev.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010030#include "sysemu/blockdev.h"
Max Reitz373340b2015-10-19 17:53:22 +020031#include "sysemu/block-backend.h"
Paolo Bonzini14cccb62012-12-17 18:19:50 +010032#include "qom/qom-qobject.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010033#include "qapi/qmp/qerror.h"
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +010034#include "qapi/qmp/qobject.h"
Daniel P. Berrangeb3db2112016-09-30 15:45:27 +010035#include "qapi/qobject-input-visitor.h"
Igor Mammedov69ca3ea2013-04-30 15:41:25 +020036#include "hw/boards.h"
Igor Mammedov269e09f2014-01-16 17:34:38 +010037#include "qom/object_interfaces.h"
Igor Mammedov6f2e2732014-06-16 19:12:25 +020038#include "hw/mem/pc-dimm.h"
Igor Mammedov02419bc2014-06-16 19:12:28 +020039#include "hw/acpi/acpi_dev_interface.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050040
41NameInfo *qmp_query_name(Error **errp)
42{
43 NameInfo *info = g_malloc0(sizeof(*info));
44
45 if (qemu_name) {
46 info->has_name = true;
47 info->name = g_strdup(qemu_name);
48 }
49
50 return info;
51}
Luiz Capitulinob9c15f12011-08-26 17:38:13 -030052
Markus Armbruster7daecb32014-05-02 13:26:31 +020053VersionInfo *qmp_query_version(Error **errp)
Luiz Capitulinob9c15f12011-08-26 17:38:13 -030054{
Eric Blake4752cdb2015-05-04 09:05:31 -060055 VersionInfo *info = g_new0(VersionInfo, 1);
Luiz Capitulinob9c15f12011-08-26 17:38:13 -030056
Eric Blake4752cdb2015-05-04 09:05:31 -060057 info->qemu = g_new0(VersionTriple, 1);
Marc-André Lureau3688d8c2016-09-12 13:18:56 +040058 info->qemu->major = QEMU_VERSION_MAJOR;
59 info->qemu->minor = QEMU_VERSION_MINOR;
60 info->qemu->micro = QEMU_VERSION_MICRO;
Luiz Capitulinob9c15f12011-08-26 17:38:13 -030061 info->package = g_strdup(QEMU_PKGVERSION);
62
63 return info;
64}
Luiz Capitulino292a2602011-09-12 15:10:53 -030065
66KvmInfo *qmp_query_kvm(Error **errp)
67{
68 KvmInfo *info = g_malloc0(sizeof(*info));
69
70 info->enabled = kvm_enabled();
71 info->present = kvm_available();
72
73 return info;
74}
75
Luiz Capitulinoefab7672011-09-13 17:16:25 -030076UuidInfo *qmp_query_uuid(Error **errp)
77{
78 UuidInfo *info = g_malloc0(sizeof(*info));
Luiz Capitulinoefab7672011-09-13 17:16:25 -030079
Fam Zheng9c5ce8d2016-09-21 12:27:22 +080080 info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
Luiz Capitulinoefab7672011-09-13 17:16:25 -030081 return info;
82}
83
Markus Armbruster7daecb32014-05-02 13:26:31 +020084void qmp_quit(Error **errp)
Luiz Capitulino7a7f3252011-09-15 14:20:28 -030085{
86 no_shutdown = 0;
87 qemu_system_shutdown_request();
88}
89
Luiz Capitulino5f158f22011-09-15 14:34:39 -030090void qmp_stop(Error **errp)
91{
Peter Xu65d64f32016-02-18 13:16:49 +080092 /* if there is a dump in background, we should wait until the dump
93 * finished */
94 if (dump_in_progress()) {
95 error_setg(errp, "There is a dump in process, please wait.");
96 return;
97 }
98
Paolo Bonzini1e998142012-10-23 14:54:21 +020099 if (runstate_check(RUN_STATE_INMIGRATE)) {
100 autostart = 0;
101 } else {
102 vm_stop(RUN_STATE_PAUSED);
103 }
Luiz Capitulino5f158f22011-09-15 14:34:39 -0300104}
105
Luiz Capitulino38d22652011-09-15 14:41:46 -0300106void qmp_system_reset(Error **errp)
107{
108 qemu_system_reset_request();
109}
Luiz Capitulino5bc465e2011-09-28 11:06:15 -0300110
111void qmp_system_powerdown(Error **erp)
112{
113 qemu_system_powerdown_request();
114}
Luiz Capitulino755f1962011-10-06 14:31:39 -0300115
116void qmp_cpu(int64_t index, Error **errp)
117{
118 /* Just do nothing */
119}
Luiz Capitulino2b54aa82011-10-17 16:41:22 -0200120
Igor Mammedov69ca3ea2013-04-30 15:41:25 +0200121void qmp_cpu_add(int64_t id, Error **errp)
122{
Marcel Apfelbaum0056ae22014-03-05 19:30:47 +0200123 MachineClass *mc;
124
125 mc = MACHINE_GET_CLASS(current_machine);
Marcel Apfelbaum958db902014-04-09 20:34:53 +0300126 if (mc->hot_add_cpu) {
127 mc->hot_add_cpu(id, errp);
Igor Mammedov69ca3ea2013-04-30 15:41:25 +0200128 } else {
129 error_setg(errp, "Not supported");
130 }
131}
132
Luiz Capitulino2b54aa82011-10-17 16:41:22 -0200133#ifndef CONFIG_VNC
134/* If VNC support is enabled, the "true" query-vnc command is
135 defined in the VNC subsystem */
136VncInfo *qmp_query_vnc(Error **errp)
137{
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100138 error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
Luiz Capitulino2b54aa82011-10-17 16:41:22 -0200139 return NULL;
140};
Leon Yu89db21772015-02-02 05:08:51 +0000141
142VncInfo2List *qmp_query_vnc_servers(Error **errp)
143{
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100144 error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
Leon Yu89db21772015-02-02 05:08:51 +0000145 return NULL;
146};
Luiz Capitulino2b54aa82011-10-17 16:41:22 -0200147#endif
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200148
149#ifndef CONFIG_SPICE
Markus Armbrusterad0ec142015-01-13 15:56:11 +0100150/*
151 * qmp-commands.hx ensures that QMP command query-spice exists only
152 * #ifdef CONFIG_SPICE. Necessary for an accurate query-commands
153 * result. However, the QAPI schema is blissfully unaware of that,
154 * and the QAPI code generator happily generates a dead
Markus Armbruster7fad30f2015-09-16 13:06:19 +0200155 * qmp_marshal_query_spice() that calls qmp_query_spice(). Provide it
156 * one, or else linking fails. FIXME Educate the QAPI schema on
157 * CONFIG_SPICE.
Markus Armbrusterad0ec142015-01-13 15:56:11 +0100158 */
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200159SpiceInfo *qmp_query_spice(Error **errp)
160{
Markus Armbrusterad0ec142015-01-13 15:56:11 +0100161 abort();
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200162};
163#endif
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200164
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200165void qmp_cont(Error **errp)
166{
Markus Armbruster4d2855a2015-01-29 10:37:00 +0100167 Error *local_err = NULL;
Max Reitz373340b2015-10-19 17:53:22 +0200168 BlockBackend *blk;
Markus Armbrusterab319792014-05-02 13:26:42 +0200169 BlockDriverState *bs;
Kevin Wolf88be7b42016-05-20 18:49:07 +0200170 BdrvNextIterator it;
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200171
Peter Xu65d64f32016-02-18 13:16:49 +0800172 /* if there is a dump in background, we should wait until the dump
173 * finished */
174 if (dump_in_progress()) {
175 error_setg(errp, "There is a dump in process, please wait.");
176 return;
177 }
178
Hu Taoede085b2013-04-26 11:24:40 +0800179 if (runstate_needs_reset()) {
Cole Robinsonf231b882014-03-21 19:42:26 -0400180 error_setg(errp, "Resetting the Virtual Machine is required");
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200181 return;
Luiz Capitulinoad02b962012-04-27 13:33:36 -0300182 } else if (runstate_check(RUN_STATE_SUSPENDED)) {
183 return;
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200184 }
185
Max Reitz373340b2015-10-19 17:53:22 +0200186 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
187 blk_iostatus_reset(blk);
Markus Armbrusterab319792014-05-02 13:26:42 +0200188 }
Kevin Wolf7c8eece2016-03-22 18:58:50 +0100189
Kevin Wolf88be7b42016-05-20 18:49:07 +0200190 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Markus Armbruster4d2855a2015-01-29 10:37:00 +0100191 bdrv_add_key(bs, NULL, &local_err);
192 if (local_err) {
193 error_propagate(errp, local_err);
Markus Armbrusterab319792014-05-02 13:26:42 +0200194 return;
195 }
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200196 }
197
Kevin Wolf76b1c7f2015-12-22 14:07:08 +0100198 /* Continuing after completed migration. Images have been inactivated to
199 * allow the destination to take control. Need to get control back now. */
200 if (runstate_check(RUN_STATE_FINISH_MIGRATE) ||
201 runstate_check(RUN_STATE_POSTMIGRATE))
202 {
203 bdrv_invalidate_cache_all(&local_err);
204 if (local_err) {
205 error_propagate(errp, local_err);
206 return;
207 }
208 }
209
Kevin Wolfd35ff5e2017-04-04 17:29:03 +0200210 blk_resume_after_migration(&local_err);
211 if (local_err) {
212 error_propagate(errp, local_err);
213 return;
214 }
215
Paolo Bonzini1e998142012-10-23 14:54:21 +0200216 if (runstate_check(RUN_STATE_INMIGRATE)) {
217 autostart = 1;
218 } else {
219 vm_start();
220 }
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200221}
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600222
Gerd Hoffmann9b9df252012-02-23 13:45:21 +0100223void qmp_system_wakeup(Error **errp)
224{
225 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
226}
227
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600228ObjectPropertyInfoList *qmp_qom_list(const char *path, Error **errp)
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600229{
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600230 Object *obj;
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600231 bool ambiguous = false;
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600232 ObjectPropertyInfoList *props = NULL;
233 ObjectProperty *prop;
Daniel P. Berrange7746abd2015-12-09 12:34:02 +0000234 ObjectPropertyIterator iter;
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600235
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600236 obj = object_resolve_path(path, &ambiguous);
237 if (obj == NULL) {
Michael Tokarev79772082014-05-04 12:23:59 +0400238 if (ambiguous) {
239 error_setg(errp, "Path '%s' is ambiguous", path);
240 } else {
Markus Armbruster75158eb2015-03-16 08:57:47 +0100241 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
242 "Device '%s' not found", path);
Michael Tokarev79772082014-05-04 12:23:59 +0400243 }
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600244 return NULL;
245 }
246
Daniel P. Berrange7746abd2015-12-09 12:34:02 +0000247 object_property_iter_init(&iter, obj);
248 while ((prop = object_property_iter_next(&iter))) {
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600249 ObjectPropertyInfoList *entry = g_malloc0(sizeof(*entry));
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600250
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600251 entry->value = g_malloc0(sizeof(ObjectPropertyInfo));
Anthony Liguorib4b12c62011-12-12 14:29:34 -0600252 entry->next = props;
253 props = entry;
254
255 entry->value->name = g_strdup(prop->name);
256 entry->value->type = g_strdup(prop->type);
257 }
258
259 return props;
260}
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600261
Markus Armbruster6eb39372015-09-16 13:06:25 +0200262void qmp_qom_set(const char *path, const char *property, QObject *value,
263 Error **errp)
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600264{
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600265 Object *obj;
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600266
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600267 obj = object_resolve_path(path, NULL);
268 if (!obj) {
Markus Armbruster485febc2015-03-13 17:25:50 +0100269 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
Markus Armbruster75158eb2015-03-16 08:57:47 +0100270 "Device '%s' not found", path);
Markus Armbruster485febc2015-03-13 17:25:50 +0100271 return;
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600272 }
273
Markus Armbruster485febc2015-03-13 17:25:50 +0100274 object_property_set_qobject(obj, value, property, errp);
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600275}
276
Markus Armbruster6eb39372015-09-16 13:06:25 +0200277QObject *qmp_qom_get(const char *path, const char *property, Error **errp)
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600278{
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600279 Object *obj;
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600280
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600281 obj = object_resolve_path(path, NULL);
282 if (!obj) {
Markus Armbruster485febc2015-03-13 17:25:50 +0100283 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
Markus Armbruster75158eb2015-03-16 08:57:47 +0100284 "Device '%s' not found", path);
Markus Armbruster6eb39372015-09-16 13:06:25 +0200285 return NULL;
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600286 }
287
Markus Armbruster6eb39372015-09-16 13:06:25 +0200288 return object_property_get_qobject(obj, property, errp);
Anthony Liguorieb6e8ea2011-12-12 14:29:35 -0600289}
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200290
291void qmp_set_password(const char *protocol, const char *password,
292 bool has_connected, const char *connected, Error **errp)
293{
294 int disconnect_if_connected = 0;
295 int fail_if_connected = 0;
296 int rc;
297
298 if (has_connected) {
299 if (strcmp(connected, "fail") == 0) {
300 fail_if_connected = 1;
301 } else if (strcmp(connected, "disconnect") == 0) {
302 disconnect_if_connected = 1;
303 } else if (strcmp(connected, "keep") == 0) {
304 /* nothing */
305 } else {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100306 error_setg(errp, QERR_INVALID_PARAMETER, "connected");
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200307 return;
308 }
309 }
310
311 if (strcmp(protocol, "spice") == 0) {
Markus Armbrusterb25d81b2015-01-13 17:07:15 +0100312 if (!qemu_using_spice(errp)) {
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200313 return;
314 }
315 rc = qemu_spice_set_passwd(password, fail_if_connected,
316 disconnect_if_connected);
317 if (rc != 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100318 error_setg(errp, QERR_SET_PASSWD_FAILED);
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200319 }
320 return;
321 }
322
323 if (strcmp(protocol, "vnc") == 0) {
324 if (fail_if_connected || disconnect_if_connected) {
325 /* vnc supports "connected=keep" only */
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100326 error_setg(errp, QERR_INVALID_PARAMETER, "connected");
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200327 return;
328 }
329 /* Note that setting an empty password will not disable login through
330 * this interface. */
331 rc = vnc_display_password(NULL, password);
332 if (rc < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100333 error_setg(errp, QERR_SET_PASSWD_FAILED);
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200334 }
335 return;
336 }
337
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100338 error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
Luiz Capitulinofbf796f2011-12-07 11:17:51 -0200339}
Luiz Capitulino9ad53722011-12-07 11:47:57 -0200340
341void qmp_expire_password(const char *protocol, const char *whenstr,
342 Error **errp)
343{
344 time_t when;
345 int rc;
346
347 if (strcmp(whenstr, "now") == 0) {
348 when = 0;
349 } else if (strcmp(whenstr, "never") == 0) {
350 when = TIME_MAX;
351 } else if (whenstr[0] == '+') {
352 when = time(NULL) + strtoull(whenstr+1, NULL, 10);
353 } else {
354 when = strtoull(whenstr, NULL, 10);
355 }
356
357 if (strcmp(protocol, "spice") == 0) {
Markus Armbrusterb25d81b2015-01-13 17:07:15 +0100358 if (!qemu_using_spice(errp)) {
Luiz Capitulino9ad53722011-12-07 11:47:57 -0200359 return;
360 }
361 rc = qemu_spice_set_pw_expire(when);
362 if (rc != 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100363 error_setg(errp, QERR_SET_PASSWD_FAILED);
Luiz Capitulino9ad53722011-12-07 11:47:57 -0200364 }
365 return;
366 }
367
368 if (strcmp(protocol, "vnc") == 0) {
369 rc = vnc_display_pw_expire(NULL, when);
370 if (rc != 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100371 error_setg(errp, QERR_SET_PASSWD_FAILED);
Luiz Capitulino9ad53722011-12-07 11:47:57 -0200372 }
373 return;
374 }
375
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100376 error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
Luiz Capitulino9ad53722011-12-07 11:47:57 -0200377}
Luiz Capitulino270b2432011-12-08 11:45:55 -0200378
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200379#ifdef CONFIG_VNC
Luiz Capitulino270b2432011-12-08 11:45:55 -0200380void qmp_change_vnc_password(const char *password, Error **errp)
381{
382 if (vnc_display_password(NULL, password) < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100383 error_setg(errp, QERR_SET_PASSWD_FAILED);
Luiz Capitulino270b2432011-12-08 11:45:55 -0200384 }
385}
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200386
Paolo Bonzini007fcd3e2012-10-18 09:01:01 +0200387static void qmp_change_vnc_listen(const char *target, Error **errp)
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200388{
Gerd Hoffmann4db14622014-09-16 12:33:03 +0200389 QemuOptsList *olist = qemu_find_opts("vnc");
390 QemuOpts *opts;
391
392 if (strstr(target, "id=")) {
393 error_setg(errp, "id not supported");
394 return;
395 }
396
397 opts = qemu_opts_find(olist, "default");
398 if (opts) {
399 qemu_opts_del(opts);
400 }
Markus Armbruster70b94332015-02-13 12:50:26 +0100401 opts = vnc_parse(target, errp);
Gongleif7801c52015-02-05 17:43:35 +0800402 if (!opts) {
403 return;
404 }
405
Gerd Hoffmann4db14622014-09-16 12:33:03 +0200406 vnc_display_open("default", errp);
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200407}
408
409static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
410 Error **errp)
411{
412 if (strcmp(target, "passwd") == 0 || strcmp(target, "password") == 0) {
413 if (!has_arg) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100414 error_setg(errp, QERR_MISSING_PARAMETER, "password");
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200415 } else {
416 qmp_change_vnc_password(arg, errp);
417 }
418 } else {
419 qmp_change_vnc_listen(target, errp);
420 }
421}
422#else
423void qmp_change_vnc_password(const char *password, Error **errp)
424{
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100425 error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200426}
427static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
428 Error **errp)
429{
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100430 error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200431}
432#endif /* !CONFIG_VNC */
433
434void qmp_change(const char *device, const char *target,
Markus Armbruster7daecb32014-05-02 13:26:31 +0200435 bool has_arg, const char *arg, Error **errp)
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200436{
437 if (strcmp(device, "vnc") == 0) {
Markus Armbruster7daecb32014-05-02 13:26:31 +0200438 qmp_change_vnc(target, has_arg, arg, errp);
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200439 } else {
Kevin Wolf70e2cb32016-09-20 13:38:47 +0200440 qmp_blockdev_change_medium(true, device, false, NULL, target,
441 has_arg, arg, false, 0, errp);
Luiz Capitulino333a96e2011-12-08 11:13:50 -0200442 }
443}
Anthony Liguori5eeee3f2011-12-22 14:40:54 -0600444
445static void qom_list_types_tramp(ObjectClass *klass, void *data)
446{
447 ObjectTypeInfoList *e, **pret = data;
448 ObjectTypeInfo *info;
449
450 info = g_malloc0(sizeof(*info));
451 info->name = g_strdup(object_class_get_name(klass));
452
453 e = g_malloc0(sizeof(*e));
454 e->value = info;
455 e->next = *pret;
456 *pret = e;
457}
458
459ObjectTypeInfoList *qmp_qom_list_types(bool has_implements,
460 const char *implements,
461 bool has_abstract,
462 bool abstract,
463 Error **errp)
464{
465 ObjectTypeInfoList *ret = NULL;
466
467 object_class_foreach(qom_list_types_tramp, implements, abstract, &ret);
468
469 return ret;
470}
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500471
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200472/* Return a DevicePropertyInfo for a qdev property.
473 *
474 * If a qdev property with the given name does not exist, use the given default
475 * type. If the qdev property info should not be shown, return NULL.
476 *
477 * The caller must free the return value.
478 */
479static DevicePropertyInfo *make_device_property_info(ObjectClass *klass,
480 const char *name,
Gonglei07d09c52014-10-07 14:33:23 +0800481 const char *default_type,
482 const char *description)
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200483{
484 DevicePropertyInfo *info;
485 Property *prop;
486
487 do {
488 for (prop = DEVICE_CLASS(klass)->props; prop && prop->name; prop++) {
489 if (strcmp(name, prop->name) != 0) {
490 continue;
491 }
492
493 /*
494 * TODO Properties without a parser are just for dirty hacks.
495 * qdev_prop_ptr is the only such PropertyInfo. It's marked
496 * for removal. This conditional should be removed along with
497 * it.
498 */
499 if (!prop->info->set) {
500 return NULL; /* no way to set it, don't show */
501 }
502
503 info = g_malloc0(sizeof(*info));
504 info->name = g_strdup(prop->name);
Gonglei07d09c52014-10-07 14:33:23 +0800505 info->type = g_strdup(prop->info->name);
506 info->has_description = !!prop->info->description;
507 info->description = g_strdup(prop->info->description);
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200508 return info;
509 }
510 klass = object_class_get_parent(klass);
511 } while (klass != object_class_by_name(TYPE_DEVICE));
512
513 /* Not a qdev property, use the default type */
514 info = g_malloc0(sizeof(*info));
515 info->name = g_strdup(name);
516 info->type = g_strdup(default_type);
Gonglei07d09c52014-10-07 14:33:23 +0800517 info->has_description = !!description;
518 info->description = g_strdup(description);
519
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200520 return info;
521}
522
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500523DevicePropertyInfoList *qmp_device_list_properties(const char *typename,
524 Error **errp)
525{
526 ObjectClass *klass;
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200527 Object *obj;
528 ObjectProperty *prop;
Daniel P. Berrange7746abd2015-12-09 12:34:02 +0000529 ObjectPropertyIterator iter;
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500530 DevicePropertyInfoList *prop_list = NULL;
531
532 klass = object_class_by_name(typename);
533 if (klass == NULL) {
Markus Armbruster75158eb2015-03-16 08:57:47 +0100534 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
535 "Device '%s' not found", typename);
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500536 return NULL;
537 }
538
539 klass = object_class_dynamic_cast(klass, TYPE_DEVICE);
540 if (klass == NULL) {
Lin Ma7a8c1532017-01-25 13:27:03 +0800541 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "typename", TYPE_DEVICE);
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500542 return NULL;
543 }
544
Markus Armbrusteredb15232015-10-01 10:59:57 +0200545 if (object_class_is_abstract(klass)) {
Lin Ma7a8c1532017-01-25 13:27:03 +0800546 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "typename",
Markus Armbrusteredb15232015-10-01 10:59:57 +0200547 "non-abstract device type");
548 return NULL;
549 }
550
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200551 obj = object_new(typename);
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500552
Daniel P. Berrange7746abd2015-12-09 12:34:02 +0000553 object_property_iter_init(&iter, obj);
554 while ((prop = object_property_iter_next(&iter))) {
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200555 DevicePropertyInfo *info;
556 DevicePropertyInfoList *entry;
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500557
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200558 /* Skip Object and DeviceState properties */
559 if (strcmp(prop->name, "type") == 0 ||
560 strcmp(prop->name, "realized") == 0 ||
561 strcmp(prop->name, "hotpluggable") == 0 ||
Stefan Hajnoczi4115dd62014-07-09 14:01:31 +0200562 strcmp(prop->name, "hotplugged") == 0 ||
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200563 strcmp(prop->name, "parent_bus") == 0) {
564 continue;
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500565 }
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200566
567 /* Skip legacy properties since they are just string versions of
568 * properties that we already list.
569 */
570 if (strstart(prop->name, "legacy-", NULL)) {
571 continue;
572 }
573
Gonglei07d09c52014-10-07 14:33:23 +0800574 info = make_device_property_info(klass, prop->name, prop->type,
575 prop->description);
Stefan Hajnoczif4eb32b2014-05-20 14:29:01 +0200576 if (!info) {
577 continue;
578 }
579
580 entry = g_malloc0(sizeof(*entry));
581 entry->value = info;
582 entry->next = prop_list;
583 prop_list = entry;
584 }
585
586 object_unref(obj);
Anthony Liguori1daa31b2012-08-10 11:04:09 -0500587
588 return prop_list;
589}
Anthony Liguorie4e31c62012-08-10 11:04:13 -0500590
Anthony Liguori76b64a72012-08-14 22:17:36 -0500591CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp)
592{
593 return arch_query_cpu_definitions(errp);
594}
595
David Hildenbrande09484e2016-09-05 10:52:39 +0200596CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type,
597 CpuModelInfo *model,
598 Error **errp)
599{
600 return arch_query_cpu_model_expansion(type, model, errp);
601}
602
David Hildenbrand0031e0d2016-09-05 10:52:40 +0200603CpuModelCompareInfo *qmp_query_cpu_model_comparison(CpuModelInfo *modela,
604 CpuModelInfo *modelb,
605 Error **errp)
606{
607 return arch_query_cpu_model_comparison(modela, modelb, errp);
608}
609
David Hildenbrandb18b6042016-09-05 10:52:41 +0200610CpuModelBaselineInfo *qmp_query_cpu_model_baseline(CpuModelInfo *modela,
611 CpuModelInfo *modelb,
612 Error **errp)
613{
614 return arch_query_cpu_model_baseline(modela, modelb, errp);
615}
616
Luiz Capitulinob224e5e2012-09-13 16:52:20 -0300617void qmp_add_client(const char *protocol, const char *fdname,
618 bool has_skipauth, bool skipauth, bool has_tls, bool tls,
619 Error **errp)
620{
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +0300621 Chardev *s;
Luiz Capitulinob224e5e2012-09-13 16:52:20 -0300622 int fd;
623
624 fd = monitor_get_fd(cur_mon, fdname, errp);
625 if (fd < 0) {
626 return;
627 }
628
629 if (strcmp(protocol, "spice") == 0) {
Markus Armbrusterb25d81b2015-01-13 17:07:15 +0100630 if (!qemu_using_spice(errp)) {
Luiz Capitulinob224e5e2012-09-13 16:52:20 -0300631 close(fd);
632 return;
633 }
634 skipauth = has_skipauth ? skipauth : false;
635 tls = has_tls ? tls : false;
636 if (qemu_spice_display_add_client(fd, skipauth, tls) < 0) {
637 error_setg(errp, "spice failed to add client");
638 close(fd);
639 }
640 return;
641#ifdef CONFIG_VNC
642 } else if (strcmp(protocol, "vnc") == 0) {
643 skipauth = has_skipauth ? skipauth : false;
644 vnc_display_add_client(NULL, fd, skipauth);
645 return;
646#endif
647 } else if ((s = qemu_chr_find(protocol)) != NULL) {
648 if (qemu_chr_add_client(s, fd) < 0) {
649 error_setg(errp, "failed to add client");
650 close(fd);
651 return;
652 }
653 return;
654 }
655
656 error_setg(errp, "protocol '%s' is invalid", protocol);
657 close(fd);
658}
Paolo Bonziniab2d0532013-12-20 23:21:09 +0100659
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +0100660
Markus Armbruster6eb39372015-09-16 13:06:25 +0200661void qmp_object_add(const char *type, const char *id,
662 bool has_props, QObject *props, Error **errp)
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +0100663{
Marc-André Lureaue64c75a2016-09-23 00:39:25 +0400664 QDict *pdict;
Eric Blakeb70ce102016-06-09 10:48:38 -0600665 Visitor *v;
Daniel P. Berrange90998d52016-02-10 18:40:59 +0000666 Object *obj;
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +0100667
668 if (props) {
669 pdict = qobject_to_qdict(props);
670 if (!pdict) {
Markus Armbruster485febc2015-03-13 17:25:50 +0100671 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict");
672 return;
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +0100673 }
Marc-André Lureaue64c75a2016-09-23 00:39:25 +0400674 QINCREF(pdict);
675 } else {
676 pdict = qdict_new();
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +0100677 }
678
Markus Armbruster048abb72017-03-03 13:32:39 +0100679 v = qobject_input_visitor_new(QOBJECT(pdict));
Eric Blakeb70ce102016-06-09 10:48:38 -0600680 obj = user_creatable_add_type(type, id, pdict, v, errp);
681 visit_free(v);
Daniel P. Berrange90998d52016-02-10 18:40:59 +0000682 if (obj) {
683 object_unref(obj);
684 }
Marc-André Lureaue64c75a2016-09-23 00:39:25 +0400685 QDECREF(pdict);
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +0100686}
687
Paolo Bonziniab2d0532013-12-20 23:21:09 +0100688void qmp_object_del(const char *id, Error **errp)
689{
Daniel P. Berrange90998d52016-02-10 18:40:59 +0000690 user_creatable_del(id, errp);
Paolo Bonziniab2d0532013-12-20 23:21:09 +0100691}
Igor Mammedov6f2e2732014-06-16 19:12:25 +0200692
693MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
694{
695 MemoryDeviceInfoList *head = NULL;
696 MemoryDeviceInfoList **prev = &head;
697
698 qmp_pc_dimm_device_list(qdev_get_machine(), &prev);
699
700 return head;
701}
Igor Mammedov02419bc2014-06-16 19:12:28 +0200702
703ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
704{
705 bool ambig;
706 ACPIOSTInfoList *head = NULL;
707 ACPIOSTInfoList **prev = &head;
708 Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);
709
710 if (obj) {
711 AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
712 AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);
713
714 adevc->ospm_status(adev, &prev);
715 } else {
716 error_setg(errp, "command is not supported, missing ACPI device");
717 }
718
719 return head;
720}