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