vfio/pci: Rename INTx functions for easier tracing
[qemu/kevin.git] / qdev-monitor.c
blobeb7aef2c81390221a044bfd08f2224b6463495c9
1 /*
2 * Dynamic device configuration and creation.
4 * Copyright (c) 2009 CodeSourcery
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.
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.
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/>.
20 #include "hw/qdev.h"
21 #include "hw/sysbus.h"
22 #include "monitor/monitor.h"
23 #include "monitor/qdev.h"
24 #include "qmp-commands.h"
25 #include "sysemu/arch_init.h"
26 #include "qapi/qmp/qerror.h"
27 #include "qemu/config-file.h"
28 #include "qemu/error-report.h"
31 * Aliases were a bad idea from the start. Let's keep them
32 * from spreading further.
34 typedef struct QDevAlias
36 const char *typename;
37 const char *alias;
38 uint32_t arch_mask;
39 } QDevAlias;
41 static const QDevAlias qdev_alias_table[] = {
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 },
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 },
50 { "lsi53c895a", "lsi" },
51 { "ich9-ahci", "ahci" },
52 { "kvm-pci-assign", "pci-assign" },
53 { }
56 static const char *qdev_class_get_alias(DeviceClass *dc)
58 const char *typename = object_class_get_name(OBJECT_CLASS(dc));
59 int i;
61 for (i = 0; qdev_alias_table[i].typename; i++) {
62 if (qdev_alias_table[i].arch_mask &&
63 !(qdev_alias_table[i].arch_mask & arch_type)) {
64 continue;
67 if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
68 return qdev_alias_table[i].alias;
72 return NULL;
75 static bool qdev_class_has_alias(DeviceClass *dc)
77 return (qdev_class_get_alias(dc) != NULL);
80 static void qdev_print_devinfo(DeviceClass *dc)
82 error_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
83 if (dc->bus_type) {
84 error_printf(", bus %s", dc->bus_type);
86 if (qdev_class_has_alias(dc)) {
87 error_printf(", alias \"%s\"", qdev_class_get_alias(dc));
89 if (dc->desc) {
90 error_printf(", desc \"%s\"", dc->desc);
92 if (dc->cannot_instantiate_with_device_add_yet) {
93 error_printf(", no-user");
95 error_printf("\n");
98 static gint devinfo_cmp(gconstpointer a, gconstpointer b)
100 return strcasecmp(object_class_get_name((ObjectClass *)a),
101 object_class_get_name((ObjectClass *)b));
104 static void qdev_print_devinfos(bool show_no_user)
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",
117 GSList *list, *elt;
118 int i;
119 bool cat_printed;
121 list = g_slist_sort(object_class_get_list(TYPE_DEVICE, false),
122 devinfo_cmp);
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))
132 || (!show_no_user
133 && dc->cannot_instantiate_with_device_add_yet)) {
134 continue;
136 if (!cat_printed) {
137 error_printf("%s%s devices:\n", i ? "\n" : "",
138 cat_name[i]);
139 cat_printed = true;
141 qdev_print_devinfo(dc);
145 g_slist_free(list);
148 static int set_property(void *opaque, const char *name, const char *value,
149 Error **errp)
151 Object *obj = opaque;
152 Error *err = NULL;
154 if (strcmp(name, "driver") == 0)
155 return 0;
156 if (strcmp(name, "bus") == 0)
157 return 0;
159 object_property_parse(obj, value, name, &err);
160 if (err != NULL) {
161 error_propagate(errp, err);
162 return -1;
164 return 0;
167 static const char *find_typename_by_alias(const char *alias)
169 int i;
171 for (i = 0; qdev_alias_table[i].alias; i++) {
172 if (qdev_alias_table[i].arch_mask &&
173 !(qdev_alias_table[i].arch_mask & arch_type)) {
174 continue;
177 if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
178 return qdev_alias_table[i].typename;
182 return NULL;
185 static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
187 ObjectClass *oc;
188 DeviceClass *dc;
190 oc = object_class_by_name(*driver);
191 if (!oc) {
192 const char *typename = find_typename_by_alias(*driver);
194 if (typename) {
195 *driver = typename;
196 oc = object_class_by_name(*driver);
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;
205 if (object_class_is_abstract(oc)) {
206 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
207 "non-abstract device type");
208 return NULL;
211 dc = DEVICE_CLASS(oc);
212 if (dc->cannot_instantiate_with_device_add_yet ||
213 (qdev_hotplug && !dc->hotpluggable)) {
214 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
215 "pluggable device type");
216 return NULL;
219 return dc;
223 int qdev_device_help(QemuOpts *opts)
225 Error *local_err = NULL;
226 const char *driver;
227 DevicePropertyInfoList *prop_list;
228 DevicePropertyInfoList *prop;
230 driver = qemu_opt_get(opts, "driver");
231 if (driver && is_help_option(driver)) {
232 qdev_print_devinfos(false);
233 return 1;
236 if (!driver || !qemu_opt_has_help_opt(opts)) {
237 return 0;
240 qdev_get_device_class(&driver, &local_err);
241 if (local_err) {
242 goto error;
245 prop_list = qmp_device_list_properties(driver, &local_err);
246 if (local_err) {
247 goto error;
250 for (prop = prop_list; prop; prop = prop->next) {
251 error_printf("%s.%s=%s", driver,
252 prop->value->name,
253 prop->value->type);
254 if (prop->value->has_description) {
255 error_printf(" (%s)\n", prop->value->description);
256 } else {
257 error_printf("\n");
261 qapi_free_DevicePropertyInfoList(prop_list);
262 return 1;
264 error:
265 error_printf("%s\n", error_get_pretty(local_err));
266 error_free(local_err);
267 return 1;
270 static Object *qdev_get_peripheral(void)
272 static Object *dev;
274 if (dev == NULL) {
275 dev = container_get(qdev_get_machine(), "/peripheral");
278 return dev;
281 static Object *qdev_get_peripheral_anon(void)
283 static Object *dev;
285 if (dev == NULL) {
286 dev = container_get(qdev_get_machine(), "/peripheral-anon");
289 return dev;
292 static void qbus_list_bus(DeviceState *dev, Error **errp)
294 BusState *child;
295 const char *sep = " ";
297 error_append_hint(errp, "child buses at \"%s\":",
298 dev->id ? dev->id : object_get_typename(OBJECT(dev)));
299 QLIST_FOREACH(child, &dev->child_bus, sibling) {
300 error_append_hint(errp, "%s\"%s\"", sep, child->name);
301 sep = ", ";
305 static void qbus_list_dev(BusState *bus, Error **errp)
307 BusChild *kid;
308 const char *sep = " ";
310 error_append_hint(errp, "devices at \"%s\":", bus->name);
311 QTAILQ_FOREACH(kid, &bus->children, sibling) {
312 DeviceState *dev = kid->child;
313 error_append_hint(errp, "%s\"%s\"", sep,
314 object_get_typename(OBJECT(dev)));
315 if (dev->id) {
316 error_append_hint(errp, "/\"%s\"", dev->id);
318 sep = ", ";
322 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
324 BusState *child;
326 QLIST_FOREACH(child, &dev->child_bus, sibling) {
327 if (strcmp(child->name, elem) == 0) {
328 return child;
331 return NULL;
334 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
336 BusChild *kid;
339 * try to match in order:
340 * (1) instance id, if present
341 * (2) driver name
342 * (3) driver alias, if present
344 QTAILQ_FOREACH(kid, &bus->children, sibling) {
345 DeviceState *dev = kid->child;
346 if (dev->id && strcmp(dev->id, elem) == 0) {
347 return dev;
350 QTAILQ_FOREACH(kid, &bus->children, sibling) {
351 DeviceState *dev = kid->child;
352 if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
353 return dev;
356 QTAILQ_FOREACH(kid, &bus->children, sibling) {
357 DeviceState *dev = kid->child;
358 DeviceClass *dc = DEVICE_GET_CLASS(dev);
360 if (qdev_class_has_alias(dc) &&
361 strcmp(qdev_class_get_alias(dc), elem) == 0) {
362 return dev;
365 return NULL;
368 static inline bool qbus_is_full(BusState *bus)
370 BusClass *bus_class = BUS_GET_CLASS(bus);
371 return bus_class->max_dev && bus->max_index >= bus_class->max_dev;
375 * Search the tree rooted at @bus for a bus.
376 * If @name, search for a bus with that name. Note that bus names
377 * need not be unique. Yes, that's screwed up.
378 * Else search for a bus that is a subtype of @bus_typename.
379 * If more than one exists, prefer one that can take another device.
380 * Return the bus if found, else %NULL.
382 static BusState *qbus_find_recursive(BusState *bus, const char *name,
383 const char *bus_typename)
385 BusChild *kid;
386 BusState *pick, *child, *ret;
387 bool match;
389 assert(name || bus_typename);
390 if (name) {
391 match = !strcmp(bus->name, name);
392 } else {
393 match = !!object_dynamic_cast(OBJECT(bus), bus_typename);
396 if (match && !qbus_is_full(bus)) {
397 return bus; /* root matches and isn't full */
400 pick = match ? bus : NULL;
402 QTAILQ_FOREACH(kid, &bus->children, sibling) {
403 DeviceState *dev = kid->child;
404 QLIST_FOREACH(child, &dev->child_bus, sibling) {
405 ret = qbus_find_recursive(child, name, bus_typename);
406 if (ret && !qbus_is_full(ret)) {
407 return ret; /* a descendant matches and isn't full */
409 if (ret && !pick) {
410 pick = ret;
415 /* root or a descendant matches, but is full */
416 return pick;
419 static BusState *qbus_find(const char *path, Error **errp)
421 DeviceState *dev;
422 BusState *bus;
423 char elem[128];
424 int pos, len;
426 /* find start element */
427 if (path[0] == '/') {
428 bus = sysbus_get_default();
429 pos = 0;
430 } else {
431 if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
432 assert(!path[0]);
433 elem[0] = len = 0;
435 bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
436 if (!bus) {
437 error_setg(errp, "Bus '%s' not found", elem);
438 return NULL;
440 pos = len;
443 for (;;) {
444 assert(path[pos] == '/' || !path[pos]);
445 while (path[pos] == '/') {
446 pos++;
448 if (path[pos] == '\0') {
449 break;
452 /* find device */
453 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
454 g_assert_not_reached();
455 elem[0] = len = 0;
457 pos += len;
458 dev = qbus_find_dev(bus, elem);
459 if (!dev) {
460 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
461 "Device '%s' not found", elem);
462 qbus_list_dev(bus, errp);
463 return NULL;
466 assert(path[pos] == '/' || !path[pos]);
467 while (path[pos] == '/') {
468 pos++;
470 if (path[pos] == '\0') {
471 /* last specified element is a device. If it has exactly
472 * one child bus accept it nevertheless */
473 if (dev->num_child_bus == 1) {
474 bus = QLIST_FIRST(&dev->child_bus);
475 break;
477 if (dev->num_child_bus) {
478 error_setg(errp, "Device '%s' has multiple child buses",
479 elem);
480 qbus_list_bus(dev, errp);
481 } else {
482 error_setg(errp, "Device '%s' has no child bus", elem);
484 return NULL;
487 /* find bus */
488 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
489 g_assert_not_reached();
490 elem[0] = len = 0;
492 pos += len;
493 bus = qbus_find_bus(dev, elem);
494 if (!bus) {
495 error_setg(errp, "Bus '%s' not found", elem);
496 qbus_list_bus(dev, errp);
497 return NULL;
501 if (qbus_is_full(bus)) {
502 error_setg(errp, "Bus '%s' is full", path);
503 return NULL;
505 return bus;
508 DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
510 DeviceClass *dc;
511 const char *driver, *path, *id;
512 DeviceState *dev;
513 BusState *bus = NULL;
514 Error *err = NULL;
516 driver = qemu_opt_get(opts, "driver");
517 if (!driver) {
518 error_setg(errp, QERR_MISSING_PARAMETER, "driver");
519 return NULL;
522 /* find driver */
523 dc = qdev_get_device_class(&driver, errp);
524 if (!dc) {
525 return NULL;
528 /* find bus */
529 path = qemu_opt_get(opts, "bus");
530 if (path != NULL) {
531 bus = qbus_find(path, errp);
532 if (!bus) {
533 return NULL;
535 if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
536 error_setg(errp, "Device '%s' can't go on %s bus",
537 driver, object_get_typename(OBJECT(bus)));
538 return NULL;
540 } else if (dc->bus_type != NULL) {
541 bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
542 if (!bus || qbus_is_full(bus)) {
543 error_setg(errp, "No '%s' bus found for device '%s'",
544 dc->bus_type, driver);
545 return NULL;
548 if (qdev_hotplug && bus && !qbus_is_hotpluggable(bus)) {
549 error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
550 return NULL;
553 /* create device */
554 dev = DEVICE(object_new(driver));
556 if (bus) {
557 qdev_set_parent_bus(dev, bus);
560 id = qemu_opts_id(opts);
561 if (id) {
562 dev->id = id;
565 if (dev->id) {
566 object_property_add_child(qdev_get_peripheral(), dev->id,
567 OBJECT(dev), NULL);
568 } else {
569 static int anon_count;
570 gchar *name = g_strdup_printf("device[%d]", anon_count++);
571 object_property_add_child(qdev_get_peripheral_anon(), name,
572 OBJECT(dev), NULL);
573 g_free(name);
576 /* set properties */
577 if (qemu_opt_foreach(opts, set_property, dev, &err)) {
578 error_propagate(errp, err);
579 object_unparent(OBJECT(dev));
580 object_unref(OBJECT(dev));
581 return NULL;
584 dev->opts = opts;
585 object_property_set_bool(OBJECT(dev), true, "realized", &err);
586 if (err != NULL) {
587 error_propagate(errp, err);
588 dev->opts = NULL;
589 object_unparent(OBJECT(dev));
590 object_unref(OBJECT(dev));
591 return NULL;
593 return dev;
597 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
598 static void qbus_print(Monitor *mon, BusState *bus, int indent);
600 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
601 int indent)
603 if (!props)
604 return;
605 for (; props->name; props++) {
606 Error *err = NULL;
607 char *value;
608 char *legacy_name = g_strdup_printf("legacy-%s", props->name);
609 if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
610 value = object_property_get_str(OBJECT(dev), legacy_name, &err);
611 } else {
612 value = object_property_print(OBJECT(dev), props->name, true, &err);
614 g_free(legacy_name);
616 if (err) {
617 error_free(err);
618 continue;
620 qdev_printf("%s = %s\n", props->name,
621 value && *value ? value : "<null>");
622 g_free(value);
626 static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
628 BusClass *bc = BUS_GET_CLASS(bus);
630 if (bc->print_dev) {
631 bc->print_dev(mon, dev, indent);
635 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
637 ObjectClass *class;
638 BusState *child;
639 NamedGPIOList *ngl;
641 qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
642 dev->id ? dev->id : "");
643 indent += 2;
644 QLIST_FOREACH(ngl, &dev->gpios, node) {
645 if (ngl->num_in) {
646 qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
647 ngl->num_in);
649 if (ngl->num_out) {
650 qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
651 ngl->num_out);
654 class = object_get_class(OBJECT(dev));
655 do {
656 qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent);
657 class = object_class_get_parent(class);
658 } while (class != object_class_by_name(TYPE_DEVICE));
659 bus_print_dev(dev->parent_bus, mon, dev, indent);
660 QLIST_FOREACH(child, &dev->child_bus, sibling) {
661 qbus_print(mon, child, indent);
665 static void qbus_print(Monitor *mon, BusState *bus, int indent)
667 BusChild *kid;
669 qdev_printf("bus: %s\n", bus->name);
670 indent += 2;
671 qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
672 QTAILQ_FOREACH(kid, &bus->children, sibling) {
673 DeviceState *dev = kid->child;
674 qdev_print(mon, dev, indent);
677 #undef qdev_printf
679 void hmp_info_qtree(Monitor *mon, const QDict *qdict)
681 if (sysbus_get_default())
682 qbus_print(mon, sysbus_get_default(), 0);
685 void hmp_info_qdm(Monitor *mon, const QDict *qdict)
687 qdev_print_devinfos(true);
690 typedef struct QOMCompositionState {
691 Monitor *mon;
692 int indent;
693 } QOMCompositionState;
695 static void print_qom_composition(Monitor *mon, Object *obj, int indent);
697 static int print_qom_composition_child(Object *obj, void *opaque)
699 QOMCompositionState *s = opaque;
701 print_qom_composition(s->mon, obj, s->indent);
703 return 0;
706 static void print_qom_composition(Monitor *mon, Object *obj, int indent)
708 QOMCompositionState s = {
709 .mon = mon,
710 .indent = indent + 2,
712 char *name;
714 if (obj == object_get_root()) {
715 name = g_strdup("");
716 } else {
717 name = object_get_canonical_path_component(obj);
719 monitor_printf(mon, "%*s/%s (%s)\n", indent, "", name,
720 object_get_typename(obj));
721 g_free(name);
722 object_child_foreach(obj, print_qom_composition_child, &s);
725 void hmp_info_qom_tree(Monitor *mon, const QDict *dict)
727 const char *path = qdict_get_try_str(dict, "path");
728 Object *obj;
729 bool ambiguous = false;
731 if (path) {
732 obj = object_resolve_path(path, &ambiguous);
733 if (!obj) {
734 monitor_printf(mon, "Path '%s' could not be resolved.\n", path);
735 return;
737 if (ambiguous) {
738 monitor_printf(mon, "Warning: Path '%s' is ambiguous.\n", path);
739 return;
741 } else {
742 obj = qdev_get_machine();
744 print_qom_composition(mon, obj, 0);
747 void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
749 Error *local_err = NULL;
750 QemuOpts *opts;
751 DeviceState *dev;
753 opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
754 if (local_err) {
755 error_propagate(errp, local_err);
756 return;
758 if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
759 qemu_opts_del(opts);
760 return;
762 dev = qdev_device_add(opts, &local_err);
763 if (!dev) {
764 error_propagate(errp, local_err);
765 qemu_opts_del(opts);
766 return;
768 object_unref(OBJECT(dev));
771 void qmp_device_del(const char *id, Error **errp)
773 Object *obj;
775 if (id[0] == '/') {
776 obj = object_resolve_path(id, NULL);
777 } else {
778 char *root_path = object_get_canonical_path(qdev_get_peripheral());
779 char *path = g_strdup_printf("%s/%s", root_path, id);
781 g_free(root_path);
782 obj = object_resolve_path_type(path, TYPE_DEVICE, NULL);
783 g_free(path);
786 if (!obj) {
787 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
788 "Device '%s' not found", id);
789 return;
792 if (!object_dynamic_cast(obj, TYPE_DEVICE)) {
793 error_setg(errp, "%s is not a hotpluggable device", id);
794 return;
797 qdev_unplug(DEVICE(obj), errp);
800 void qdev_machine_init(void)
802 qdev_get_peripheral_anon();
803 qdev_get_peripheral();
806 QemuOptsList qemu_device_opts = {
807 .name = "device",
808 .implied_opt_name = "driver",
809 .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
810 .desc = {
812 * no elements => accept any
813 * sanity checking will happen later
814 * when setting device properties
816 { /* end of list */ }
820 QemuOptsList qemu_global_opts = {
821 .name = "global",
822 .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
823 .desc = {
825 .name = "driver",
826 .type = QEMU_OPT_STRING,
828 .name = "property",
829 .type = QEMU_OPT_STRING,
831 .name = "value",
832 .type = QEMU_OPT_STRING,
834 { /* end of list */ }
838 int qemu_global_option(const char *str)
840 char driver[64], property[64];
841 QemuOpts *opts;
842 int rc, offset;
844 rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset);
845 if (rc == 2 && str[offset] == '=') {
846 opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
847 qemu_opt_set(opts, "driver", driver, &error_abort);
848 qemu_opt_set(opts, "property", property, &error_abort);
849 qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
850 return 0;
853 opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false);
854 if (!opts) {
855 return -1;
858 return 0;