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