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