qdev: Move error printing to the end of qdev_device_help()
[qemu.git] / qdev-monitor.c
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
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 "qemu/config-file.h"
27
28 /*
29 * Aliases were a bad idea from the start. Let's keep them
30 * from spreading further.
31 */
32 typedef struct QDevAlias
33 {
34 const char *typename;
35 const char *alias;
36 uint32_t arch_mask;
37 } QDevAlias;
38
39 static const QDevAlias qdev_alias_table[] = {
40 { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
41 { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
42 { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
43 { "virtio-balloon-pci", "virtio-balloon",
44 QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
45 { "virtio-blk-s390", "virtio-blk", QEMU_ARCH_S390X },
46 { "virtio-net-s390", "virtio-net", QEMU_ARCH_S390X },
47 { "virtio-serial-s390", "virtio-serial", QEMU_ARCH_S390X },
48 { "lsi53c895a", "lsi" },
49 { "ich9-ahci", "ahci" },
50 { "kvm-pci-assign", "pci-assign" },
51 { }
52 };
53
54 static const char *qdev_class_get_alias(DeviceClass *dc)
55 {
56 const char *typename = object_class_get_name(OBJECT_CLASS(dc));
57 int i;
58
59 for (i = 0; qdev_alias_table[i].typename; i++) {
60 if (qdev_alias_table[i].arch_mask &&
61 !(qdev_alias_table[i].arch_mask & arch_type)) {
62 continue;
63 }
64
65 if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
66 return qdev_alias_table[i].alias;
67 }
68 }
69
70 return NULL;
71 }
72
73 static bool qdev_class_has_alias(DeviceClass *dc)
74 {
75 return (qdev_class_get_alias(dc) != NULL);
76 }
77
78 static void qdev_print_devinfo(DeviceClass *dc)
79 {
80 error_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
81 if (dc->bus_type) {
82 error_printf(", bus %s", dc->bus_type);
83 }
84 if (qdev_class_has_alias(dc)) {
85 error_printf(", alias \"%s\"", qdev_class_get_alias(dc));
86 }
87 if (dc->desc) {
88 error_printf(", desc \"%s\"", dc->desc);
89 }
90 if (dc->cannot_instantiate_with_device_add_yet) {
91 error_printf(", no-user");
92 }
93 error_printf("\n");
94 }
95
96 static gint devinfo_cmp(gconstpointer a, gconstpointer b)
97 {
98 return strcasecmp(object_class_get_name((ObjectClass *)a),
99 object_class_get_name((ObjectClass *)b));
100 }
101
102 static void qdev_print_devinfos(bool show_no_user)
103 {
104 static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = {
105 [DEVICE_CATEGORY_BRIDGE] = "Controller/Bridge/Hub",
106 [DEVICE_CATEGORY_USB] = "USB",
107 [DEVICE_CATEGORY_STORAGE] = "Storage",
108 [DEVICE_CATEGORY_NETWORK] = "Network",
109 [DEVICE_CATEGORY_INPUT] = "Input",
110 [DEVICE_CATEGORY_DISPLAY] = "Display",
111 [DEVICE_CATEGORY_SOUND] = "Sound",
112 [DEVICE_CATEGORY_MISC] = "Misc",
113 [DEVICE_CATEGORY_MAX] = "Uncategorized",
114 };
115 GSList *list, *elt;
116 int i;
117 bool cat_printed;
118
119 list = g_slist_sort(object_class_get_list(TYPE_DEVICE, false),
120 devinfo_cmp);
121
122 for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) {
123 cat_printed = false;
124 for (elt = list; elt; elt = elt->next) {
125 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
126 TYPE_DEVICE);
127 if ((i < DEVICE_CATEGORY_MAX
128 ? !test_bit(i, dc->categories)
129 : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX))
130 || (!show_no_user
131 && dc->cannot_instantiate_with_device_add_yet)) {
132 continue;
133 }
134 if (!cat_printed) {
135 error_printf("%s%s devices:\n", i ? "\n" : "",
136 cat_name[i]);
137 cat_printed = true;
138 }
139 qdev_print_devinfo(dc);
140 }
141 }
142
143 g_slist_free(list);
144 }
145
146 static int set_property(const char *name, const char *value, void *opaque)
147 {
148 Object *obj = opaque;
149 Error *err = NULL;
150
151 if (strcmp(name, "driver") == 0)
152 return 0;
153 if (strcmp(name, "bus") == 0)
154 return 0;
155
156 object_property_parse(obj, value, name, &err);
157 if (err != NULL) {
158 qerror_report_err(err);
159 error_free(err);
160 return -1;
161 }
162 return 0;
163 }
164
165 static const char *find_typename_by_alias(const char *alias)
166 {
167 int i;
168
169 for (i = 0; qdev_alias_table[i].alias; i++) {
170 if (qdev_alias_table[i].arch_mask &&
171 !(qdev_alias_table[i].arch_mask & arch_type)) {
172 continue;
173 }
174
175 if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
176 return qdev_alias_table[i].typename;
177 }
178 }
179
180 return NULL;
181 }
182
183 static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
184 {
185 ObjectClass *oc;
186 DeviceClass *dc;
187
188 oc = object_class_by_name(*driver);
189 if (!oc) {
190 const char *typename = find_typename_by_alias(*driver);
191
192 if (typename) {
193 *driver = typename;
194 oc = object_class_by_name(*driver);
195 }
196 }
197
198 if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) {
199 error_setg(errp, "'%s' is not a valid device model name", *driver);
200 return NULL;
201 }
202
203 if (object_class_is_abstract(oc)) {
204 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
205 "non-abstract device type");
206 return NULL;
207 }
208
209 dc = DEVICE_CLASS(oc);
210 if (dc->cannot_instantiate_with_device_add_yet ||
211 (qdev_hotplug && !dc->hotpluggable)) {
212 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
213 "pluggable device type");
214 return NULL;
215 }
216
217 return dc;
218 }
219
220
221 int qdev_device_help(QemuOpts *opts)
222 {
223 Error *local_err = NULL;
224 const char *driver;
225 DevicePropertyInfoList *prop_list;
226 DevicePropertyInfoList *prop;
227
228 driver = qemu_opt_get(opts, "driver");
229 if (driver && is_help_option(driver)) {
230 qdev_print_devinfos(false);
231 return 1;
232 }
233
234 if (!driver || !qemu_opt_has_help_opt(opts)) {
235 return 0;
236 }
237
238 if (!object_class_by_name(driver)) {
239 const char *typename = find_typename_by_alias(driver);
240
241 if (typename) {
242 driver = typename;
243 }
244 }
245
246 prop_list = qmp_device_list_properties(driver, &local_err);
247 if (local_err) {
248 goto error;
249 }
250
251 for (prop = prop_list; prop; prop = prop->next) {
252 error_printf("%s.%s=%s", driver,
253 prop->value->name,
254 prop->value->type);
255 if (prop->value->has_description) {
256 error_printf(" (%s)\n", prop->value->description);
257 } else {
258 error_printf("\n");
259 }
260 }
261
262 qapi_free_DevicePropertyInfoList(prop_list);
263 return 1;
264
265 error:
266 error_printf("%s\n", error_get_pretty(local_err));
267 error_free(local_err);
268 return 1;
269 }
270
271 static Object *qdev_get_peripheral(void)
272 {
273 static Object *dev;
274
275 if (dev == NULL) {
276 dev = container_get(qdev_get_machine(), "/peripheral");
277 }
278
279 return dev;
280 }
281
282 static Object *qdev_get_peripheral_anon(void)
283 {
284 static Object *dev;
285
286 if (dev == NULL) {
287 dev = container_get(qdev_get_machine(), "/peripheral-anon");
288 }
289
290 return dev;
291 }
292
293 static void qbus_list_bus(DeviceState *dev)
294 {
295 BusState *child;
296 const char *sep = " ";
297
298 error_printf("child busses at \"%s\":",
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 {
309 BusChild *kid;
310 const char *sep = " ";
311
312 error_printf("devices at \"%s\":", bus->name);
313 QTAILQ_FOREACH(kid, &bus->children, sibling) {
314 DeviceState *dev = kid->child;
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 }
322
323 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
324 {
325 BusState *child;
326
327 QLIST_FOREACH(child, &dev->child_bus, sibling) {
328 if (strcmp(child->name, elem) == 0) {
329 return child;
330 }
331 }
332 return NULL;
333 }
334
335 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
336 {
337 BusChild *kid;
338
339 /*
340 * try to match in order:
341 * (1) instance id, if present
342 * (2) driver name
343 * (3) driver alias, if present
344 */
345 QTAILQ_FOREACH(kid, &bus->children, sibling) {
346 DeviceState *dev = kid->child;
347 if (dev->id && strcmp(dev->id, elem) == 0) {
348 return dev;
349 }
350 }
351 QTAILQ_FOREACH(kid, &bus->children, sibling) {
352 DeviceState *dev = kid->child;
353 if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
354 return dev;
355 }
356 }
357 QTAILQ_FOREACH(kid, &bus->children, sibling) {
358 DeviceState *dev = kid->child;
359 DeviceClass *dc = DEVICE_GET_CLASS(dev);
360
361 if (qdev_class_has_alias(dc) &&
362 strcmp(qdev_class_get_alias(dc), elem) == 0) {
363 return dev;
364 }
365 }
366 return NULL;
367 }
368
369 static BusState *qbus_find_recursive(BusState *bus, const char *name,
370 const char *bus_typename)
371 {
372 BusClass *bus_class = BUS_GET_CLASS(bus);
373 BusChild *kid;
374 BusState *child, *ret;
375 int match = 1;
376
377 if (name && (strcmp(bus->name, name) != 0)) {
378 match = 0;
379 } else if (bus_typename && !object_dynamic_cast(OBJECT(bus), bus_typename)) {
380 match = 0;
381 } else if ((bus_class->max_dev != 0) && (bus_class->max_dev <= bus->max_index)) {
382 if (name != NULL) {
383 /* bus was explicitly specified: return an error. */
384 qerror_report(ERROR_CLASS_GENERIC_ERROR, "Bus '%s' is full",
385 bus->name);
386 return NULL;
387 } else {
388 /* bus was not specified: try to find another one. */
389 match = 0;
390 }
391 }
392 if (match) {
393 return bus;
394 }
395
396 QTAILQ_FOREACH(kid, &bus->children, sibling) {
397 DeviceState *dev = kid->child;
398 QLIST_FOREACH(child, &dev->child_bus, sibling) {
399 ret = qbus_find_recursive(child, name, bus_typename);
400 if (ret) {
401 return ret;
402 }
403 }
404 }
405 return NULL;
406 }
407
408 static BusState *qbus_find(const char *path)
409 {
410 DeviceState *dev;
411 BusState *bus;
412 char elem[128];
413 int pos, len;
414
415 /* find start element */
416 if (path[0] == '/') {
417 bus = sysbus_get_default();
418 pos = 0;
419 } else {
420 if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
421 assert(!path[0]);
422 elem[0] = len = 0;
423 }
424 bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
425 if (!bus) {
426 qerror_report(QERR_BUS_NOT_FOUND, elem);
427 return NULL;
428 }
429 pos = len;
430 }
431
432 for (;;) {
433 assert(path[pos] == '/' || !path[pos]);
434 while (path[pos] == '/') {
435 pos++;
436 }
437 if (path[pos] == '\0') {
438 return bus;
439 }
440
441 /* find device */
442 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
443 g_assert_not_reached();
444 elem[0] = len = 0;
445 }
446 pos += len;
447 dev = qbus_find_dev(bus, elem);
448 if (!dev) {
449 qerror_report(QERR_DEVICE_NOT_FOUND, elem);
450 if (!monitor_cur_is_qmp()) {
451 qbus_list_dev(bus);
452 }
453 return NULL;
454 }
455
456 assert(path[pos] == '/' || !path[pos]);
457 while (path[pos] == '/') {
458 pos++;
459 }
460 if (path[pos] == '\0') {
461 /* last specified element is a device. If it has exactly
462 * one child bus accept it nevertheless */
463 switch (dev->num_child_bus) {
464 case 0:
465 qerror_report(ERROR_CLASS_GENERIC_ERROR,
466 "Device '%s' has no child bus", elem);
467 return NULL;
468 case 1:
469 return QLIST_FIRST(&dev->child_bus);
470 default:
471 qerror_report(ERROR_CLASS_GENERIC_ERROR,
472 "Device '%s' has multiple child busses", elem);
473 if (!monitor_cur_is_qmp()) {
474 qbus_list_bus(dev);
475 }
476 return NULL;
477 }
478 }
479
480 /* find bus */
481 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
482 g_assert_not_reached();
483 elem[0] = len = 0;
484 }
485 pos += len;
486 bus = qbus_find_bus(dev, elem);
487 if (!bus) {
488 qerror_report(QERR_BUS_NOT_FOUND, elem);
489 if (!monitor_cur_is_qmp()) {
490 qbus_list_bus(dev);
491 }
492 return NULL;
493 }
494 }
495 }
496
497 DeviceState *qdev_device_add(QemuOpts *opts)
498 {
499 DeviceClass *dc;
500 const char *driver, *path, *id;
501 DeviceState *dev;
502 BusState *bus = NULL;
503 Error *err = NULL;
504
505 driver = qemu_opt_get(opts, "driver");
506 if (!driver) {
507 qerror_report(QERR_MISSING_PARAMETER, "driver");
508 return NULL;
509 }
510
511 /* find driver */
512 dc = qdev_get_device_class(&driver, &err);
513 if (err) {
514 qerror_report_err(err);
515 error_free(err);
516 return NULL;
517 }
518
519 /* find bus */
520 path = qemu_opt_get(opts, "bus");
521 if (path != NULL) {
522 bus = qbus_find(path);
523 if (!bus) {
524 return NULL;
525 }
526 if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
527 qerror_report(ERROR_CLASS_GENERIC_ERROR,
528 "Device '%s' can't go on a %s bus",
529 driver, object_get_typename(OBJECT(bus)));
530 return NULL;
531 }
532 } else if (dc->bus_type != NULL) {
533 bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
534 if (!bus) {
535 qerror_report(ERROR_CLASS_GENERIC_ERROR,
536 "No '%s' bus found for device '%s'",
537 dc->bus_type, driver);
538 return NULL;
539 }
540 }
541 if (qdev_hotplug && bus && !qbus_is_hotpluggable(bus)) {
542 qerror_report(QERR_BUS_NO_HOTPLUG, bus->name);
543 return NULL;
544 }
545
546 /* create device */
547 dev = DEVICE(object_new(driver));
548
549 if (bus) {
550 qdev_set_parent_bus(dev, bus);
551 }
552
553 id = qemu_opts_id(opts);
554 if (id) {
555 dev->id = id;
556 }
557
558 if (dev->id) {
559 object_property_add_child(qdev_get_peripheral(), dev->id,
560 OBJECT(dev), NULL);
561 } else {
562 static int anon_count;
563 gchar *name = g_strdup_printf("device[%d]", anon_count++);
564 object_property_add_child(qdev_get_peripheral_anon(), name,
565 OBJECT(dev), NULL);
566 g_free(name);
567 }
568
569 /* set properties */
570 if (qemu_opt_foreach(opts, set_property, dev, 1) != 0) {
571 object_unparent(OBJECT(dev));
572 object_unref(OBJECT(dev));
573 return NULL;
574 }
575
576 dev->opts = opts;
577 object_property_set_bool(OBJECT(dev), true, "realized", &err);
578 if (err != NULL) {
579 qerror_report_err(err);
580 error_free(err);
581 dev->opts = NULL;
582 object_unparent(OBJECT(dev));
583 object_unref(OBJECT(dev));
584 qerror_report(QERR_DEVICE_INIT_FAILED, driver);
585 return NULL;
586 }
587 return dev;
588 }
589
590
591 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
592 static void qbus_print(Monitor *mon, BusState *bus, int indent);
593
594 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
595 int indent)
596 {
597 if (!props)
598 return;
599 for (; props->name; props++) {
600 Error *err = NULL;
601 char *value;
602 char *legacy_name = g_strdup_printf("legacy-%s", props->name);
603 if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
604 value = object_property_get_str(OBJECT(dev), legacy_name, &err);
605 } else {
606 value = object_property_print(OBJECT(dev), props->name, true, &err);
607 }
608 g_free(legacy_name);
609
610 if (err) {
611 error_free(err);
612 continue;
613 }
614 qdev_printf("%s = %s\n", props->name,
615 value && *value ? value : "<null>");
616 g_free(value);
617 }
618 }
619
620 static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
621 {
622 BusClass *bc = BUS_GET_CLASS(bus);
623
624 if (bc->print_dev) {
625 bc->print_dev(mon, dev, indent);
626 }
627 }
628
629 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
630 {
631 ObjectClass *class;
632 BusState *child;
633 NamedGPIOList *ngl;
634
635 qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
636 dev->id ? dev->id : "");
637 indent += 2;
638 QLIST_FOREACH(ngl, &dev->gpios, node) {
639 if (ngl->num_in) {
640 qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
641 ngl->num_in);
642 }
643 if (ngl->num_out) {
644 qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
645 ngl->num_out);
646 }
647 }
648 class = object_get_class(OBJECT(dev));
649 do {
650 qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent);
651 class = object_class_get_parent(class);
652 } while (class != object_class_by_name(TYPE_DEVICE));
653 bus_print_dev(dev->parent_bus, mon, dev, indent);
654 QLIST_FOREACH(child, &dev->child_bus, sibling) {
655 qbus_print(mon, child, indent);
656 }
657 }
658
659 static void qbus_print(Monitor *mon, BusState *bus, int indent)
660 {
661 BusChild *kid;
662
663 qdev_printf("bus: %s\n", bus->name);
664 indent += 2;
665 qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
666 QTAILQ_FOREACH(kid, &bus->children, sibling) {
667 DeviceState *dev = kid->child;
668 qdev_print(mon, dev, indent);
669 }
670 }
671 #undef qdev_printf
672
673 void do_info_qtree(Monitor *mon, const QDict *qdict)
674 {
675 if (sysbus_get_default())
676 qbus_print(mon, sysbus_get_default(), 0);
677 }
678
679 void do_info_qdm(Monitor *mon, const QDict *qdict)
680 {
681 qdev_print_devinfos(true);
682 }
683
684 int do_device_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
685 {
686 Error *local_err = NULL;
687 QemuOpts *opts;
688 DeviceState *dev;
689
690 opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
691 if (local_err) {
692 qerror_report_err(local_err);
693 error_free(local_err);
694 return -1;
695 }
696 if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
697 qemu_opts_del(opts);
698 return 0;
699 }
700 dev = qdev_device_add(opts);
701 if (!dev) {
702 qemu_opts_del(opts);
703 return -1;
704 }
705 object_unref(OBJECT(dev));
706 return 0;
707 }
708
709 void qmp_device_del(const char *id, Error **errp)
710 {
711 Object *obj;
712 char *root_path = object_get_canonical_path(qdev_get_peripheral());
713 char *path = g_strdup_printf("%s/%s", root_path, id);
714
715 g_free(root_path);
716 obj = object_resolve_path_type(path, TYPE_DEVICE, NULL);
717 g_free(path);
718
719 if (!obj) {
720 error_set(errp, QERR_DEVICE_NOT_FOUND, id);
721 return;
722 }
723
724 qdev_unplug(DEVICE(obj), errp);
725 }
726
727 void qdev_machine_init(void)
728 {
729 qdev_get_peripheral_anon();
730 qdev_get_peripheral();
731 }
732
733 QemuOptsList qemu_device_opts = {
734 .name = "device",
735 .implied_opt_name = "driver",
736 .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
737 .desc = {
738 /*
739 * no elements => accept any
740 * sanity checking will happen later
741 * when setting device properties
742 */
743 { /* end of list */ }
744 },
745 };
746
747 QemuOptsList qemu_global_opts = {
748 .name = "global",
749 .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
750 .desc = {
751 {
752 .name = "driver",
753 .type = QEMU_OPT_STRING,
754 },{
755 .name = "property",
756 .type = QEMU_OPT_STRING,
757 },{
758 .name = "value",
759 .type = QEMU_OPT_STRING,
760 },
761 { /* end of list */ }
762 },
763 };
764
765 int qemu_global_option(const char *str)
766 {
767 char driver[64], property[64];
768 QemuOpts *opts;
769 int rc, offset;
770
771 rc = sscanf(str, "%63[^.].%63[^=]%n", driver, property, &offset);
772 if (rc < 2 || str[offset] != '=') {
773 error_report("can't parse: \"%s\"", str);
774 return -1;
775 }
776
777 opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
778 qemu_opt_set(opts, "driver", driver);
779 qemu_opt_set(opts, "property", property);
780 qemu_opt_set(opts, "value", str+offset+1);
781 return 0;
782 }