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