]>
Commit | Line | Data |
---|---|---|
ee46d8a5 AL |
1 | /* |
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 | ||
b4a42f81 | 20 | #include "hw/qdev.h" |
2f7bd829 | 21 | #include "hw/sysbus.h" |
83c9089e | 22 | #include "monitor/monitor.h" |
b4a42f81 | 23 | #include "monitor/qdev.h" |
a15fef21 | 24 | #include "qmp-commands.h" |
9c17d615 | 25 | #include "sysemu/arch_init.h" |
cc7a8ea7 | 26 | #include "qapi/qmp/qerror.h" |
1de7afc9 | 27 | #include "qemu/config-file.h" |
d49b6836 | 28 | #include "qemu/error-report.h" |
ee46d8a5 AL |
29 | |
30 | /* | |
31 | * Aliases were a bad idea from the start. Let's keep them | |
32 | * from spreading further. | |
33 | */ | |
34 | typedef struct QDevAlias | |
35 | { | |
36 | const char *typename; | |
37 | const char *alias; | |
5f629d94 | 38 | uint32_t arch_mask; |
ee46d8a5 AL |
39 | } QDevAlias; |
40 | ||
41 | static const QDevAlias qdev_alias_table[] = { | |
5f629d94 AG |
42 | { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X }, |
43 | { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X }, | |
44 | { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X }, | |
45 | { "virtio-balloon-pci", "virtio-balloon", | |
46 | QEMU_ARCH_ALL & ~QEMU_ARCH_S390X }, | |
1f68f1d3 AG |
47 | { "virtio-blk-ccw", "virtio-blk", QEMU_ARCH_S390X }, |
48 | { "virtio-net-ccw", "virtio-net", QEMU_ARCH_S390X }, | |
49 | { "virtio-serial-ccw", "virtio-serial", QEMU_ARCH_S390X }, | |
ee46d8a5 AL |
50 | { "lsi53c895a", "lsi" }, |
51 | { "ich9-ahci", "ahci" }, | |
c3ebd3ba | 52 | { "kvm-pci-assign", "pci-assign" }, |
ee46d8a5 AL |
53 | { } |
54 | }; | |
55 | ||
56 | static const char *qdev_class_get_alias(DeviceClass *dc) | |
57 | { | |
58 | const char *typename = object_class_get_name(OBJECT_CLASS(dc)); | |
59 | int i; | |
60 | ||
61 | for (i = 0; qdev_alias_table[i].typename; i++) { | |
5f629d94 AG |
62 | if (qdev_alias_table[i].arch_mask && |
63 | !(qdev_alias_table[i].arch_mask & arch_type)) { | |
64 | continue; | |
65 | } | |
66 | ||
ee46d8a5 AL |
67 | if (strcmp(qdev_alias_table[i].typename, typename) == 0) { |
68 | return qdev_alias_table[i].alias; | |
69 | } | |
70 | } | |
71 | ||
72 | return NULL; | |
73 | } | |
74 | ||
75 | static bool qdev_class_has_alias(DeviceClass *dc) | |
76 | { | |
77 | return (qdev_class_get_alias(dc) != NULL); | |
78 | } | |
79 | ||
a3400aee | 80 | static void qdev_print_devinfo(DeviceClass *dc) |
ee46d8a5 | 81 | { |
a3400aee | 82 | error_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc))); |
0d936928 AL |
83 | if (dc->bus_type) { |
84 | error_printf(", bus %s", dc->bus_type); | |
ee46d8a5 AL |
85 | } |
86 | if (qdev_class_has_alias(dc)) { | |
87 | error_printf(", alias \"%s\"", qdev_class_get_alias(dc)); | |
88 | } | |
89 | if (dc->desc) { | |
90 | error_printf(", desc \"%s\"", dc->desc); | |
91 | } | |
efec3dd6 | 92 | if (dc->cannot_instantiate_with_device_add_yet) { |
ee46d8a5 AL |
93 | error_printf(", no-user"); |
94 | } | |
95 | error_printf("\n"); | |
96 | } | |
97 | ||
a3400aee MA |
98 | static gint devinfo_cmp(gconstpointer a, gconstpointer b) |
99 | { | |
100 | return strcasecmp(object_class_get_name((ObjectClass *)a), | |
101 | object_class_get_name((ObjectClass *)b)); | |
102 | } | |
103 | ||
104 | static void qdev_print_devinfos(bool show_no_user) | |
105 | { | |
106 | static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = { | |
107 | [DEVICE_CATEGORY_BRIDGE] = "Controller/Bridge/Hub", | |
108 | [DEVICE_CATEGORY_USB] = "USB", | |
109 | [DEVICE_CATEGORY_STORAGE] = "Storage", | |
110 | [DEVICE_CATEGORY_NETWORK] = "Network", | |
111 | [DEVICE_CATEGORY_INPUT] = "Input", | |
112 | [DEVICE_CATEGORY_DISPLAY] = "Display", | |
113 | [DEVICE_CATEGORY_SOUND] = "Sound", | |
114 | [DEVICE_CATEGORY_MISC] = "Misc", | |
115 | [DEVICE_CATEGORY_MAX] = "Uncategorized", | |
116 | }; | |
117 | GSList *list, *elt; | |
118 | int i; | |
119 | bool cat_printed; | |
120 | ||
121 | list = g_slist_sort(object_class_get_list(TYPE_DEVICE, false), | |
122 | devinfo_cmp); | |
123 | ||
124 | for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) { | |
125 | cat_printed = false; | |
126 | for (elt = list; elt; elt = elt->next) { | |
127 | DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data, | |
128 | TYPE_DEVICE); | |
129 | if ((i < DEVICE_CATEGORY_MAX | |
130 | ? !test_bit(i, dc->categories) | |
131 | : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX)) | |
efec3dd6 MA |
132 | || (!show_no_user |
133 | && dc->cannot_instantiate_with_device_add_yet)) { | |
a3400aee MA |
134 | continue; |
135 | } | |
136 | if (!cat_printed) { | |
137 | error_printf("%s%s devices:\n", i ? "\n" : "", | |
138 | cat_name[i]); | |
139 | cat_printed = true; | |
140 | } | |
141 | qdev_print_devinfo(dc); | |
142 | } | |
143 | } | |
144 | ||
145 | g_slist_free(list); | |
146 | } | |
147 | ||
71df1d83 MA |
148 | static int set_property(void *opaque, const char *name, const char *value, |
149 | Error **errp) | |
ee46d8a5 | 150 | { |
98a65284 | 151 | Object *obj = opaque; |
b1fe9bcb | 152 | Error *err = NULL; |
ee46d8a5 AL |
153 | |
154 | if (strcmp(name, "driver") == 0) | |
155 | return 0; | |
156 | if (strcmp(name, "bus") == 0) | |
157 | return 0; | |
158 | ||
98a65284 | 159 | object_property_parse(obj, value, name, &err); |
b1fe9bcb | 160 | if (err != NULL) { |
4caa489d | 161 | error_propagate(errp, err); |
ee46d8a5 AL |
162 | return -1; |
163 | } | |
164 | return 0; | |
165 | } | |
166 | ||
167 | static const char *find_typename_by_alias(const char *alias) | |
168 | { | |
169 | int i; | |
170 | ||
171 | for (i = 0; qdev_alias_table[i].alias; i++) { | |
5f629d94 AG |
172 | if (qdev_alias_table[i].arch_mask && |
173 | !(qdev_alias_table[i].arch_mask & arch_type)) { | |
174 | continue; | |
175 | } | |
176 | ||
ee46d8a5 AL |
177 | if (strcmp(qdev_alias_table[i].alias, alias) == 0) { |
178 | return qdev_alias_table[i].typename; | |
179 | } | |
180 | } | |
181 | ||
182 | return NULL; | |
183 | } | |
184 | ||
43c95d78 EH |
185 | static DeviceClass *qdev_get_device_class(const char **driver, Error **errp) |
186 | { | |
187 | ObjectClass *oc; | |
188 | DeviceClass *dc; | |
189 | ||
190 | oc = object_class_by_name(*driver); | |
191 | if (!oc) { | |
192 | const char *typename = find_typename_by_alias(*driver); | |
193 | ||
194 | if (typename) { | |
195 | *driver = typename; | |
196 | oc = object_class_by_name(*driver); | |
197 | } | |
198 | } | |
199 | ||
200 | if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) { | |
201 | error_setg(errp, "'%s' is not a valid device model name", *driver); | |
202 | return NULL; | |
203 | } | |
204 | ||
205 | if (object_class_is_abstract(oc)) { | |
c6bd8c70 MA |
206 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", |
207 | "non-abstract device type"); | |
43c95d78 EH |
208 | return NULL; |
209 | } | |
210 | ||
211 | dc = DEVICE_CLASS(oc); | |
212 | if (dc->cannot_instantiate_with_device_add_yet || | |
213 | (qdev_hotplug && !dc->hotpluggable)) { | |
c6bd8c70 MA |
214 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", |
215 | "pluggable device type"); | |
43c95d78 EH |
216 | return NULL; |
217 | } | |
218 | ||
219 | return dc; | |
220 | } | |
221 | ||
222 | ||
ee46d8a5 AL |
223 | int qdev_device_help(QemuOpts *opts) |
224 | { | |
ef523587 | 225 | Error *local_err = NULL; |
ee46d8a5 | 226 | const char *driver; |
ef523587 SH |
227 | DevicePropertyInfoList *prop_list; |
228 | DevicePropertyInfoList *prop; | |
ee46d8a5 AL |
229 | |
230 | driver = qemu_opt_get(opts, "driver"); | |
c8057f95 | 231 | if (driver && is_help_option(driver)) { |
a3400aee | 232 | qdev_print_devinfos(false); |
ee46d8a5 AL |
233 | return 1; |
234 | } | |
235 | ||
c8057f95 | 236 | if (!driver || !qemu_opt_has_help_opt(opts)) { |
ee46d8a5 AL |
237 | return 0; |
238 | } | |
239 | ||
31bed550 EH |
240 | qdev_get_device_class(&driver, &local_err); |
241 | if (local_err) { | |
242 | goto error; | |
ee46d8a5 AL |
243 | } |
244 | ||
ef523587 | 245 | prop_list = qmp_device_list_properties(driver, &local_err); |
0722eba9 | 246 | if (local_err) { |
5185f0e0 | 247 | goto error; |
ee46d8a5 | 248 | } |
ef523587 SH |
249 | |
250 | for (prop = prop_list; prop; prop = prop->next) { | |
07d09c58 | 251 | error_printf("%s.%s=%s", driver, |
ef523587 SH |
252 | prop->value->name, |
253 | prop->value->type); | |
07d09c58 GA |
254 | if (prop->value->has_description) { |
255 | error_printf(" (%s)\n", prop->value->description); | |
256 | } else { | |
257 | error_printf("\n"); | |
258 | } | |
ef523587 SH |
259 | } |
260 | ||
261 | qapi_free_DevicePropertyInfoList(prop_list); | |
ee46d8a5 | 262 | return 1; |
5185f0e0 EH |
263 | |
264 | error: | |
265 | error_printf("%s\n", error_get_pretty(local_err)); | |
266 | error_free(local_err); | |
267 | return 1; | |
ee46d8a5 AL |
268 | } |
269 | ||
57c9fafe | 270 | static Object *qdev_get_peripheral(void) |
ee46d8a5 | 271 | { |
8b45d447 | 272 | static Object *dev; |
ee46d8a5 AL |
273 | |
274 | if (dev == NULL) { | |
dfe47e70 | 275 | dev = container_get(qdev_get_machine(), "/peripheral"); |
ee46d8a5 AL |
276 | } |
277 | ||
8b45d447 | 278 | return dev; |
ee46d8a5 AL |
279 | } |
280 | ||
57c9fafe | 281 | static Object *qdev_get_peripheral_anon(void) |
ee46d8a5 | 282 | { |
8b45d447 | 283 | static Object *dev; |
ee46d8a5 AL |
284 | |
285 | if (dev == NULL) { | |
dfe47e70 | 286 | dev = container_get(qdev_get_machine(), "/peripheral-anon"); |
ee46d8a5 AL |
287 | } |
288 | ||
8b45d447 | 289 | return dev; |
ee46d8a5 AL |
290 | } |
291 | ||
d2828429 | 292 | #if 0 /* conversion from qerror_report() to error_set() broke their use */ |
ee46d8a5 AL |
293 | static void qbus_list_bus(DeviceState *dev) |
294 | { | |
295 | BusState *child; | |
296 | const char *sep = " "; | |
297 | ||
d2828429 | 298 | error_printf("child buses at \"%s\":", |
ee46d8a5 AL |
299 | dev->id ? dev->id : object_get_typename(OBJECT(dev))); |
300 | QLIST_FOREACH(child, &dev->child_bus, sibling) { | |
301 | error_printf("%s\"%s\"", sep, child->name); | |
302 | sep = ", "; | |
303 | } | |
304 | error_printf("\n"); | |
305 | } | |
306 | ||
307 | static void qbus_list_dev(BusState *bus) | |
308 | { | |
0866aca1 | 309 | BusChild *kid; |
ee46d8a5 AL |
310 | const char *sep = " "; |
311 | ||
312 | error_printf("devices at \"%s\":", bus->name); | |
0866aca1 AL |
313 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
314 | DeviceState *dev = kid->child; | |
ee46d8a5 AL |
315 | error_printf("%s\"%s\"", sep, object_get_typename(OBJECT(dev))); |
316 | if (dev->id) | |
317 | error_printf("/\"%s\"", dev->id); | |
318 | sep = ", "; | |
319 | } | |
320 | error_printf("\n"); | |
321 | } | |
d2828429 | 322 | #endif |
ee46d8a5 AL |
323 | |
324 | static BusState *qbus_find_bus(DeviceState *dev, char *elem) | |
325 | { | |
326 | BusState *child; | |
327 | ||
328 | QLIST_FOREACH(child, &dev->child_bus, sibling) { | |
329 | if (strcmp(child->name, elem) == 0) { | |
330 | return child; | |
331 | } | |
332 | } | |
333 | return NULL; | |
334 | } | |
335 | ||
336 | static DeviceState *qbus_find_dev(BusState *bus, char *elem) | |
337 | { | |
0866aca1 | 338 | BusChild *kid; |
ee46d8a5 AL |
339 | |
340 | /* | |
341 | * try to match in order: | |
342 | * (1) instance id, if present | |
343 | * (2) driver name | |
344 | * (3) driver alias, if present | |
345 | */ | |
0866aca1 AL |
346 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
347 | DeviceState *dev = kid->child; | |
ee46d8a5 AL |
348 | if (dev->id && strcmp(dev->id, elem) == 0) { |
349 | return dev; | |
350 | } | |
351 | } | |
0866aca1 AL |
352 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
353 | DeviceState *dev = kid->child; | |
ee46d8a5 AL |
354 | if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) { |
355 | return dev; | |
356 | } | |
357 | } | |
0866aca1 AL |
358 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
359 | DeviceState *dev = kid->child; | |
ee46d8a5 AL |
360 | DeviceClass *dc = DEVICE_GET_CLASS(dev); |
361 | ||
362 | if (qdev_class_has_alias(dc) && | |
363 | strcmp(qdev_class_get_alias(dc), elem) == 0) { | |
364 | return dev; | |
365 | } | |
366 | } | |
367 | return NULL; | |
368 | } | |
369 | ||
a5ec494e MA |
370 | static inline bool qbus_is_full(BusState *bus) |
371 | { | |
372 | BusClass *bus_class = BUS_GET_CLASS(bus); | |
373 | return bus_class->max_dev && bus->max_index >= bus_class->max_dev; | |
374 | } | |
375 | ||
376 | /* | |
377 | * Search the tree rooted at @bus for a bus. | |
378 | * If @name, search for a bus with that name. Note that bus names | |
379 | * need not be unique. Yes, that's screwed up. | |
380 | * Else search for a bus that is a subtype of @bus_typename. | |
381 | * If more than one exists, prefer one that can take another device. | |
382 | * Return the bus if found, else %NULL. | |
383 | */ | |
ee46d8a5 | 384 | static BusState *qbus_find_recursive(BusState *bus, const char *name, |
0d936928 | 385 | const char *bus_typename) |
ee46d8a5 | 386 | { |
0866aca1 | 387 | BusChild *kid; |
a5ec494e MA |
388 | BusState *pick, *child, *ret; |
389 | bool match; | |
390 | ||
391 | assert(name || bus_typename); | |
392 | if (name) { | |
393 | match = !strcmp(bus->name, name); | |
394 | } else { | |
395 | match = !!object_dynamic_cast(OBJECT(bus), bus_typename); | |
1395af6f | 396 | } |
a5ec494e MA |
397 | |
398 | if (match && !qbus_is_full(bus)) { | |
399 | return bus; /* root matches and isn't full */ | |
ee46d8a5 AL |
400 | } |
401 | ||
a5ec494e MA |
402 | pick = match ? bus : NULL; |
403 | ||
0866aca1 AL |
404 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
405 | DeviceState *dev = kid->child; | |
ee46d8a5 | 406 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
0d936928 | 407 | ret = qbus_find_recursive(child, name, bus_typename); |
a5ec494e MA |
408 | if (ret && !qbus_is_full(ret)) { |
409 | return ret; /* a descendant matches and isn't full */ | |
410 | } | |
411 | if (ret && !pick) { | |
412 | pick = ret; | |
ee46d8a5 AL |
413 | } |
414 | } | |
415 | } | |
a5ec494e MA |
416 | |
417 | /* root or a descendant matches, but is full */ | |
418 | return pick; | |
ee46d8a5 AL |
419 | } |
420 | ||
d2828429 | 421 | static BusState *qbus_find(const char *path, Error **errp) |
ee46d8a5 AL |
422 | { |
423 | DeviceState *dev; | |
424 | BusState *bus; | |
425 | char elem[128]; | |
426 | int pos, len; | |
427 | ||
428 | /* find start element */ | |
429 | if (path[0] == '/') { | |
430 | bus = sysbus_get_default(); | |
431 | pos = 0; | |
432 | } else { | |
433 | if (sscanf(path, "%127[^/]%n", elem, &len) != 1) { | |
434 | assert(!path[0]); | |
435 | elem[0] = len = 0; | |
436 | } | |
437 | bus = qbus_find_recursive(sysbus_get_default(), elem, NULL); | |
438 | if (!bus) { | |
d2828429 | 439 | error_setg(errp, "Bus '%s' not found", elem); |
ee46d8a5 AL |
440 | return NULL; |
441 | } | |
442 | pos = len; | |
443 | } | |
444 | ||
445 | for (;;) { | |
446 | assert(path[pos] == '/' || !path[pos]); | |
447 | while (path[pos] == '/') { | |
448 | pos++; | |
449 | } | |
450 | if (path[pos] == '\0') { | |
ed238ba2 | 451 | break; |
ee46d8a5 AL |
452 | } |
453 | ||
454 | /* find device */ | |
455 | if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) { | |
dfc6f865 | 456 | g_assert_not_reached(); |
ee46d8a5 AL |
457 | elem[0] = len = 0; |
458 | } | |
459 | pos += len; | |
460 | dev = qbus_find_dev(bus, elem); | |
461 | if (!dev) { | |
75158ebb MA |
462 | error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, |
463 | "Device '%s' not found", elem); | |
d2828429 | 464 | #if 0 /* conversion from qerror_report() to error_set() broke this: */ |
ee46d8a5 AL |
465 | if (!monitor_cur_is_qmp()) { |
466 | qbus_list_dev(bus); | |
467 | } | |
d2828429 | 468 | #endif |
ee46d8a5 AL |
469 | return NULL; |
470 | } | |
471 | ||
472 | assert(path[pos] == '/' || !path[pos]); | |
473 | while (path[pos] == '/') { | |
474 | pos++; | |
475 | } | |
476 | if (path[pos] == '\0') { | |
477 | /* last specified element is a device. If it has exactly | |
478 | * one child bus accept it nevertheless */ | |
ed238ba2 MA |
479 | if (dev->num_child_bus == 1) { |
480 | bus = QLIST_FIRST(&dev->child_bus); | |
481 | break; | |
482 | } | |
483 | if (dev->num_child_bus) { | |
d2828429 MA |
484 | error_setg(errp, "Device '%s' has multiple child buses", |
485 | elem); | |
486 | #if 0 /* conversion from qerror_report() to error_set() broke this: */ | |
ee46d8a5 AL |
487 | if (!monitor_cur_is_qmp()) { |
488 | qbus_list_bus(dev); | |
489 | } | |
d2828429 | 490 | #endif |
ed238ba2 | 491 | } else { |
d2828429 | 492 | error_setg(errp, "Device '%s' has no child bus", elem); |
ee46d8a5 | 493 | } |
ed238ba2 | 494 | return NULL; |
ee46d8a5 AL |
495 | } |
496 | ||
497 | /* find bus */ | |
498 | if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) { | |
dfc6f865 | 499 | g_assert_not_reached(); |
ee46d8a5 AL |
500 | elem[0] = len = 0; |
501 | } | |
502 | pos += len; | |
503 | bus = qbus_find_bus(dev, elem); | |
504 | if (!bus) { | |
d2828429 MA |
505 | error_setg(errp, "Bus '%s' not found", elem); |
506 | #if 0 /* conversion from qerror_report() to error_set() broke this: */ | |
ee46d8a5 AL |
507 | if (!monitor_cur_is_qmp()) { |
508 | qbus_list_bus(dev); | |
509 | } | |
d2828429 | 510 | #endif |
ee46d8a5 AL |
511 | return NULL; |
512 | } | |
513 | } | |
ed238ba2 MA |
514 | |
515 | if (qbus_is_full(bus)) { | |
d2828429 | 516 | error_setg(errp, "Bus '%s' is full", path); |
ed238ba2 MA |
517 | return NULL; |
518 | } | |
519 | return bus; | |
ee46d8a5 AL |
520 | } |
521 | ||
f006cf7f | 522 | DeviceState *qdev_device_add(QemuOpts *opts, Error **errp) |
ee46d8a5 | 523 | { |
f4d85795 | 524 | DeviceClass *dc; |
ee46d8a5 | 525 | const char *driver, *path, *id; |
2bcb0c62 | 526 | DeviceState *dev; |
2f7bd829 | 527 | BusState *bus = NULL; |
852e2c50 | 528 | Error *err = NULL; |
ee46d8a5 AL |
529 | |
530 | driver = qemu_opt_get(opts, "driver"); | |
531 | if (!driver) { | |
c6bd8c70 | 532 | error_setg(errp, QERR_MISSING_PARAMETER, "driver"); |
ee46d8a5 AL |
533 | return NULL; |
534 | } | |
535 | ||
536 | /* find driver */ | |
f006cf7f MA |
537 | dc = qdev_get_device_class(&driver, errp); |
538 | if (!dc) { | |
7ea5e78f MA |
539 | return NULL; |
540 | } | |
ee46d8a5 AL |
541 | |
542 | /* find bus */ | |
543 | path = qemu_opt_get(opts, "bus"); | |
544 | if (path != NULL) { | |
f006cf7f | 545 | bus = qbus_find(path, errp); |
ee46d8a5 AL |
546 | if (!bus) { |
547 | return NULL; | |
548 | } | |
f4d85795 | 549 | if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) { |
f006cf7f MA |
550 | error_setg(errp, "Device '%s' can't go on %s bus", |
551 | driver, object_get_typename(OBJECT(bus))); | |
ee46d8a5 AL |
552 | return NULL; |
553 | } | |
f4d85795 AF |
554 | } else if (dc->bus_type != NULL) { |
555 | bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type); | |
a5ec494e | 556 | if (!bus || qbus_is_full(bus)) { |
f006cf7f MA |
557 | error_setg(errp, "No '%s' bus found for device '%s'", |
558 | dc->bus_type, driver); | |
ee46d8a5 AL |
559 | return NULL; |
560 | } | |
561 | } | |
39b888bd | 562 | if (qdev_hotplug && bus && !qbus_is_hotpluggable(bus)) { |
c6bd8c70 | 563 | error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name); |
ee46d8a5 AL |
564 | return NULL; |
565 | } | |
566 | ||
7b030949 | 567 | /* create device */ |
2bcb0c62 | 568 | dev = DEVICE(object_new(driver)); |
2f7bd829 AF |
569 | |
570 | if (bus) { | |
2bcb0c62 | 571 | qdev_set_parent_bus(dev, bus); |
2f7bd829 | 572 | } |
ee46d8a5 AL |
573 | |
574 | id = qemu_opts_id(opts); | |
575 | if (id) { | |
2bcb0c62 | 576 | dev->id = id; |
b2d4b3f7 | 577 | } |
7b030949 | 578 | |
2bcb0c62 AF |
579 | if (dev->id) { |
580 | object_property_add_child(qdev_get_peripheral(), dev->id, | |
581 | OBJECT(dev), NULL); | |
ee46d8a5 AL |
582 | } else { |
583 | static int anon_count; | |
584 | gchar *name = g_strdup_printf("device[%d]", anon_count++); | |
57c9fafe | 585 | object_property_add_child(qdev_get_peripheral_anon(), name, |
2bcb0c62 | 586 | OBJECT(dev), NULL); |
ee46d8a5 | 587 | g_free(name); |
2bcb0c62 | 588 | } |
52aa17cb | 589 | |
7b030949 | 590 | /* set properties */ |
4caa489d | 591 | if (qemu_opt_foreach(opts, set_property, dev, &err)) { |
f006cf7f | 592 | error_propagate(errp, err); |
7b030949 AK |
593 | object_unparent(OBJECT(dev)); |
594 | object_unref(OBJECT(dev)); | |
595 | return NULL; | |
596 | } | |
597 | ||
52aa17cb | 598 | dev->opts = opts; |
852e2c50 AF |
599 | object_property_set_bool(OBJECT(dev), true, "realized", &err); |
600 | if (err != NULL) { | |
f006cf7f | 601 | error_propagate(errp, err); |
52aa17cb | 602 | dev->opts = NULL; |
852e2c50 | 603 | object_unparent(OBJECT(dev)); |
2bcb0c62 | 604 | object_unref(OBJECT(dev)); |
f424d5c4 PB |
605 | return NULL; |
606 | } | |
2bcb0c62 | 607 | return dev; |
ee46d8a5 AL |
608 | } |
609 | ||
610 | ||
611 | #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__) | |
612 | static void qbus_print(Monitor *mon, BusState *bus, int indent); | |
613 | ||
614 | static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props, | |
bce54474 | 615 | int indent) |
ee46d8a5 | 616 | { |
ee46d8a5 AL |
617 | if (!props) |
618 | return; | |
d822979b PB |
619 | for (; props->name; props++) { |
620 | Error *err = NULL; | |
621 | char *value; | |
622 | char *legacy_name = g_strdup_printf("legacy-%s", props->name); | |
623 | if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) { | |
624 | value = object_property_get_str(OBJECT(dev), legacy_name, &err); | |
625 | } else { | |
dae3bda4 | 626 | value = object_property_print(OBJECT(dev), props->name, true, &err); |
d822979b PB |
627 | } |
628 | g_free(legacy_name); | |
629 | ||
630 | if (err) { | |
631 | error_free(err); | |
632 | continue; | |
ee46d8a5 | 633 | } |
bce54474 | 634 | qdev_printf("%s = %s\n", props->name, |
d822979b PB |
635 | value && *value ? value : "<null>"); |
636 | g_free(value); | |
ee46d8a5 AL |
637 | } |
638 | } | |
639 | ||
0d936928 AL |
640 | static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent) |
641 | { | |
642 | BusClass *bc = BUS_GET_CLASS(bus); | |
643 | ||
644 | if (bc->print_dev) { | |
645 | bc->print_dev(mon, dev, indent); | |
646 | } | |
647 | } | |
648 | ||
ee46d8a5 AL |
649 | static void qdev_print(Monitor *mon, DeviceState *dev, int indent) |
650 | { | |
bce54474 | 651 | ObjectClass *class; |
ee46d8a5 | 652 | BusState *child; |
a5f54290 PC |
653 | NamedGPIOList *ngl; |
654 | ||
ee46d8a5 AL |
655 | qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)), |
656 | dev->id ? dev->id : ""); | |
657 | indent += 2; | |
a5f54290 PC |
658 | QLIST_FOREACH(ngl, &dev->gpios, node) { |
659 | if (ngl->num_in) { | |
660 | qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "", | |
661 | ngl->num_in); | |
662 | } | |
663 | if (ngl->num_out) { | |
664 | qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "", | |
665 | ngl->num_out); | |
666 | } | |
ee46d8a5 | 667 | } |
bce54474 PB |
668 | class = object_get_class(OBJECT(dev)); |
669 | do { | |
670 | qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent); | |
671 | class = object_class_get_parent(class); | |
672 | } while (class != object_class_by_name(TYPE_DEVICE)); | |
da9fbe76 | 673 | bus_print_dev(dev->parent_bus, mon, dev, indent); |
ee46d8a5 AL |
674 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
675 | qbus_print(mon, child, indent); | |
676 | } | |
677 | } | |
678 | ||
679 | static void qbus_print(Monitor *mon, BusState *bus, int indent) | |
680 | { | |
0866aca1 | 681 | BusChild *kid; |
ee46d8a5 AL |
682 | |
683 | qdev_printf("bus: %s\n", bus->name); | |
684 | indent += 2; | |
0d936928 | 685 | qdev_printf("type %s\n", object_get_typename(OBJECT(bus))); |
0866aca1 AL |
686 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
687 | DeviceState *dev = kid->child; | |
ee46d8a5 AL |
688 | qdev_print(mon, dev, indent); |
689 | } | |
690 | } | |
691 | #undef qdev_printf | |
692 | ||
1ce6be24 | 693 | void hmp_info_qtree(Monitor *mon, const QDict *qdict) |
ee46d8a5 AL |
694 | { |
695 | if (sysbus_get_default()) | |
696 | qbus_print(mon, sysbus_get_default(), 0); | |
697 | } | |
698 | ||
1ce6be24 | 699 | void hmp_info_qdm(Monitor *mon, const QDict *qdict) |
ee46d8a5 | 700 | { |
a3400aee | 701 | qdev_print_devinfos(true); |
ee46d8a5 AL |
702 | } |
703 | ||
a01ff75f AF |
704 | typedef struct QOMCompositionState { |
705 | Monitor *mon; | |
706 | int indent; | |
707 | } QOMCompositionState; | |
708 | ||
709 | static void print_qom_composition(Monitor *mon, Object *obj, int indent); | |
710 | ||
711 | static int print_qom_composition_child(Object *obj, void *opaque) | |
712 | { | |
713 | QOMCompositionState *s = opaque; | |
714 | ||
715 | print_qom_composition(s->mon, obj, s->indent); | |
716 | ||
717 | return 0; | |
718 | } | |
719 | ||
720 | static void print_qom_composition(Monitor *mon, Object *obj, int indent) | |
721 | { | |
722 | QOMCompositionState s = { | |
723 | .mon = mon, | |
724 | .indent = indent + 2, | |
725 | }; | |
726 | char *name; | |
727 | ||
728 | if (obj == object_get_root()) { | |
729 | name = g_strdup(""); | |
730 | } else { | |
731 | name = object_get_canonical_path_component(obj); | |
732 | } | |
733 | monitor_printf(mon, "%*s/%s (%s)\n", indent, "", name, | |
734 | object_get_typename(obj)); | |
735 | g_free(name); | |
736 | object_child_foreach(obj, print_qom_composition_child, &s); | |
737 | } | |
738 | ||
739 | void hmp_info_qom_tree(Monitor *mon, const QDict *dict) | |
740 | { | |
741 | const char *path = qdict_get_try_str(dict, "path"); | |
742 | Object *obj; | |
743 | bool ambiguous = false; | |
744 | ||
745 | if (path) { | |
746 | obj = object_resolve_path(path, &ambiguous); | |
747 | if (!obj) { | |
748 | monitor_printf(mon, "Path '%s' could not be resolved.\n", path); | |
749 | return; | |
750 | } | |
751 | if (ambiguous) { | |
752 | monitor_printf(mon, "Warning: Path '%s' is ambiguous.\n", path); | |
753 | return; | |
754 | } | |
755 | } else { | |
756 | obj = qdev_get_machine(); | |
757 | } | |
758 | print_qom_composition(mon, obj, 0); | |
759 | } | |
760 | ||
485febc6 | 761 | void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp) |
ee46d8a5 | 762 | { |
4e89978e | 763 | Error *local_err = NULL; |
ee46d8a5 | 764 | QemuOpts *opts; |
b09995ae | 765 | DeviceState *dev; |
ee46d8a5 | 766 | |
4e89978e | 767 | opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err); |
84d18f06 | 768 | if (local_err) { |
485febc6 MA |
769 | error_propagate(errp, local_err); |
770 | return; | |
ee46d8a5 AL |
771 | } |
772 | if (!monitor_cur_is_qmp() && qdev_device_help(opts)) { | |
773 | qemu_opts_del(opts); | |
485febc6 | 774 | return; |
ee46d8a5 | 775 | } |
f006cf7f | 776 | dev = qdev_device_add(opts, &local_err); |
b09995ae | 777 | if (!dev) { |
485febc6 | 778 | error_propagate(errp, local_err); |
ee46d8a5 | 779 | qemu_opts_del(opts); |
485febc6 | 780 | return; |
ee46d8a5 | 781 | } |
b09995ae | 782 | object_unref(OBJECT(dev)); |
ee46d8a5 AL |
783 | } |
784 | ||
a15fef21 | 785 | void qmp_device_del(const char *id, Error **errp) |
ee46d8a5 | 786 | { |
b6cc36ab IM |
787 | Object *obj; |
788 | char *root_path = object_get_canonical_path(qdev_get_peripheral()); | |
789 | char *path = g_strdup_printf("%s/%s", root_path, id); | |
ee46d8a5 | 790 | |
b6cc36ab IM |
791 | g_free(root_path); |
792 | obj = object_resolve_path_type(path, TYPE_DEVICE, NULL); | |
793 | g_free(path); | |
794 | ||
795 | if (!obj) { | |
75158ebb MA |
796 | error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, |
797 | "Device '%s' not found", id); | |
a15fef21 | 798 | return; |
56f9107e LC |
799 | } |
800 | ||
b6cc36ab | 801 | qdev_unplug(DEVICE(obj), errp); |
ee46d8a5 AL |
802 | } |
803 | ||
804 | void qdev_machine_init(void) | |
805 | { | |
806 | qdev_get_peripheral_anon(); | |
807 | qdev_get_peripheral(); | |
808 | } | |
4d454574 PB |
809 | |
810 | QemuOptsList qemu_device_opts = { | |
811 | .name = "device", | |
812 | .implied_opt_name = "driver", | |
813 | .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head), | |
814 | .desc = { | |
815 | /* | |
816 | * no elements => accept any | |
817 | * sanity checking will happen later | |
818 | * when setting device properties | |
819 | */ | |
820 | { /* end of list */ } | |
821 | }, | |
822 | }; | |
823 | ||
824 | QemuOptsList qemu_global_opts = { | |
825 | .name = "global", | |
826 | .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head), | |
827 | .desc = { | |
828 | { | |
829 | .name = "driver", | |
830 | .type = QEMU_OPT_STRING, | |
831 | },{ | |
832 | .name = "property", | |
833 | .type = QEMU_OPT_STRING, | |
834 | },{ | |
835 | .name = "value", | |
836 | .type = QEMU_OPT_STRING, | |
837 | }, | |
838 | { /* end of list */ } | |
839 | }, | |
840 | }; | |
841 | ||
842 | int qemu_global_option(const char *str) | |
843 | { | |
844 | char driver[64], property[64]; | |
845 | QemuOpts *opts; | |
846 | int rc, offset; | |
847 | ||
3751d7c4 PB |
848 | rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset); |
849 | if (rc == 2 && str[offset] == '=') { | |
850 | opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort); | |
851 | qemu_opt_set(opts, "driver", driver, &error_abort); | |
852 | qemu_opt_set(opts, "property", property, &error_abort); | |
853 | qemu_opt_set(opts, "value", str + offset + 1, &error_abort); | |
854 | return 0; | |
855 | } | |
856 | ||
70b94331 | 857 | opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false); |
3751d7c4 | 858 | if (!opts) { |
4d454574 PB |
859 | return -1; |
860 | } | |
861 | ||
4d454574 PB |
862 | return 0; |
863 | } |