Update version for 2.11.2 release
[qemu.git] / hw / core / qdev.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 /* The theory here is that it should be possible to create a machine without
21 knowledge of specific devices. Historically board init routines have
22 passed a bunch of arguments to each device, requiring the board know
23 exactly which device it is dealing with. This file provides an abstract
24 API for device configuration and initialization. Devices will generally
25 inherit from a particular bus (e.g. PCI or I2C) rather than
26 this API directly. */
27
28 #include "qemu/osdep.h"
29 #include "hw/qdev.h"
30 #include "hw/fw-path-provider.h"
31 #include "sysemu/sysemu.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qemu/error-report.h"
36 #include "hw/hotplug.h"
37 #include "hw/boards.h"
38 #include "hw/sysbus.h"
39 #include "qapi-event.h"
40
41 bool qdev_hotplug = false;
42 static bool qdev_hot_added = false;
43 bool qdev_hot_removed = false;
44
45 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
46 {
47 DeviceClass *dc = DEVICE_GET_CLASS(dev);
48 return dc->vmsd;
49 }
50
51 const char *qdev_fw_name(DeviceState *dev)
52 {
53 DeviceClass *dc = DEVICE_GET_CLASS(dev);
54
55 if (dc->fw_name) {
56 return dc->fw_name;
57 }
58
59 return object_get_typename(OBJECT(dev));
60 }
61
62 static void bus_remove_child(BusState *bus, DeviceState *child)
63 {
64 BusChild *kid;
65
66 QTAILQ_FOREACH(kid, &bus->children, sibling) {
67 if (kid->child == child) {
68 char name[32];
69
70 snprintf(name, sizeof(name), "child[%d]", kid->index);
71 QTAILQ_REMOVE(&bus->children, kid, sibling);
72
73 /* This gives back ownership of kid->child back to us. */
74 object_property_del(OBJECT(bus), name, NULL);
75 object_unref(OBJECT(kid->child));
76 g_free(kid);
77 return;
78 }
79 }
80 }
81
82 static void bus_add_child(BusState *bus, DeviceState *child)
83 {
84 char name[32];
85 BusChild *kid = g_malloc0(sizeof(*kid));
86
87 kid->index = bus->max_index++;
88 kid->child = child;
89 object_ref(OBJECT(kid->child));
90
91 QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
92
93 /* This transfers ownership of kid->child to the property. */
94 snprintf(name, sizeof(name), "child[%d]", kid->index);
95 object_property_add_link(OBJECT(bus), name,
96 object_get_typename(OBJECT(child)),
97 (Object **)&kid->child,
98 NULL, /* read-only property */
99 0, /* return ownership on prop deletion */
100 NULL);
101 }
102
103 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
104 {
105 bool replugging = dev->parent_bus != NULL;
106
107 if (replugging) {
108 /* Keep a reference to the device while it's not plugged into
109 * any bus, to avoid it potentially evaporating when it is
110 * dereffed in bus_remove_child().
111 */
112 object_ref(OBJECT(dev));
113 bus_remove_child(dev->parent_bus, dev);
114 object_unref(OBJECT(dev->parent_bus));
115 }
116 dev->parent_bus = bus;
117 object_ref(OBJECT(bus));
118 bus_add_child(bus, dev);
119 if (replugging) {
120 object_unref(OBJECT(dev));
121 }
122 }
123
124 /* Create a new device. This only initializes the device state
125 structure and allows properties to be set. The device still needs
126 to be realized. See qdev-core.h. */
127 DeviceState *qdev_create(BusState *bus, const char *name)
128 {
129 DeviceState *dev;
130
131 dev = qdev_try_create(bus, name);
132 if (!dev) {
133 if (bus) {
134 error_report("Unknown device '%s' for bus '%s'", name,
135 object_get_typename(OBJECT(bus)));
136 } else {
137 error_report("Unknown device '%s' for default sysbus", name);
138 }
139 abort();
140 }
141
142 return dev;
143 }
144
145 DeviceState *qdev_try_create(BusState *bus, const char *type)
146 {
147 DeviceState *dev;
148
149 if (object_class_by_name(type) == NULL) {
150 return NULL;
151 }
152 dev = DEVICE(object_new(type));
153 if (!dev) {
154 return NULL;
155 }
156
157 if (!bus) {
158 /* Assert that the device really is a SysBusDevice before
159 * we put it onto the sysbus. Non-sysbus devices which aren't
160 * being put onto a bus should be created with object_new(TYPE_FOO),
161 * not qdev_create(NULL, TYPE_FOO).
162 */
163 g_assert(object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE));
164 bus = sysbus_get_default();
165 }
166
167 qdev_set_parent_bus(dev, bus);
168 object_unref(OBJECT(dev));
169 return dev;
170 }
171
172 static QTAILQ_HEAD(device_listeners, DeviceListener) device_listeners
173 = QTAILQ_HEAD_INITIALIZER(device_listeners);
174
175 enum ListenerDirection { Forward, Reverse };
176
177 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
178 do { \
179 DeviceListener *_listener; \
180 \
181 switch (_direction) { \
182 case Forward: \
183 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
184 if (_listener->_callback) { \
185 _listener->_callback(_listener, ##_args); \
186 } \
187 } \
188 break; \
189 case Reverse: \
190 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
191 device_listeners, link) { \
192 if (_listener->_callback) { \
193 _listener->_callback(_listener, ##_args); \
194 } \
195 } \
196 break; \
197 default: \
198 abort(); \
199 } \
200 } while (0)
201
202 static int device_listener_add(DeviceState *dev, void *opaque)
203 {
204 DEVICE_LISTENER_CALL(realize, Forward, dev);
205
206 return 0;
207 }
208
209 void device_listener_register(DeviceListener *listener)
210 {
211 QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
212
213 qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
214 NULL, NULL);
215 }
216
217 void device_listener_unregister(DeviceListener *listener)
218 {
219 QTAILQ_REMOVE(&device_listeners, listener, link);
220 }
221
222 static void device_realize(DeviceState *dev, Error **errp)
223 {
224 DeviceClass *dc = DEVICE_GET_CLASS(dev);
225
226 if (dc->init) {
227 int rc = dc->init(dev);
228 if (rc < 0) {
229 error_setg(errp, "Device initialization failed.");
230 return;
231 }
232 }
233 }
234
235 static void device_unrealize(DeviceState *dev, Error **errp)
236 {
237 DeviceClass *dc = DEVICE_GET_CLASS(dev);
238
239 if (dc->exit) {
240 int rc = dc->exit(dev);
241 if (rc < 0) {
242 error_setg(errp, "Device exit failed.");
243 return;
244 }
245 }
246 }
247
248 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
249 int required_for_version)
250 {
251 assert(!dev->realized);
252 dev->instance_id_alias = alias_id;
253 dev->alias_required_for_version = required_for_version;
254 }
255
256 HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
257 {
258 HotplugHandler *hotplug_ctrl = NULL;
259
260 if (dev->parent_bus && dev->parent_bus->hotplug_handler) {
261 hotplug_ctrl = dev->parent_bus->hotplug_handler;
262 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE)) {
263 MachineState *machine = MACHINE(qdev_get_machine());
264 MachineClass *mc = MACHINE_GET_CLASS(machine);
265
266 if (mc->get_hotplug_handler) {
267 hotplug_ctrl = mc->get_hotplug_handler(machine, dev);
268 }
269 }
270 return hotplug_ctrl;
271 }
272
273 static int qdev_reset_one(DeviceState *dev, void *opaque)
274 {
275 device_reset(dev);
276
277 return 0;
278 }
279
280 static int qbus_reset_one(BusState *bus, void *opaque)
281 {
282 BusClass *bc = BUS_GET_CLASS(bus);
283 if (bc->reset) {
284 bc->reset(bus);
285 }
286 return 0;
287 }
288
289 void qdev_reset_all(DeviceState *dev)
290 {
291 qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
292 }
293
294 void qdev_reset_all_fn(void *opaque)
295 {
296 qdev_reset_all(DEVICE(opaque));
297 }
298
299 void qbus_reset_all(BusState *bus)
300 {
301 qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
302 }
303
304 void qbus_reset_all_fn(void *opaque)
305 {
306 BusState *bus = opaque;
307 qbus_reset_all(bus);
308 }
309
310 /* can be used as ->unplug() callback for the simple cases */
311 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
312 DeviceState *dev, Error **errp)
313 {
314 /* just zap it */
315 object_unparent(OBJECT(dev));
316 }
317
318 /*
319 * Realize @dev.
320 * Device properties should be set before calling this function. IRQs
321 * and MMIO regions should be connected/mapped after calling this
322 * function.
323 * On failure, report an error with error_report() and terminate the
324 * program. This is okay during machine creation. Don't use for
325 * hotplug, because there callers need to recover from failure.
326 * Exception: if you know the device's init() callback can't fail,
327 * then qdev_init_nofail() can't fail either, and is therefore usable
328 * even then. But relying on the device implementation that way is
329 * somewhat unclean, and best avoided.
330 */
331 void qdev_init_nofail(DeviceState *dev)
332 {
333 Error *err = NULL;
334
335 assert(!dev->realized);
336
337 object_ref(OBJECT(dev));
338 object_property_set_bool(OBJECT(dev), true, "realized", &err);
339 if (err) {
340 error_reportf_err(err, "Initialization of device %s failed: ",
341 object_get_typename(OBJECT(dev)));
342 exit(1);
343 }
344 object_unref(OBJECT(dev));
345 }
346
347 void qdev_machine_creation_done(void)
348 {
349 /*
350 * ok, initial machine setup is done, starting from now we can
351 * only create hotpluggable devices
352 */
353 qdev_hotplug = true;
354 }
355
356 bool qdev_machine_modified(void)
357 {
358 return qdev_hot_added || qdev_hot_removed;
359 }
360
361 BusState *qdev_get_parent_bus(DeviceState *dev)
362 {
363 return dev->parent_bus;
364 }
365
366 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
367 const char *name)
368 {
369 NamedGPIOList *ngl;
370
371 QLIST_FOREACH(ngl, &dev->gpios, node) {
372 /* NULL is a valid and matchable name, otherwise do a normal
373 * strcmp match.
374 */
375 if ((!ngl->name && !name) ||
376 (name && ngl->name && strcmp(name, ngl->name) == 0)) {
377 return ngl;
378 }
379 }
380
381 ngl = g_malloc0(sizeof(*ngl));
382 ngl->name = g_strdup(name);
383 QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
384 return ngl;
385 }
386
387 void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler,
388 const char *name, int n)
389 {
390 int i;
391 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
392
393 assert(gpio_list->num_out == 0 || !name);
394 gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
395 dev, n);
396
397 if (!name) {
398 name = "unnamed-gpio-in";
399 }
400 for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
401 gchar *propname = g_strdup_printf("%s[%u]", name, i);
402
403 object_property_add_child(OBJECT(dev), propname,
404 OBJECT(gpio_list->in[i]), &error_abort);
405 g_free(propname);
406 }
407
408 gpio_list->num_in += n;
409 }
410
411 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
412 {
413 qdev_init_gpio_in_named(dev, handler, NULL, n);
414 }
415
416 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
417 const char *name, int n)
418 {
419 int i;
420 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
421
422 assert(gpio_list->num_in == 0 || !name);
423
424 if (!name) {
425 name = "unnamed-gpio-out";
426 }
427 memset(pins, 0, sizeof(*pins) * n);
428 for (i = 0; i < n; ++i) {
429 gchar *propname = g_strdup_printf("%s[%u]", name,
430 gpio_list->num_out + i);
431
432 object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
433 (Object **)&pins[i],
434 object_property_allow_set_link,
435 OBJ_PROP_LINK_UNREF_ON_RELEASE,
436 &error_abort);
437 g_free(propname);
438 }
439 gpio_list->num_out += n;
440 }
441
442 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
443 {
444 qdev_init_gpio_out_named(dev, pins, NULL, n);
445 }
446
447 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
448 {
449 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
450
451 assert(n >= 0 && n < gpio_list->num_in);
452 return gpio_list->in[n];
453 }
454
455 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
456 {
457 return qdev_get_gpio_in_named(dev, NULL, n);
458 }
459
460 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
461 qemu_irq pin)
462 {
463 char *propname = g_strdup_printf("%s[%d]",
464 name ? name : "unnamed-gpio-out", n);
465 if (pin) {
466 /* We need a name for object_property_set_link to work. If the
467 * object has a parent, object_property_add_child will come back
468 * with an error without doing anything. If it has none, it will
469 * never fail. So we can just call it with a NULL Error pointer.
470 */
471 object_property_add_child(container_get(qdev_get_machine(),
472 "/unattached"),
473 "non-qdev-gpio[*]", OBJECT(pin), NULL);
474 }
475 object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort);
476 g_free(propname);
477 }
478
479 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
480 {
481 char *propname = g_strdup_printf("%s[%d]",
482 name ? name : "unnamed-gpio-out", n);
483
484 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
485 NULL);
486
487 return ret;
488 }
489
490 /* disconnect a GPIO output, returning the disconnected input (if any) */
491
492 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
493 const char *name, int n)
494 {
495 char *propname = g_strdup_printf("%s[%d]",
496 name ? name : "unnamed-gpio-out", n);
497
498 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
499 NULL);
500 if (ret) {
501 object_property_set_link(OBJECT(dev), NULL, propname, NULL);
502 }
503 g_free(propname);
504 return ret;
505 }
506
507 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
508 const char *name, int n)
509 {
510 qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
511 qdev_connect_gpio_out_named(dev, name, n, icpt);
512 return disconnected;
513 }
514
515 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
516 {
517 qdev_connect_gpio_out_named(dev, NULL, n, pin);
518 }
519
520 void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
521 const char *name)
522 {
523 int i;
524 NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
525
526 for (i = 0; i < ngl->num_in; i++) {
527 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
528 char *propname = g_strdup_printf("%s[%d]", nm, i);
529
530 object_property_add_alias(OBJECT(container), propname,
531 OBJECT(dev), propname,
532 &error_abort);
533 g_free(propname);
534 }
535 for (i = 0; i < ngl->num_out; i++) {
536 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
537 char *propname = g_strdup_printf("%s[%d]", nm, i);
538
539 object_property_add_alias(OBJECT(container), propname,
540 OBJECT(dev), propname,
541 &error_abort);
542 g_free(propname);
543 }
544 QLIST_REMOVE(ngl, node);
545 QLIST_INSERT_HEAD(&container->gpios, ngl, node);
546 }
547
548 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
549 {
550 BusState *bus;
551 Object *child = object_resolve_path_component(OBJECT(dev), name);
552
553 bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
554 if (bus) {
555 return bus;
556 }
557
558 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
559 if (strcmp(name, bus->name) == 0) {
560 return bus;
561 }
562 }
563 return NULL;
564 }
565
566 int qdev_walk_children(DeviceState *dev,
567 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
568 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
569 void *opaque)
570 {
571 BusState *bus;
572 int err;
573
574 if (pre_devfn) {
575 err = pre_devfn(dev, opaque);
576 if (err) {
577 return err;
578 }
579 }
580
581 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
582 err = qbus_walk_children(bus, pre_devfn, pre_busfn,
583 post_devfn, post_busfn, opaque);
584 if (err < 0) {
585 return err;
586 }
587 }
588
589 if (post_devfn) {
590 err = post_devfn(dev, opaque);
591 if (err) {
592 return err;
593 }
594 }
595
596 return 0;
597 }
598
599 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
600 {
601 BusChild *kid;
602 DeviceState *ret;
603 BusState *child;
604
605 QTAILQ_FOREACH(kid, &bus->children, sibling) {
606 DeviceState *dev = kid->child;
607
608 if (dev->id && strcmp(dev->id, id) == 0) {
609 return dev;
610 }
611
612 QLIST_FOREACH(child, &dev->child_bus, sibling) {
613 ret = qdev_find_recursive(child, id);
614 if (ret) {
615 return ret;
616 }
617 }
618 }
619 return NULL;
620 }
621
622 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
623 {
624 BusClass *bc = BUS_GET_CLASS(bus);
625
626 if (bc->get_fw_dev_path) {
627 return bc->get_fw_dev_path(dev);
628 }
629
630 return NULL;
631 }
632
633 static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
634 {
635 Object *obj = OBJECT(dev);
636 char *d = NULL;
637
638 while (!d && obj->parent) {
639 obj = obj->parent;
640 d = fw_path_provider_try_get_dev_path(obj, bus, dev);
641 }
642 return d;
643 }
644
645 char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
646 {
647 Object *obj = OBJECT(dev);
648
649 return fw_path_provider_try_get_dev_path(obj, bus, dev);
650 }
651
652 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
653 {
654 int l = 0;
655
656 if (dev && dev->parent_bus) {
657 char *d;
658 l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
659 d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev);
660 if (!d) {
661 d = bus_get_fw_dev_path(dev->parent_bus, dev);
662 }
663 if (d) {
664 l += snprintf(p + l, size - l, "%s", d);
665 g_free(d);
666 } else {
667 return l;
668 }
669 }
670 l += snprintf(p + l , size - l, "/");
671
672 return l;
673 }
674
675 char* qdev_get_fw_dev_path(DeviceState *dev)
676 {
677 char path[128];
678 int l;
679
680 l = qdev_get_fw_dev_path_helper(dev, path, 128);
681
682 path[l-1] = '\0';
683
684 return g_strdup(path);
685 }
686
687 char *qdev_get_dev_path(DeviceState *dev)
688 {
689 BusClass *bc;
690
691 if (!dev || !dev->parent_bus) {
692 return NULL;
693 }
694
695 bc = BUS_GET_CLASS(dev->parent_bus);
696 if (bc->get_dev_path) {
697 return bc->get_dev_path(dev);
698 }
699
700 return NULL;
701 }
702
703 /**
704 * Legacy property handling
705 */
706
707 static void qdev_get_legacy_property(Object *obj, Visitor *v,
708 const char *name, void *opaque,
709 Error **errp)
710 {
711 DeviceState *dev = DEVICE(obj);
712 Property *prop = opaque;
713
714 char buffer[1024];
715 char *ptr = buffer;
716
717 prop->info->print(dev, prop, buffer, sizeof(buffer));
718 visit_type_str(v, name, &ptr, errp);
719 }
720
721 /**
722 * qdev_property_add_legacy:
723 * @dev: Device to add the property to.
724 * @prop: The qdev property definition.
725 * @errp: location to store error information.
726 *
727 * Add a legacy QOM property to @dev for qdev property @prop.
728 * On error, store error in @errp.
729 *
730 * Legacy properties are string versions of QOM properties. The format of
731 * the string depends on the property type. Legacy properties are only
732 * needed for "info qtree".
733 *
734 * Do not use this is new code! QOM Properties added through this interface
735 * will be given names in the "legacy" namespace.
736 */
737 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
738 Error **errp)
739 {
740 gchar *name;
741
742 /* Register pointer properties as legacy properties */
743 if (!prop->info->print && prop->info->get) {
744 return;
745 }
746
747 if (prop->info->create) {
748 return;
749 }
750
751 name = g_strdup_printf("legacy-%s", prop->name);
752 object_property_add(OBJECT(dev), name, "str",
753 prop->info->print ? qdev_get_legacy_property : prop->info->get,
754 NULL,
755 NULL,
756 prop, errp);
757
758 g_free(name);
759 }
760
761 /**
762 * qdev_property_add_static:
763 * @dev: Device to add the property to.
764 * @prop: The qdev property definition.
765 * @errp: location to store error information.
766 *
767 * Add a static QOM property to @dev for qdev property @prop.
768 * On error, store error in @errp. Static properties access data in a struct.
769 * The type of the QOM property is derived from prop->info.
770 */
771 void qdev_property_add_static(DeviceState *dev, Property *prop,
772 Error **errp)
773 {
774 Error *local_err = NULL;
775 Object *obj = OBJECT(dev);
776
777 if (prop->info->create) {
778 prop->info->create(obj, prop, &local_err);
779 } else {
780 /*
781 * TODO qdev_prop_ptr does not have getters or setters. It must
782 * go now that it can be replaced with links. The test should be
783 * removed along with it: all static properties are read/write.
784 */
785 if (!prop->info->get && !prop->info->set) {
786 return;
787 }
788 object_property_add(obj, prop->name, prop->info->name,
789 prop->info->get, prop->info->set,
790 prop->info->release,
791 prop, &local_err);
792 }
793
794 if (local_err) {
795 error_propagate(errp, local_err);
796 return;
797 }
798
799 object_property_set_description(obj, prop->name,
800 prop->info->description,
801 &error_abort);
802
803 if (prop->set_default) {
804 prop->info->set_default_value(obj, prop);
805 }
806 }
807
808 /* @qdev_alias_all_properties - Add alias properties to the source object for
809 * all qdev properties on the target DeviceState.
810 */
811 void qdev_alias_all_properties(DeviceState *target, Object *source)
812 {
813 ObjectClass *class;
814 Property *prop;
815
816 class = object_get_class(OBJECT(target));
817 do {
818 DeviceClass *dc = DEVICE_CLASS(class);
819
820 for (prop = dc->props; prop && prop->name; prop++) {
821 object_property_add_alias(source, prop->name,
822 OBJECT(target), prop->name,
823 &error_abort);
824 }
825 class = object_class_get_parent(class);
826 } while (class != object_class_by_name(TYPE_DEVICE));
827 }
828
829 static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
830 {
831 GSList **list = opaque;
832 DeviceState *dev = (DeviceState *)object_dynamic_cast(OBJECT(obj),
833 TYPE_DEVICE);
834
835 if (dev == NULL) {
836 return 0;
837 }
838
839 if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
840 *list = g_slist_append(*list, dev);
841 }
842
843 return 0;
844 }
845
846 GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
847 {
848 GSList *list = NULL;
849
850 object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
851
852 return list;
853 }
854
855 static bool device_get_realized(Object *obj, Error **errp)
856 {
857 DeviceState *dev = DEVICE(obj);
858 return dev->realized;
859 }
860
861 static bool check_only_migratable(Object *obj, Error **err)
862 {
863 DeviceClass *dc = DEVICE_GET_CLASS(obj);
864
865 if (!vmstate_check_only_migratable(dc->vmsd)) {
866 error_setg(err, "Device %s is not migratable, but "
867 "--only-migratable was specified",
868 object_get_typename(obj));
869 return false;
870 }
871
872 return true;
873 }
874
875 static void device_set_realized(Object *obj, bool value, Error **errp)
876 {
877 DeviceState *dev = DEVICE(obj);
878 DeviceClass *dc = DEVICE_GET_CLASS(dev);
879 HotplugHandler *hotplug_ctrl;
880 BusState *bus;
881 Error *local_err = NULL;
882 bool unattached_parent = false;
883 static int unattached_count;
884
885 if (dev->hotplugged && !dc->hotpluggable) {
886 error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
887 return;
888 }
889
890 if (value && !dev->realized) {
891 if (!check_only_migratable(obj, &local_err)) {
892 goto fail;
893 }
894
895 if (!obj->parent) {
896 gchar *name = g_strdup_printf("device[%d]", unattached_count++);
897
898 object_property_add_child(container_get(qdev_get_machine(),
899 "/unattached"),
900 name, obj, &error_abort);
901 unattached_parent = true;
902 g_free(name);
903 }
904
905 hotplug_ctrl = qdev_get_hotplug_handler(dev);
906 if (hotplug_ctrl) {
907 hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
908 if (local_err != NULL) {
909 goto fail;
910 }
911 }
912
913 if (dc->realize) {
914 dc->realize(dev, &local_err);
915 }
916
917 if (local_err != NULL) {
918 goto fail;
919 }
920
921 DEVICE_LISTENER_CALL(realize, Forward, dev);
922
923 if (hotplug_ctrl) {
924 hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
925 }
926
927 if (local_err != NULL) {
928 goto post_realize_fail;
929 }
930
931 /*
932 * always free/re-initialize here since the value cannot be cleaned up
933 * in device_unrealize due to its usage later on in the unplug path
934 */
935 g_free(dev->canonical_path);
936 dev->canonical_path = object_get_canonical_path(OBJECT(dev));
937
938 if (qdev_get_vmsd(dev)) {
939 if (vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
940 dev->instance_id_alias,
941 dev->alias_required_for_version,
942 &local_err) < 0) {
943 goto post_realize_fail;
944 }
945 }
946
947 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
948 object_property_set_bool(OBJECT(bus), true, "realized",
949 &local_err);
950 if (local_err != NULL) {
951 goto child_realize_fail;
952 }
953 }
954 if (dev->hotplugged) {
955 device_reset(dev);
956 }
957 dev->pending_deleted_event = false;
958 } else if (!value && dev->realized) {
959 Error **local_errp = NULL;
960 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
961 local_errp = local_err ? NULL : &local_err;
962 object_property_set_bool(OBJECT(bus), false, "realized",
963 local_errp);
964 }
965 if (qdev_get_vmsd(dev)) {
966 vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
967 }
968 if (dc->unrealize) {
969 local_errp = local_err ? NULL : &local_err;
970 dc->unrealize(dev, local_errp);
971 }
972 dev->pending_deleted_event = true;
973 DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
974 }
975
976 if (local_err != NULL) {
977 goto fail;
978 }
979
980 dev->realized = value;
981 return;
982
983 child_realize_fail:
984 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
985 object_property_set_bool(OBJECT(bus), false, "realized",
986 NULL);
987 }
988
989 if (qdev_get_vmsd(dev)) {
990 vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
991 }
992
993 post_realize_fail:
994 g_free(dev->canonical_path);
995 dev->canonical_path = NULL;
996 if (dc->unrealize) {
997 dc->unrealize(dev, NULL);
998 }
999
1000 fail:
1001 error_propagate(errp, local_err);
1002 if (unattached_parent) {
1003 object_unparent(OBJECT(dev));
1004 unattached_count--;
1005 }
1006 }
1007
1008 static bool device_get_hotpluggable(Object *obj, Error **errp)
1009 {
1010 DeviceClass *dc = DEVICE_GET_CLASS(obj);
1011 DeviceState *dev = DEVICE(obj);
1012
1013 return dc->hotpluggable && (dev->parent_bus == NULL ||
1014 qbus_is_hotpluggable(dev->parent_bus));
1015 }
1016
1017 static bool device_get_hotplugged(Object *obj, Error **err)
1018 {
1019 DeviceState *dev = DEVICE(obj);
1020
1021 return dev->hotplugged;
1022 }
1023
1024 static void device_initfn(Object *obj)
1025 {
1026 DeviceState *dev = DEVICE(obj);
1027 ObjectClass *class;
1028 Property *prop;
1029
1030 if (qdev_hotplug) {
1031 dev->hotplugged = 1;
1032 qdev_hot_added = true;
1033 }
1034
1035 dev->instance_id_alias = -1;
1036 dev->realized = false;
1037
1038 object_property_add_bool(obj, "realized",
1039 device_get_realized, device_set_realized, NULL);
1040 object_property_add_bool(obj, "hotpluggable",
1041 device_get_hotpluggable, NULL, NULL);
1042 object_property_add_bool(obj, "hotplugged",
1043 device_get_hotplugged, NULL,
1044 &error_abort);
1045
1046 class = object_get_class(OBJECT(dev));
1047 do {
1048 for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
1049 qdev_property_add_legacy(dev, prop, &error_abort);
1050 qdev_property_add_static(dev, prop, &error_abort);
1051 }
1052 class = object_class_get_parent(class);
1053 } while (class != object_class_by_name(TYPE_DEVICE));
1054
1055 object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
1056 (Object **)&dev->parent_bus, NULL, 0,
1057 &error_abort);
1058 QLIST_INIT(&dev->gpios);
1059 }
1060
1061 static void device_post_init(Object *obj)
1062 {
1063 qdev_prop_set_globals(DEVICE(obj));
1064 }
1065
1066 /* Unlink device from bus and free the structure. */
1067 static void device_finalize(Object *obj)
1068 {
1069 NamedGPIOList *ngl, *next;
1070
1071 DeviceState *dev = DEVICE(obj);
1072
1073 QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1074 QLIST_REMOVE(ngl, node);
1075 qemu_free_irqs(ngl->in, ngl->num_in);
1076 g_free(ngl->name);
1077 g_free(ngl);
1078 /* ngl->out irqs are owned by the other end and should not be freed
1079 * here
1080 */
1081 }
1082
1083 /* Only send event if the device had been completely realized */
1084 if (dev->pending_deleted_event) {
1085 g_assert(dev->canonical_path);
1086
1087 qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path,
1088 &error_abort);
1089 g_free(dev->canonical_path);
1090 dev->canonical_path = NULL;
1091 }
1092
1093 qemu_opts_del(dev->opts);
1094 }
1095
1096 static void device_class_base_init(ObjectClass *class, void *data)
1097 {
1098 DeviceClass *klass = DEVICE_CLASS(class);
1099
1100 /* We explicitly look up properties in the superclasses,
1101 * so do not propagate them to the subclasses.
1102 */
1103 klass->props = NULL;
1104 }
1105
1106 static void device_unparent(Object *obj)
1107 {
1108 DeviceState *dev = DEVICE(obj);
1109 BusState *bus;
1110
1111 if (dev->realized) {
1112 object_property_set_bool(obj, false, "realized", NULL);
1113 }
1114 while (dev->num_child_bus) {
1115 bus = QLIST_FIRST(&dev->child_bus);
1116 object_unparent(OBJECT(bus));
1117 }
1118 if (dev->parent_bus) {
1119 bus_remove_child(dev->parent_bus, dev);
1120 object_unref(OBJECT(dev->parent_bus));
1121 dev->parent_bus = NULL;
1122 }
1123 }
1124
1125 static void device_class_init(ObjectClass *class, void *data)
1126 {
1127 DeviceClass *dc = DEVICE_CLASS(class);
1128
1129 class->unparent = device_unparent;
1130 dc->realize = device_realize;
1131 dc->unrealize = device_unrealize;
1132
1133 /* by default all devices were considered as hotpluggable,
1134 * so with intent to check it in generic qdev_unplug() /
1135 * device_set_realized() functions make every device
1136 * hotpluggable. Devices that shouldn't be hotpluggable,
1137 * should override it in their class_init()
1138 */
1139 dc->hotpluggable = true;
1140 dc->user_creatable = true;
1141 }
1142
1143 void device_reset(DeviceState *dev)
1144 {
1145 DeviceClass *klass = DEVICE_GET_CLASS(dev);
1146
1147 if (klass->reset) {
1148 klass->reset(dev);
1149 }
1150 }
1151
1152 Object *qdev_get_machine(void)
1153 {
1154 static Object *dev;
1155
1156 if (dev == NULL) {
1157 dev = container_get(object_get_root(), "/machine");
1158 }
1159
1160 return dev;
1161 }
1162
1163 static const TypeInfo device_type_info = {
1164 .name = TYPE_DEVICE,
1165 .parent = TYPE_OBJECT,
1166 .instance_size = sizeof(DeviceState),
1167 .instance_init = device_initfn,
1168 .instance_post_init = device_post_init,
1169 .instance_finalize = device_finalize,
1170 .class_base_init = device_class_base_init,
1171 .class_init = device_class_init,
1172 .abstract = true,
1173 .class_size = sizeof(DeviceClass),
1174 };
1175
1176 static void qdev_register_types(void)
1177 {
1178 type_register_static(&device_type_info);
1179 }
1180
1181 type_init(qdev_register_types)