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