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