blob: e9b7228480ddba2b9d4c393b7a9d02ff86687be3 [file] [log] [blame]
Anthony Liguoriee46d8a2011-12-22 15:24:20 -06001/*
2 * Dynamic device configuration and creation.
3 *
4 * Copyright (c) 2009 CodeSourcery
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
Peter Maydelld38ea872016-01-29 17:50:05 +000020#include "qemu/osdep.h"
Andreas Färber2f7bd822013-04-16 03:50:21 +020021#include "hw/sysbus.h"
Markus Armbrusterd94bd092019-07-09 20:59:36 +020022#include "monitor/hmp.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010023#include "monitor/monitor.h"
Paolo Bonzinib4a42f82013-02-04 11:37:52 +010024#include "monitor/qdev.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010025#include "sysemu/arch_init.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010026#include "qapi/error.h"
Markus Armbrusterc577ff62019-06-19 22:10:37 +020027#include "qapi/qapi-commands-qdev.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010028#include "qapi/qmp/qdict.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010029#include "qapi/qmp/qerror.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/config-file.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010031#include "qemu/error-report.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020032#include "qemu/help_option.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010033#include "qemu/option.h"
Markus Armbruster8acb2a72019-04-17 21:06:41 +020034#include "qemu/qemu-print.h"
Jens Freimannf3a85052019-10-29 12:48:55 +010035#include "qemu/option_int.h"
Kevin Wolf9680cae2016-09-20 13:38:42 +020036#include "sysemu/block-backend.h"
Markus Armbrusterd5938f22019-08-12 07:23:56 +020037#include "sysemu/sysemu.h"
Juan Quintelac4b63b72017-04-24 19:02:44 +020038#include "migration/misc.h"
Jens Freimannf3a85052019-10-29 12:48:55 +010039#include "migration/migration.h"
Marc-André Lureaue1043d62020-01-10 19:30:39 +040040#include "qemu/cutils.h"
Damien Hedde9f2ff992020-04-06 15:52:51 +020041#include "hw/clock.h"
Anthony Liguoriee46d8a2011-12-22 15:24:20 -060042
43/*
44 * Aliases were a bad idea from the start. Let's keep them
45 * from spreading further.
46 */
47typedef struct QDevAlias
48{
49 const char *typename;
50 const char *alias;
Alexander Graf5f629d92012-05-18 02:36:26 +020051 uint32_t arch_mask;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -060052} QDevAlias;
53
Sascha Silbe36e99162016-02-18 22:44:13 +010054/* Please keep this table sorted by typename. */
Anthony Liguoriee46d8a2011-12-22 15:24:20 -060055static const QDevAlias qdev_alias_table[] = {
Gerd Hoffmann2957f5a2020-07-02 15:25:09 +020056 { "AC97", "ac97" }, /* -soundhw name */
Sascha Silbe36e99162016-02-18 22:44:13 +010057 { "e1000", "e1000-82540em" },
Gerd Hoffmann0e933fe2020-07-02 15:25:10 +020058 { "ES1370", "es1370" }, /* -soundhw name */
Sascha Silbe36e99162016-02-18 22:44:13 +010059 { "ich9-ahci", "ahci" },
Sascha Silbe36e99162016-02-18 22:44:13 +010060 { "lsi53c895a", "lsi" },
Sascha Silbe588c36c2016-02-18 22:44:14 +010061 { "virtio-9p-ccw", "virtio-9p", QEMU_ARCH_S390X },
62 { "virtio-9p-pci", "virtio-9p", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
63 { "virtio-balloon-ccw", "virtio-balloon", QEMU_ARCH_S390X },
Alexander Graf5f629d92012-05-18 02:36:26 +020064 { "virtio-balloon-pci", "virtio-balloon",
65 QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Alexander Graf1f68f1d2015-06-16 23:06:33 +020066 { "virtio-blk-ccw", "virtio-blk", QEMU_ARCH_S390X },
Sascha Silbe36e99162016-02-18 22:44:13 +010067 { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Sascha Silbe588c36c2016-02-18 22:44:14 +010068 { "virtio-gpu-ccw", "virtio-gpu", QEMU_ARCH_S390X },
69 { "virtio-gpu-pci", "virtio-gpu", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
70 { "virtio-input-host-ccw", "virtio-input-host", QEMU_ARCH_S390X },
71 { "virtio-input-host-pci", "virtio-input-host",
72 QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Eric Auger8b4eb092020-02-14 14:27:43 +010073 { "virtio-iommu-pci", "virtio-iommu", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Sascha Silbe588c36c2016-02-18 22:44:14 +010074 { "virtio-keyboard-ccw", "virtio-keyboard", QEMU_ARCH_S390X },
75 { "virtio-keyboard-pci", "virtio-keyboard",
76 QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
77 { "virtio-mouse-ccw", "virtio-mouse", QEMU_ARCH_S390X },
78 { "virtio-mouse-pci", "virtio-mouse", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Alexander Graf1f68f1d2015-06-16 23:06:33 +020079 { "virtio-net-ccw", "virtio-net", QEMU_ARCH_S390X },
Sascha Silbe36e99162016-02-18 22:44:13 +010080 { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Sascha Silbe588c36c2016-02-18 22:44:14 +010081 { "virtio-rng-ccw", "virtio-rng", QEMU_ARCH_S390X },
82 { "virtio-rng-pci", "virtio-rng", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
83 { "virtio-scsi-ccw", "virtio-scsi", QEMU_ARCH_S390X },
84 { "virtio-scsi-pci", "virtio-scsi", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Alexander Graf1f68f1d2015-06-16 23:06:33 +020085 { "virtio-serial-ccw", "virtio-serial", QEMU_ARCH_S390X },
Sascha Silbe36e99162016-02-18 22:44:13 +010086 { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Sascha Silbe588c36c2016-02-18 22:44:14 +010087 { "virtio-tablet-ccw", "virtio-tablet", QEMU_ARCH_S390X },
88 { "virtio-tablet-pci", "virtio-tablet", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
Anthony Liguoriee46d8a2011-12-22 15:24:20 -060089 { }
90};
91
92static const char *qdev_class_get_alias(DeviceClass *dc)
93{
94 const char *typename = object_class_get_name(OBJECT_CLASS(dc));
95 int i;
96
97 for (i = 0; qdev_alias_table[i].typename; i++) {
Alexander Graf5f629d92012-05-18 02:36:26 +020098 if (qdev_alias_table[i].arch_mask &&
99 !(qdev_alias_table[i].arch_mask & arch_type)) {
100 continue;
101 }
102
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600103 if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
104 return qdev_alias_table[i].alias;
105 }
106 }
107
108 return NULL;
109}
110
111static bool qdev_class_has_alias(DeviceClass *dc)
112{
113 return (qdev_class_get_alias(dc) != NULL);
114}
115
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200116static void qdev_print_devinfo(DeviceClass *dc)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600117{
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200118 qemu_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
Anthony Liguori0d936922012-05-02 09:00:20 +0200119 if (dc->bus_type) {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200120 qemu_printf(", bus %s", dc->bus_type);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600121 }
122 if (qdev_class_has_alias(dc)) {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200123 qemu_printf(", alias \"%s\"", qdev_class_get_alias(dc));
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600124 }
125 if (dc->desc) {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200126 qemu_printf(", desc \"%s\"", dc->desc);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600127 }
Eduardo Habkoste90f2a82017-05-03 17:35:44 -0300128 if (!dc->user_creatable) {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200129 qemu_printf(", no-user");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600130 }
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200131 qemu_printf("\n");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600132}
133
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200134static void qdev_print_devinfos(bool show_no_user)
135{
136 static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = {
137 [DEVICE_CATEGORY_BRIDGE] = "Controller/Bridge/Hub",
138 [DEVICE_CATEGORY_USB] = "USB",
139 [DEVICE_CATEGORY_STORAGE] = "Storage",
140 [DEVICE_CATEGORY_NETWORK] = "Network",
141 [DEVICE_CATEGORY_INPUT] = "Input",
142 [DEVICE_CATEGORY_DISPLAY] = "Display",
143 [DEVICE_CATEGORY_SOUND] = "Sound",
144 [DEVICE_CATEGORY_MISC] = "Misc",
Thomas Huthba31cc72017-01-20 14:01:16 +0100145 [DEVICE_CATEGORY_CPU] = "CPU",
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200146 [DEVICE_CATEGORY_MAX] = "Uncategorized",
147 };
148 GSList *list, *elt;
149 int i;
150 bool cat_printed;
151
Gerd Hoffmann7ab6e7f2020-06-24 15:10:38 +0200152 module_load_qom_all();
Paolo Bonzini47c66002018-03-03 08:33:10 +0100153 list = object_class_get_list_sorted(TYPE_DEVICE, false);
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200154
155 for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) {
156 cat_printed = false;
157 for (elt = list; elt; elt = elt->next) {
158 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
159 TYPE_DEVICE);
160 if ((i < DEVICE_CATEGORY_MAX
161 ? !test_bit(i, dc->categories)
162 : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX))
Markus Armbrusterefec3dd2013-11-28 17:26:54 +0100163 || (!show_no_user
Eduardo Habkoste90f2a82017-05-03 17:35:44 -0300164 && !dc->user_creatable)) {
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200165 continue;
166 }
167 if (!cat_printed) {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200168 qemu_printf("%s%s devices:\n", i ? "\n" : "", cat_name[i]);
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200169 cat_printed = true;
170 }
171 qdev_print_devinfo(dc);
172 }
173 }
174
175 g_slist_free(list);
176}
177
Markus Armbruster71df1d82015-03-12 08:40:25 +0100178static int set_property(void *opaque, const char *name, const char *value,
179 Error **errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600180{
Paolo Bonzini98a65282014-02-08 11:01:49 +0100181 Object *obj = opaque;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600182
183 if (strcmp(name, "driver") == 0)
184 return 0;
185 if (strcmp(name, "bus") == 0)
186 return 0;
187
Markus Armbruster668f62e2020-07-07 18:06:02 +0200188 if (!object_property_parse(obj, name, value, errp)) {
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600189 return -1;
190 }
191 return 0;
192}
193
194static const char *find_typename_by_alias(const char *alias)
195{
196 int i;
197
198 for (i = 0; qdev_alias_table[i].alias; i++) {
Alexander Graf5f629d92012-05-18 02:36:26 +0200199 if (qdev_alias_table[i].arch_mask &&
200 !(qdev_alias_table[i].arch_mask & arch_type)) {
201 continue;
202 }
203
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600204 if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
205 return qdev_alias_table[i].typename;
206 }
207 }
208
209 return NULL;
210}
211
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200212static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
213{
214 ObjectClass *oc;
215 DeviceClass *dc;
Sascha Silbef6b53192016-02-18 22:44:12 +0100216 const char *original_name = *driver;
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200217
Gerd Hoffmann7ab6e7f2020-06-24 15:10:38 +0200218 oc = module_object_class_by_name(*driver);
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200219 if (!oc) {
220 const char *typename = find_typename_by_alias(*driver);
221
222 if (typename) {
223 *driver = typename;
Gerd Hoffmann7ab6e7f2020-06-24 15:10:38 +0200224 oc = module_object_class_by_name(*driver);
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200225 }
226 }
227
228 if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) {
Sascha Silbef6b53192016-02-18 22:44:12 +0100229 if (*driver != original_name) {
230 error_setg(errp, "'%s' (alias '%s') is not a valid device model"
231 " name", original_name, *driver);
232 } else {
233 error_setg(errp, "'%s' is not a valid device model name", *driver);
234 }
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200235 return NULL;
236 }
237
238 if (object_class_is_abstract(oc)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100239 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
240 "non-abstract device type");
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200241 return NULL;
242 }
243
244 dc = DEVICE_CLASS(oc);
Eduardo Habkoste90f2a82017-05-03 17:35:44 -0300245 if (!dc->user_creatable ||
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200246 (qdev_hotplug && !dc->hotpluggable)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100247 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
248 "pluggable device type");
Eduardo Habkost43c95d72014-11-01 13:56:09 -0200249 return NULL;
250 }
251
252 return dc;
253}
254
255
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600256int qdev_device_help(QemuOpts *opts)
257{
Stefan Hajnoczief523582014-07-09 14:01:32 +0200258 Error *local_err = NULL;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600259 const char *driver;
Alexey Kardashevskiy35f63762018-03-02 00:09:38 +1100260 ObjectPropertyInfoList *prop_list;
261 ObjectPropertyInfoList *prop;
Marc-André Lureaue1043d62020-01-10 19:30:39 +0400262 GPtrArray *array;
263 int i;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600264
265 driver = qemu_opt_get(opts, "driver");
Peter Maydellc8057f92012-08-02 13:45:54 +0100266 if (driver && is_help_option(driver)) {
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200267 qdev_print_devinfos(false);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600268 return 1;
269 }
270
Peter Maydellc8057f92012-08-02 13:45:54 +0100271 if (!driver || !qemu_opt_has_help_opt(opts)) {
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600272 return 0;
273 }
274
Markus Armbruster33fe9682015-10-01 10:59:59 +0200275 if (!object_class_by_name(driver)) {
276 const char *typename = find_typename_by_alias(driver);
277
278 if (typename) {
279 driver = typename;
280 }
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600281 }
282
Stefan Hajnoczief523582014-07-09 14:01:32 +0200283 prop_list = qmp_device_list_properties(driver, &local_err);
Gonglei0722eba2014-09-16 10:19:33 +0800284 if (local_err) {
Eduardo Habkost5185f0e2014-11-01 13:56:10 -0200285 goto error;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600286 }
Stefan Hajnoczief523582014-07-09 14:01:32 +0200287
Max Reitz9c2762b2018-10-19 18:49:27 +0200288 if (prop_list) {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200289 qemu_printf("%s options:\n", driver);
Max Reitz9c2762b2018-10-19 18:49:27 +0200290 } else {
Markus Armbruster8acb2a72019-04-17 21:06:41 +0200291 qemu_printf("There are no options for %s.\n", driver);
Max Reitz9c2762b2018-10-19 18:49:27 +0200292 }
Marc-André Lureaue1043d62020-01-10 19:30:39 +0400293 array = g_ptr_array_new();
Stefan Hajnoczief523582014-07-09 14:01:32 +0200294 for (prop = prop_list; prop; prop = prop->next) {
Marc-André Lureaue1043d62020-01-10 19:30:39 +0400295 g_ptr_array_add(array,
296 object_property_help(prop->value->name,
297 prop->value->type,
298 prop->value->default_value,
299 prop->value->description));
Stefan Hajnoczief523582014-07-09 14:01:32 +0200300 }
Marc-André Lureaue1043d62020-01-10 19:30:39 +0400301 g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
302 for (i = 0; i < array->len; i++) {
Markus Armbruster029afc42020-07-14 18:01:58 +0200303 qemu_printf("%s\n", (char *)array->pdata[i]);
Marc-André Lureaue1043d62020-01-10 19:30:39 +0400304 }
305 g_ptr_array_set_free_func(array, g_free);
306 g_ptr_array_free(array, true);
Alexey Kardashevskiy35f63762018-03-02 00:09:38 +1100307 qapi_free_ObjectPropertyInfoList(prop_list);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600308 return 1;
Eduardo Habkost5185f0e2014-11-01 13:56:10 -0200309
310error:
Markus Armbruster78288672015-12-18 16:35:07 +0100311 error_report_err(local_err);
Eduardo Habkost5185f0e2014-11-01 13:56:10 -0200312 return 1;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600313}
314
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600315static Object *qdev_get_peripheral(void)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600316{
Anthony Liguori8b45d442011-12-23 09:08:05 -0600317 static Object *dev;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600318
319 if (dev == NULL) {
Andreas Färberdfe47e72012-04-05 13:21:46 +0200320 dev = container_get(qdev_get_machine(), "/peripheral");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600321 }
322
Anthony Liguori8b45d442011-12-23 09:08:05 -0600323 return dev;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600324}
325
Anthony Liguori57c9faf2012-01-30 08:55:55 -0600326static Object *qdev_get_peripheral_anon(void)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600327{
Anthony Liguori8b45d442011-12-23 09:08:05 -0600328 static Object *dev;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600329
330 if (dev == NULL) {
Andreas Färberdfe47e72012-04-05 13:21:46 +0200331 dev = container_get(qdev_get_machine(), "/peripheral-anon");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600332 }
333
Anthony Liguori8b45d442011-12-23 09:08:05 -0600334 return dev;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600335}
336
Vladimir Sementsov-Ogievskiy34077322019-12-05 20:46:20 +0300337static void qbus_error_append_bus_list_hint(DeviceState *dev,
338 Error *const *errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600339{
340 BusState *child;
341 const char *sep = " ";
342
Eric Blake50b7b002015-09-10 10:19:16 -0600343 error_append_hint(errp, "child buses at \"%s\":",
344 dev->id ? dev->id : object_get_typename(OBJECT(dev)));
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600345 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Eric Blake50b7b002015-09-10 10:19:16 -0600346 error_append_hint(errp, "%s\"%s\"", sep, child->name);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600347 sep = ", ";
348 }
Markus Armbruster543202c2015-12-17 17:35:14 +0100349 error_append_hint(errp, "\n");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600350}
351
Vladimir Sementsov-Ogievskiy34077322019-12-05 20:46:20 +0300352static void qbus_error_append_dev_list_hint(BusState *bus,
353 Error *const *errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600354{
Anthony Liguori0866aca2011-12-23 15:34:39 -0600355 BusChild *kid;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600356 const char *sep = " ";
357
Eric Blake50b7b002015-09-10 10:19:16 -0600358 error_append_hint(errp, "devices at \"%s\":", bus->name);
Anthony Liguori0866aca2011-12-23 15:34:39 -0600359 QTAILQ_FOREACH(kid, &bus->children, sibling) {
360 DeviceState *dev = kid->child;
Eric Blake50b7b002015-09-10 10:19:16 -0600361 error_append_hint(errp, "%s\"%s\"", sep,
362 object_get_typename(OBJECT(dev)));
363 if (dev->id) {
364 error_append_hint(errp, "/\"%s\"", dev->id);
365 }
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600366 sep = ", ";
367 }
Markus Armbruster543202c2015-12-17 17:35:14 +0100368 error_append_hint(errp, "\n");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600369}
370
371static BusState *qbus_find_bus(DeviceState *dev, char *elem)
372{
373 BusState *child;
374
375 QLIST_FOREACH(child, &dev->child_bus, sibling) {
376 if (strcmp(child->name, elem) == 0) {
377 return child;
378 }
379 }
380 return NULL;
381}
382
383static DeviceState *qbus_find_dev(BusState *bus, char *elem)
384{
Anthony Liguori0866aca2011-12-23 15:34:39 -0600385 BusChild *kid;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600386
387 /*
388 * try to match in order:
389 * (1) instance id, if present
390 * (2) driver name
391 * (3) driver alias, if present
392 */
Anthony Liguori0866aca2011-12-23 15:34:39 -0600393 QTAILQ_FOREACH(kid, &bus->children, sibling) {
394 DeviceState *dev = kid->child;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600395 if (dev->id && strcmp(dev->id, elem) == 0) {
396 return dev;
397 }
398 }
Anthony Liguori0866aca2011-12-23 15:34:39 -0600399 QTAILQ_FOREACH(kid, &bus->children, sibling) {
400 DeviceState *dev = kid->child;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600401 if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
402 return dev;
403 }
404 }
Anthony Liguori0866aca2011-12-23 15:34:39 -0600405 QTAILQ_FOREACH(kid, &bus->children, sibling) {
406 DeviceState *dev = kid->child;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600407 DeviceClass *dc = DEVICE_GET_CLASS(dev);
408
409 if (qdev_class_has_alias(dc) &&
410 strcmp(qdev_class_get_alias(dc), elem) == 0) {
411 return dev;
412 }
413 }
414 return NULL;
415}
416
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100417static inline bool qbus_is_full(BusState *bus)
418{
419 BusClass *bus_class = BUS_GET_CLASS(bus);
Tony Krowiak12b2e9f2018-12-17 10:57:30 -0500420 return bus_class->max_dev && bus->num_children >= bus_class->max_dev;
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100421}
422
423/*
424 * Search the tree rooted at @bus for a bus.
425 * If @name, search for a bus with that name. Note that bus names
426 * need not be unique. Yes, that's screwed up.
427 * Else search for a bus that is a subtype of @bus_typename.
428 * If more than one exists, prefer one that can take another device.
429 * Return the bus if found, else %NULL.
430 */
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600431static BusState *qbus_find_recursive(BusState *bus, const char *name,
Anthony Liguori0d936922012-05-02 09:00:20 +0200432 const char *bus_typename)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600433{
Anthony Liguori0866aca2011-12-23 15:34:39 -0600434 BusChild *kid;
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100435 BusState *pick, *child, *ret;
436 bool match;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600437
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100438 assert(name || bus_typename);
439 if (name) {
440 match = !strcmp(bus->name, name);
441 } else {
442 match = !!object_dynamic_cast(OBJECT(bus), bus_typename);
KONRAD Frederic1395af62013-01-15 00:08:00 +0100443 }
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100444
445 if (match && !qbus_is_full(bus)) {
446 return bus; /* root matches and isn't full */
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600447 }
448
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100449 pick = match ? bus : NULL;
450
Anthony Liguori0866aca2011-12-23 15:34:39 -0600451 QTAILQ_FOREACH(kid, &bus->children, sibling) {
452 DeviceState *dev = kid->child;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600453 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Anthony Liguori0d936922012-05-02 09:00:20 +0200454 ret = qbus_find_recursive(child, name, bus_typename);
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100455 if (ret && !qbus_is_full(ret)) {
456 return ret; /* a descendant matches and isn't full */
457 }
458 if (ret && !pick) {
459 pick = ret;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600460 }
461 }
462 }
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100463
464 /* root or a descendant matches, but is full */
465 return pick;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600466}
467
Markus Armbrusterd2828422015-03-11 19:16:04 +0100468static BusState *qbus_find(const char *path, Error **errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600469{
470 DeviceState *dev;
471 BusState *bus;
472 char elem[128];
473 int pos, len;
474
475 /* find start element */
476 if (path[0] == '/') {
477 bus = sysbus_get_default();
478 pos = 0;
479 } else {
480 if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
481 assert(!path[0]);
482 elem[0] = len = 0;
483 }
484 bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
485 if (!bus) {
Markus Armbrusterd2828422015-03-11 19:16:04 +0100486 error_setg(errp, "Bus '%s' not found", elem);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600487 return NULL;
488 }
489 pos = len;
490 }
491
492 for (;;) {
493 assert(path[pos] == '/' || !path[pos]);
494 while (path[pos] == '/') {
495 pos++;
496 }
497 if (path[pos] == '\0') {
Markus Armbrustered238ba2015-03-11 18:39:16 +0100498 break;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600499 }
500
501 /* find device */
502 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
Stefan Weildfc6f862013-07-25 18:21:28 +0200503 g_assert_not_reached();
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600504 elem[0] = len = 0;
505 }
506 pos += len;
507 dev = qbus_find_dev(bus, elem);
508 if (!dev) {
Markus Armbruster75158eb2015-03-16 08:57:47 +0100509 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
510 "Device '%s' not found", elem);
Vladimir Sementsov-Ogievskiy34077322019-12-05 20:46:20 +0300511 qbus_error_append_dev_list_hint(bus, errp);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600512 return NULL;
513 }
514
515 assert(path[pos] == '/' || !path[pos]);
516 while (path[pos] == '/') {
517 pos++;
518 }
519 if (path[pos] == '\0') {
520 /* last specified element is a device. If it has exactly
521 * one child bus accept it nevertheless */
Markus Armbrustered238ba2015-03-11 18:39:16 +0100522 if (dev->num_child_bus == 1) {
523 bus = QLIST_FIRST(&dev->child_bus);
524 break;
525 }
526 if (dev->num_child_bus) {
Markus Armbrusterd2828422015-03-11 19:16:04 +0100527 error_setg(errp, "Device '%s' has multiple child buses",
528 elem);
Vladimir Sementsov-Ogievskiy34077322019-12-05 20:46:20 +0300529 qbus_error_append_bus_list_hint(dev, errp);
Markus Armbrustered238ba2015-03-11 18:39:16 +0100530 } else {
Markus Armbrusterd2828422015-03-11 19:16:04 +0100531 error_setg(errp, "Device '%s' has no child bus", elem);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600532 }
Markus Armbrustered238ba2015-03-11 18:39:16 +0100533 return NULL;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600534 }
535
536 /* find bus */
537 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
Stefan Weildfc6f862013-07-25 18:21:28 +0200538 g_assert_not_reached();
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600539 elem[0] = len = 0;
540 }
541 pos += len;
542 bus = qbus_find_bus(dev, elem);
543 if (!bus) {
Markus Armbrusterd2828422015-03-11 19:16:04 +0100544 error_setg(errp, "Bus '%s' not found", elem);
Vladimir Sementsov-Ogievskiy34077322019-12-05 20:46:20 +0300545 qbus_error_append_bus_list_hint(dev, errp);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600546 return NULL;
547 }
548 }
Markus Armbrustered238ba2015-03-11 18:39:16 +0100549
550 if (qbus_is_full(bus)) {
Markus Armbrusterd2828422015-03-11 19:16:04 +0100551 error_setg(errp, "Bus '%s' is full", path);
Markus Armbrustered238ba2015-03-11 18:39:16 +0100552 return NULL;
553 }
554 return bus;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600555}
556
Juergen Grossce49b732016-11-22 07:10:57 +0100557void qdev_set_id(DeviceState *dev, const char *id)
558{
559 if (id) {
560 dev->id = id;
561 }
562
563 if (dev->id) {
564 object_property_add_child(qdev_get_peripheral(), dev->id,
Markus Armbrusterd2623122020-05-05 17:29:22 +0200565 OBJECT(dev));
Juergen Grossce49b732016-11-22 07:10:57 +0100566 } else {
567 static int anon_count;
568 gchar *name = g_strdup_printf("device[%d]", anon_count++);
569 object_property_add_child(qdev_get_peripheral_anon(), name,
Markus Armbrusterd2623122020-05-05 17:29:22 +0200570 OBJECT(dev));
Juergen Grossce49b732016-11-22 07:10:57 +0100571 g_free(name);
572 }
573}
574
Jens Freimannf3a85052019-10-29 12:48:55 +0100575static int is_failover_device(void *opaque, const char *name, const char *value,
576 Error **errp)
577{
578 if (strcmp(name, "failover_pair_id") == 0) {
579 QemuOpts *opts = (QemuOpts *)opaque;
580
581 if (qdev_should_hide_device(opts)) {
582 return 1;
583 }
584 }
585
586 return 0;
587}
588
589static bool should_hide_device(QemuOpts *opts)
590{
591 if (qemu_opt_foreach(opts, is_failover_device, opts, NULL) == 0) {
592 return false;
593 }
594 return true;
595}
596
Markus Armbrusterf006cf72015-03-12 14:00:41 +0100597DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600598{
Andreas Färberf4d85792013-08-24 01:21:22 +0200599 DeviceClass *dc;
Juergen Grossce49b732016-11-22 07:10:57 +0100600 const char *driver, *path;
Jens Freimannf3a85052019-10-29 12:48:55 +0100601 DeviceState *dev = NULL;
Andreas Färber2f7bd822013-04-16 03:50:21 +0200602 BusState *bus = NULL;
Jens Freimannf3a85052019-10-29 12:48:55 +0100603 bool hide;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600604
605 driver = qemu_opt_get(opts, "driver");
606 if (!driver) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100607 error_setg(errp, QERR_MISSING_PARAMETER, "driver");
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600608 return NULL;
609 }
610
611 /* find driver */
Markus Armbrusterf006cf72015-03-12 14:00:41 +0100612 dc = qdev_get_device_class(&driver, errp);
613 if (!dc) {
Markus Armbruster7ea5e782013-11-28 17:27:03 +0100614 return NULL;
615 }
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600616
617 /* find bus */
618 path = qemu_opt_get(opts, "bus");
619 if (path != NULL) {
Markus Armbrusterf006cf72015-03-12 14:00:41 +0100620 bus = qbus_find(path, errp);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600621 if (!bus) {
622 return NULL;
623 }
Andreas Färberf4d85792013-08-24 01:21:22 +0200624 if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
Markus Armbrusterf006cf72015-03-12 14:00:41 +0100625 error_setg(errp, "Device '%s' can't go on %s bus",
626 driver, object_get_typename(OBJECT(bus)));
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600627 return NULL;
628 }
Andreas Färberf4d85792013-08-24 01:21:22 +0200629 } else if (dc->bus_type != NULL) {
630 bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
Markus Armbrustera5ec4942015-03-11 17:26:31 +0100631 if (!bus || qbus_is_full(bus)) {
Markus Armbrusterf006cf72015-03-12 14:00:41 +0100632 error_setg(errp, "No '%s' bus found for device '%s'",
633 dc->bus_type, driver);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600634 return NULL;
635 }
636 }
Jens Freimannf3a85052019-10-29 12:48:55 +0100637 hide = should_hide_device(opts);
638
639 if ((hide || qdev_hotplug) && bus && !qbus_is_hotpluggable(bus)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100640 error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600641 return NULL;
642 }
643
Jens Freimannf3a85052019-10-29 12:48:55 +0100644 if (hide) {
645 return NULL;
646 }
647
Juan Quintelab06424d2017-03-22 17:34:27 +0100648 if (!migration_is_idle()) {
649 error_setg(errp, "device_add not allowed while migrating");
650 return NULL;
651 }
652
Amos Kong7b030942014-03-03 15:57:55 +0800653 /* create device */
Markus Armbruster4e3a6772020-06-10 07:31:54 +0200654 dev = qdev_new(driver);
Andreas Färber2f7bd822013-04-16 03:50:21 +0200655
Peter Xud2321d32019-09-16 16:07:16 +0800656 /* Check whether the hotplug is allowed by the machine */
Markus Armbruster992861f2020-07-07 18:06:04 +0200657 if (qdev_hotplug && !qdev_hotplug_allowed(dev, errp)) {
Peter Xud2321d32019-09-16 16:07:16 +0800658 goto err_del_dev;
659 }
660
Markus Armbruster464a22c2020-06-10 07:32:44 +0200661 if (!bus && qdev_hotplug && !qdev_get_machine_hotplug_handler(dev)) {
Thomas Huth03fcbd92017-11-02 11:10:06 +0100662 /* No bus, no machine hotplug handler --> device is not hotpluggable */
Markus Armbruster992861f2020-07-07 18:06:04 +0200663 error_setg(errp, "Device '%s' can not be hotplugged on this machine",
Thomas Huth03fcbd92017-11-02 11:10:06 +0100664 driver);
665 goto err_del_dev;
Andreas Färber2f7bd822013-04-16 03:50:21 +0200666 }
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600667
Juergen Grossce49b732016-11-22 07:10:57 +0100668 qdev_set_id(dev, qemu_opts_id(opts));
Bandan Das52aa17c2014-02-26 10:32:40 -0700669
Amos Kong7b030942014-03-03 15:57:55 +0800670 /* set properties */
Markus Armbruster992861f2020-07-07 18:06:04 +0200671 if (qemu_opt_foreach(opts, set_property, dev, errp)) {
Thomas Huth58346212017-11-02 11:10:05 +0100672 goto err_del_dev;
Amos Kong7b030942014-03-03 15:57:55 +0800673 }
674
Bandan Das52aa17c2014-02-26 10:32:40 -0700675 dev->opts = opts;
Markus Armbruster992861f2020-07-07 18:06:04 +0200676 if (!qdev_realize(DEVICE(dev), bus, errp)) {
Bandan Das52aa17c2014-02-26 10:32:40 -0700677 dev->opts = NULL;
Thomas Huth58346212017-11-02 11:10:05 +0100678 goto err_del_dev;
Paolo Bonzinif424d5c2012-03-27 18:38:46 +0200679 }
Andreas Färber2bcb0c62013-10-07 16:17:54 +0200680 return dev;
Thomas Huth58346212017-11-02 11:10:05 +0100681
682err_del_dev:
Jens Freimannf3a85052019-10-29 12:48:55 +0100683 if (dev) {
684 object_unparent(OBJECT(dev));
685 object_unref(OBJECT(dev));
686 }
Thomas Huth58346212017-11-02 11:10:05 +0100687 return NULL;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600688}
689
690
691#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
692static void qbus_print(Monitor *mon, BusState *bus, int indent);
693
694static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
Paolo Bonzinibce54472012-03-28 18:12:47 +0200695 int indent)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600696{
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600697 if (!props)
698 return;
Paolo Bonzinid8229792012-02-02 09:47:13 +0100699 for (; props->name; props++) {
Paolo Bonzinid8229792012-02-02 09:47:13 +0100700 char *value;
701 char *legacy_name = g_strdup_printf("legacy-%s", props->name);
Markus Armbrustera43770d2020-07-07 18:06:13 +0200702
Paolo Bonzinid8229792012-02-02 09:47:13 +0100703 if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
Markus Armbrustera43770d2020-07-07 18:06:13 +0200704 value = object_property_get_str(OBJECT(dev), legacy_name, NULL);
Paolo Bonzinid8229792012-02-02 09:47:13 +0100705 } else {
Markus Armbrustera43770d2020-07-07 18:06:13 +0200706 value = object_property_print(OBJECT(dev), props->name, true,
707 NULL);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600708 }
Paolo Bonzinid8229792012-02-02 09:47:13 +0100709 g_free(legacy_name);
710
Markus Armbrustera43770d2020-07-07 18:06:13 +0200711 if (!value) {
Paolo Bonzinid8229792012-02-02 09:47:13 +0100712 continue;
713 }
Paolo Bonzinibce54472012-03-28 18:12:47 +0200714 qdev_printf("%s = %s\n", props->name,
Markus Armbrustera43770d2020-07-07 18:06:13 +0200715 *value ? value : "<null>");
Paolo Bonzinid8229792012-02-02 09:47:13 +0100716 g_free(value);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600717 }
718}
719
Anthony Liguori0d936922012-05-02 09:00:20 +0200720static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
721{
722 BusClass *bc = BUS_GET_CLASS(bus);
723
724 if (bc->print_dev) {
725 bc->print_dev(mon, dev, indent);
726 }
727}
728
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600729static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
730{
Paolo Bonzinibce54472012-03-28 18:12:47 +0200731 ObjectClass *class;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600732 BusState *child;
Peter Crosthwaitea5f54292014-05-19 23:30:58 -0700733 NamedGPIOList *ngl;
Damien Hedde9f2ff992020-04-06 15:52:51 +0200734 NamedClockList *ncl;
Peter Crosthwaitea5f54292014-05-19 23:30:58 -0700735
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600736 qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
737 dev->id ? dev->id : "");
738 indent += 2;
Peter Crosthwaitea5f54292014-05-19 23:30:58 -0700739 QLIST_FOREACH(ngl, &dev->gpios, node) {
740 if (ngl->num_in) {
741 qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
742 ngl->num_in);
743 }
744 if (ngl->num_out) {
745 qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
746 ngl->num_out);
747 }
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600748 }
Damien Hedde9f2ff992020-04-06 15:52:51 +0200749 QLIST_FOREACH(ncl, &dev->clocks, node) {
750 qdev_printf("clock-%s%s \"%s\" freq_hz=%e\n",
751 ncl->output ? "out" : "in",
752 ncl->alias ? " (alias)" : "",
753 ncl->name,
754 CLOCK_PERIOD_TO_HZ(1.0 * clock_get(ncl->clock)));
755 }
Paolo Bonzinibce54472012-03-28 18:12:47 +0200756 class = object_get_class(OBJECT(dev));
757 do {
Paolo Bonzini385d8f22020-01-23 12:11:38 +0100758 qdev_print_props(mon, dev, DEVICE_CLASS(class)->props_, indent);
Paolo Bonzinibce54472012-03-28 18:12:47 +0200759 class = object_class_get_parent(class);
760 } while (class != object_class_by_name(TYPE_DEVICE));
Gerd Hoffmannda9fbe72012-07-11 12:21:23 +0200761 bus_print_dev(dev->parent_bus, mon, dev, indent);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600762 QLIST_FOREACH(child, &dev->child_bus, sibling) {
763 qbus_print(mon, child, indent);
764 }
765}
766
767static void qbus_print(Monitor *mon, BusState *bus, int indent)
768{
Anthony Liguori0866aca2011-12-23 15:34:39 -0600769 BusChild *kid;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600770
771 qdev_printf("bus: %s\n", bus->name);
772 indent += 2;
Anthony Liguori0d936922012-05-02 09:00:20 +0200773 qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
Anthony Liguori0866aca2011-12-23 15:34:39 -0600774 QTAILQ_FOREACH(kid, &bus->children, sibling) {
775 DeviceState *dev = kid->child;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600776 qdev_print(mon, dev, indent);
777 }
778}
779#undef qdev_printf
780
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100781void hmp_info_qtree(Monitor *mon, const QDict *qdict)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600782{
783 if (sysbus_get_default())
784 qbus_print(mon, sysbus_get_default(), 0);
785}
786
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100787void hmp_info_qdm(Monitor *mon, const QDict *qdict)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600788{
Markus Armbrustera3400ae2013-10-10 15:00:21 +0200789 qdev_print_devinfos(true);
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600790}
791
Markus Armbruster485febc2015-03-13 17:25:50 +0100792void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600793{
794 QemuOpts *opts;
Paolo Bonzinib09995a2013-01-25 14:12:37 +0100795 DeviceState *dev;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600796
Markus Armbrusterc6ecec42020-07-07 18:05:35 +0200797 opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, errp);
798 if (!opts) {
Markus Armbruster485febc2015-03-13 17:25:50 +0100799 return;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600800 }
801 if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
802 qemu_opts_del(opts);
Markus Armbruster485febc2015-03-13 17:25:50 +0100803 return;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600804 }
Markus Armbruster668f62e2020-07-07 18:06:02 +0200805 dev = qdev_device_add(opts, errp);
Paolo Bonzinib09995a2013-01-25 14:12:37 +0100806 if (!dev) {
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600807 qemu_opts_del(opts);
Markus Armbruster485febc2015-03-13 17:25:50 +0100808 return;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600809 }
Paolo Bonzinib09995a2013-01-25 14:12:37 +0100810 object_unref(OBJECT(dev));
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600811}
812
Kevin Wolf6c1db522016-09-20 13:38:41 +0200813static DeviceState *find_device_state(const char *id, Error **errp)
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600814{
Igor Mammedovb6cc36a2014-10-02 10:08:45 +0000815 Object *obj;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600816
Daniel P. Berrange6287d822015-09-11 13:33:56 +0100817 if (id[0] == '/') {
818 obj = object_resolve_path(id, NULL);
819 } else {
820 char *root_path = object_get_canonical_path(qdev_get_peripheral());
821 char *path = g_strdup_printf("%s/%s", root_path, id);
822
823 g_free(root_path);
824 obj = object_resolve_path_type(path, TYPE_DEVICE, NULL);
825 g_free(path);
826 }
Igor Mammedovb6cc36a2014-10-02 10:08:45 +0000827
828 if (!obj) {
Markus Armbruster75158eb2015-03-16 08:57:47 +0100829 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
830 "Device '%s' not found", id);
Kevin Wolf6c1db522016-09-20 13:38:41 +0200831 return NULL;
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600832 }
Luiz Capitulino56f91072012-03-14 17:37:38 -0300833
Daniel P. Berrange6287d822015-09-11 13:33:56 +0100834 if (!object_dynamic_cast(obj, TYPE_DEVICE)) {
835 error_setg(errp, "%s is not a hotpluggable device", id);
Kevin Wolf6c1db522016-09-20 13:38:41 +0200836 return NULL;
Daniel P. Berrange6287d822015-09-11 13:33:56 +0100837 }
838
Kevin Wolf6c1db522016-09-20 13:38:41 +0200839 return DEVICE(obj);
840}
841
Juan Quintela32900672017-03-28 11:22:51 +0200842void qdev_unplug(DeviceState *dev, Error **errp)
843{
844 DeviceClass *dc = DEVICE_GET_CLASS(dev);
845 HotplugHandler *hotplug_ctrl;
846 HotplugHandlerClass *hdc;
David Hildenbrand07578b02019-02-28 13:28:47 +0100847 Error *local_err = NULL;
Juan Quintela32900672017-03-28 11:22:51 +0200848
849 if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
850 error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
851 return;
852 }
853
854 if (!dc->hotpluggable) {
855 error_setg(errp, QERR_DEVICE_NO_HOTPLUG,
856 object_get_typename(OBJECT(dev)));
857 return;
858 }
859
Jens Freimanna1190ab2019-10-29 12:49:01 +0100860 if (!migration_is_idle() && !dev->allow_unplug_during_migration) {
Juan Quintelab06424d2017-03-22 17:34:27 +0100861 error_setg(errp, "device_del not allowed while migrating");
862 return;
863 }
864
Juan Quintela32900672017-03-28 11:22:51 +0200865 qdev_hot_removed = true;
866
867 hotplug_ctrl = qdev_get_hotplug_handler(dev);
868 /* hotpluggable device MUST have HotplugHandler, if it doesn't
869 * then something is very wrong with it */
870 g_assert(hotplug_ctrl);
871
872 /* If device supports async unplug just request it to be done,
873 * otherwise just remove it synchronously */
874 hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);
875 if (hdc->unplug_request) {
David Hildenbrand07578b02019-02-28 13:28:47 +0100876 hotplug_handler_unplug_request(hotplug_ctrl, dev, &local_err);
Juan Quintela32900672017-03-28 11:22:51 +0200877 } else {
David Hildenbrand07578b02019-02-28 13:28:47 +0100878 hotplug_handler_unplug(hotplug_ctrl, dev, &local_err);
879 if (!local_err) {
880 object_unparent(OBJECT(dev));
881 }
Juan Quintela32900672017-03-28 11:22:51 +0200882 }
David Hildenbrand07578b02019-02-28 13:28:47 +0100883 error_propagate(errp, local_err);
Juan Quintela32900672017-03-28 11:22:51 +0200884}
885
Kevin Wolf6c1db522016-09-20 13:38:41 +0200886void qmp_device_del(const char *id, Error **errp)
887{
888 DeviceState *dev = find_device_state(id, errp);
889 if (dev != NULL) {
Julia Suvorovacce89442020-02-20 17:55:56 +0100890 if (dev->pending_deleted_event) {
891 error_setg(errp, "Device %s is already in the "
892 "process of unplug", id);
893 return;
894 }
895
Kevin Wolf6c1db522016-09-20 13:38:41 +0200896 qdev_unplug(dev, errp);
897 }
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600898}
899
Markus Armbrusterd94bd092019-07-09 20:59:36 +0200900void hmp_device_add(Monitor *mon, const QDict *qdict)
901{
902 Error *err = NULL;
903
904 qmp_device_add((QDict *)qdict, NULL, &err);
Vladimir Sementsov-Ogievskiy187c6142019-12-05 20:46:18 +0300905 hmp_handle_error(mon, err);
Markus Armbrusterd94bd092019-07-09 20:59:36 +0200906}
907
908void hmp_device_del(Monitor *mon, const QDict *qdict)
909{
910 const char *id = qdict_get_str(qdict, "id");
911 Error *err = NULL;
912
913 qmp_device_del(id, &err);
Vladimir Sementsov-Ogievskiy187c6142019-12-05 20:46:18 +0300914 hmp_handle_error(mon, err);
Markus Armbrusterd94bd092019-07-09 20:59:36 +0200915}
916
Kevin Wolf9680cae2016-09-20 13:38:42 +0200917BlockBackend *blk_by_qdev_id(const char *id, Error **errp)
918{
919 DeviceState *dev;
920 BlockBackend *blk;
921
922 dev = find_device_state(id, errp);
923 if (dev == NULL) {
924 return NULL;
925 }
926
927 blk = blk_by_dev(dev);
928 if (!blk) {
929 error_setg(errp, "Device does not have a block device backend");
930 }
931 return blk;
932}
933
Anthony Liguoriee46d8a2011-12-22 15:24:20 -0600934void qdev_machine_init(void)
935{
936 qdev_get_peripheral_anon();
937 qdev_get_peripheral();
938}
Paolo Bonzini4d454572012-11-26 16:03:42 +0100939
940QemuOptsList qemu_device_opts = {
941 .name = "device",
942 .implied_opt_name = "driver",
943 .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
944 .desc = {
945 /*
946 * no elements => accept any
947 * sanity checking will happen later
948 * when setting device properties
949 */
950 { /* end of list */ }
951 },
952};
953
954QemuOptsList qemu_global_opts = {
955 .name = "global",
956 .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
957 .desc = {
958 {
959 .name = "driver",
960 .type = QEMU_OPT_STRING,
961 },{
962 .name = "property",
963 .type = QEMU_OPT_STRING,
964 },{
965 .name = "value",
966 .type = QEMU_OPT_STRING,
967 },
968 { /* end of list */ }
969 },
970};
971
972int qemu_global_option(const char *str)
973{
974 char driver[64], property[64];
975 QemuOpts *opts;
976 int rc, offset;
977
Paolo Bonzini3751d7c2015-04-09 14:16:19 +0200978 rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset);
979 if (rc == 2 && str[offset] == '=') {
980 opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
981 qemu_opt_set(opts, "driver", driver, &error_abort);
982 qemu_opt_set(opts, "property", property, &error_abort);
983 qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
984 return 0;
985 }
986
Markus Armbruster70b94332015-02-13 12:50:26 +0100987 opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false);
Paolo Bonzini3751d7c2015-04-09 14:16:19 +0200988 if (!opts) {
Paolo Bonzini4d454572012-11-26 16:03:42 +0100989 return -1;
990 }
991
Paolo Bonzini4d454572012-11-26 16:03:42 +0100992 return 0;
993}