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