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