device-core: use RCU for list of children of a bus
[qemu.git] / hw / core / qdev.c
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 "hw/qdev-clock.h"
41 #include "migration/vmstate.h"
42 #include "trace.h"
43
44 bool qdev_hotplug = false;
45 static bool qdev_hot_added = false;
46 bool qdev_hot_removed = false;
47
48 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
49 {
50 DeviceClass *dc = DEVICE_GET_CLASS(dev);
51 return dc->vmsd;
52 }
53
54 static void bus_free_bus_child(BusChild *kid)
55 {
56 object_unref(OBJECT(kid->child));
57 g_free(kid);
58 }
59
60 static void bus_remove_child(BusState *bus, DeviceState *child)
61 {
62 BusChild *kid;
63
64 QTAILQ_FOREACH(kid, &bus->children, sibling) {
65 if (kid->child == child) {
66 char name[32];
67
68 snprintf(name, sizeof(name), "child[%d]", kid->index);
69 QTAILQ_REMOVE_RCU(&bus->children, kid, sibling);
70
71 bus->num_children--;
72
73 /* This gives back ownership of kid->child back to us. */
74 object_property_del(OBJECT(bus), name);
75
76 /* free the bus kid, when it is safe to do so*/
77 call_rcu(kid, bus_free_bus_child, rcu);
78 break;
79 }
80 }
81 }
82
83 static void bus_add_child(BusState *bus, DeviceState *child)
84 {
85 char name[32];
86 BusChild *kid = g_malloc0(sizeof(*kid));
87
88 bus->num_children++;
89 kid->index = bus->max_index++;
90 kid->child = child;
91 object_ref(OBJECT(kid->child));
92
93 QTAILQ_INSERT_HEAD_RCU(&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);
102 }
103
104 static bool bus_check_address(BusState *bus, DeviceState *child, Error **errp)
105 {
106 BusClass *bc = BUS_GET_CLASS(bus);
107 return !bc->check_address || bc->check_address(bus, child, errp);
108 }
109
110 bool qdev_set_parent_bus(DeviceState *dev, BusState *bus, Error **errp)
111 {
112 BusState *old_parent_bus = dev->parent_bus;
113 DeviceClass *dc = DEVICE_GET_CLASS(dev);
114
115 assert(dc->bus_type && object_dynamic_cast(OBJECT(bus), dc->bus_type));
116
117 if (!bus_check_address(bus, dev, errp)) {
118 return false;
119 }
120
121 if (old_parent_bus) {
122 trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)),
123 old_parent_bus, object_get_typename(OBJECT(old_parent_bus)),
124 OBJECT(bus), object_get_typename(OBJECT(bus)));
125 /*
126 * Keep a reference to the device while it's not plugged into
127 * any bus, to avoid it potentially evaporating when it is
128 * dereffed in bus_remove_child().
129 * Also keep the ref of the parent bus until the end, so that
130 * we can safely call resettable_change_parent() below.
131 */
132 object_ref(OBJECT(dev));
133 bus_remove_child(dev->parent_bus, dev);
134 }
135 dev->parent_bus = bus;
136 object_ref(OBJECT(bus));
137 bus_add_child(bus, dev);
138 if (dev->realized) {
139 resettable_change_parent(OBJECT(dev), OBJECT(bus),
140 OBJECT(old_parent_bus));
141 }
142 if (old_parent_bus) {
143 object_unref(OBJECT(old_parent_bus));
144 object_unref(OBJECT(dev));
145 }
146 return true;
147 }
148
149 DeviceState *qdev_new(const char *name)
150 {
151 if (!object_class_by_name(name)) {
152 module_load_qom_one(name);
153 }
154 return DEVICE(object_new(name));
155 }
156
157 DeviceState *qdev_try_new(const char *name)
158 {
159 if (!module_object_class_by_name(name)) {
160 return NULL;
161 }
162 return DEVICE(object_new(name));
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_prereset(DeviceState *dev, void *opaque)
300 {
301 trace_qdev_reset_tree(dev, object_get_typename(OBJECT(dev)));
302 return 0;
303 }
304
305 static int qbus_prereset(BusState *bus, void *opaque)
306 {
307 trace_qbus_reset_tree(bus, object_get_typename(OBJECT(bus)));
308 return 0;
309 }
310
311 static int qdev_reset_one(DeviceState *dev, void *opaque)
312 {
313 device_legacy_reset(dev);
314
315 return 0;
316 }
317
318 static int qbus_reset_one(BusState *bus, void *opaque)
319 {
320 BusClass *bc = BUS_GET_CLASS(bus);
321 trace_qbus_reset(bus, object_get_typename(OBJECT(bus)));
322 if (bc->reset) {
323 bc->reset(bus);
324 }
325 return 0;
326 }
327
328 void qdev_reset_all(DeviceState *dev)
329 {
330 trace_qdev_reset_all(dev, object_get_typename(OBJECT(dev)));
331 qdev_walk_children(dev, qdev_prereset, qbus_prereset,
332 qdev_reset_one, qbus_reset_one, NULL);
333 }
334
335 void qdev_reset_all_fn(void *opaque)
336 {
337 qdev_reset_all(DEVICE(opaque));
338 }
339
340 void qbus_reset_all(BusState *bus)
341 {
342 trace_qbus_reset_all(bus, object_get_typename(OBJECT(bus)));
343 qbus_walk_children(bus, qdev_prereset, qbus_prereset,
344 qdev_reset_one, qbus_reset_one, NULL);
345 }
346
347 void qbus_reset_all_fn(void *opaque)
348 {
349 BusState *bus = opaque;
350 qbus_reset_all(bus);
351 }
352
353 void device_cold_reset(DeviceState *dev)
354 {
355 resettable_reset(OBJECT(dev), RESET_TYPE_COLD);
356 }
357
358 bool device_is_in_reset(DeviceState *dev)
359 {
360 return resettable_is_in_reset(OBJECT(dev));
361 }
362
363 static ResettableState *device_get_reset_state(Object *obj)
364 {
365 DeviceState *dev = DEVICE(obj);
366 return &dev->reset;
367 }
368
369 static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb,
370 void *opaque, ResetType type)
371 {
372 DeviceState *dev = DEVICE(obj);
373 BusState *bus;
374
375 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
376 cb(OBJECT(bus), opaque, type);
377 }
378 }
379
380 /* can be used as ->unplug() callback for the simple cases */
381 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
382 DeviceState *dev, Error **errp)
383 {
384 qdev_unrealize(dev);
385 }
386
387 bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp)
388 {
389 assert(!dev->realized && !dev->parent_bus);
390
391 if (bus) {
392 if (!qdev_set_parent_bus(dev, bus, errp)) {
393 return false;
394 }
395 } else {
396 assert(!DEVICE_GET_CLASS(dev)->bus_type);
397 }
398
399 return object_property_set_bool(OBJECT(dev), "realized", true, errp);
400 }
401
402 bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp)
403 {
404 bool ret;
405
406 ret = qdev_realize(dev, bus, errp);
407 object_unref(OBJECT(dev));
408 return ret;
409 }
410
411 void qdev_unrealize(DeviceState *dev)
412 {
413 object_property_set_bool(OBJECT(dev), "realized", false, &error_abort);
414 }
415
416 static int qdev_assert_realized_properly(Object *obj, void *opaque)
417 {
418 DeviceState *dev = DEVICE(object_dynamic_cast(obj, TYPE_DEVICE));
419 DeviceClass *dc;
420
421 if (dev) {
422 dc = DEVICE_GET_CLASS(dev);
423 assert(dev->realized);
424 assert(dev->parent_bus || !dc->bus_type);
425 }
426 return 0;
427 }
428
429 void qdev_machine_creation_done(void)
430 {
431 /*
432 * ok, initial machine setup is done, starting from now we can
433 * only create hotpluggable devices
434 */
435 qdev_hotplug = true;
436
437 object_child_foreach_recursive(object_get_root(),
438 qdev_assert_realized_properly, NULL);
439 }
440
441 bool qdev_machine_modified(void)
442 {
443 return qdev_hot_added || qdev_hot_removed;
444 }
445
446 BusState *qdev_get_parent_bus(DeviceState *dev)
447 {
448 return dev->parent_bus;
449 }
450
451 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
452 const char *name)
453 {
454 NamedGPIOList *ngl;
455
456 QLIST_FOREACH(ngl, &dev->gpios, node) {
457 /* NULL is a valid and matchable name. */
458 if (g_strcmp0(name, ngl->name) == 0) {
459 return ngl;
460 }
461 }
462
463 ngl = g_malloc0(sizeof(*ngl));
464 ngl->name = g_strdup(name);
465 QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
466 return ngl;
467 }
468
469 void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
470 qemu_irq_handler handler,
471 void *opaque,
472 const char *name, int n)
473 {
474 int i;
475 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
476
477 assert(gpio_list->num_out == 0 || !name);
478 gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
479 opaque, n);
480
481 if (!name) {
482 name = "unnamed-gpio-in";
483 }
484 for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
485 gchar *propname = g_strdup_printf("%s[%u]", name, i);
486
487 object_property_add_child(OBJECT(dev), propname,
488 OBJECT(gpio_list->in[i]));
489 g_free(propname);
490 }
491
492 gpio_list->num_in += n;
493 }
494
495 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
496 {
497 qdev_init_gpio_in_named(dev, handler, NULL, n);
498 }
499
500 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
501 const char *name, int n)
502 {
503 int i;
504 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
505
506 assert(gpio_list->num_in == 0 || !name);
507
508 if (!name) {
509 name = "unnamed-gpio-out";
510 }
511 memset(pins, 0, sizeof(*pins) * n);
512 for (i = 0; i < n; ++i) {
513 gchar *propname = g_strdup_printf("%s[%u]", name,
514 gpio_list->num_out + i);
515
516 object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
517 (Object **)&pins[i],
518 object_property_allow_set_link,
519 OBJ_PROP_LINK_STRONG);
520 g_free(propname);
521 }
522 gpio_list->num_out += n;
523 }
524
525 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
526 {
527 qdev_init_gpio_out_named(dev, pins, NULL, n);
528 }
529
530 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
531 {
532 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
533
534 assert(n >= 0 && n < gpio_list->num_in);
535 return gpio_list->in[n];
536 }
537
538 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
539 {
540 return qdev_get_gpio_in_named(dev, NULL, n);
541 }
542
543 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
544 qemu_irq pin)
545 {
546 char *propname = g_strdup_printf("%s[%d]",
547 name ? name : "unnamed-gpio-out", n);
548 if (pin && !OBJECT(pin)->parent) {
549 /* We need a name for object_property_set_link to work */
550 object_property_add_child(container_get(qdev_get_machine(),
551 "/unattached"),
552 "non-qdev-gpio[*]", OBJECT(pin));
553 }
554 object_property_set_link(OBJECT(dev), propname, OBJECT(pin), &error_abort);
555 g_free(propname);
556 }
557
558 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
559 {
560 g_autofree char *propname = g_strdup_printf("%s[%d]",
561 name ? name : "unnamed-gpio-out", n);
562
563 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
564 NULL);
565
566 return ret;
567 }
568
569 /* disconnect a GPIO output, returning the disconnected input (if any) */
570
571 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
572 const char *name, int n)
573 {
574 char *propname = g_strdup_printf("%s[%d]",
575 name ? name : "unnamed-gpio-out", n);
576
577 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
578 NULL);
579 if (ret) {
580 object_property_set_link(OBJECT(dev), propname, NULL, NULL);
581 }
582 g_free(propname);
583 return ret;
584 }
585
586 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
587 const char *name, int n)
588 {
589 qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
590 qdev_connect_gpio_out_named(dev, name, n, icpt);
591 return disconnected;
592 }
593
594 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
595 {
596 qdev_connect_gpio_out_named(dev, NULL, n, pin);
597 }
598
599 void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
600 const char *name)
601 {
602 int i;
603 NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
604
605 for (i = 0; i < ngl->num_in; i++) {
606 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
607 char *propname = g_strdup_printf("%s[%d]", nm, i);
608
609 object_property_add_alias(OBJECT(container), propname,
610 OBJECT(dev), propname);
611 g_free(propname);
612 }
613 for (i = 0; i < ngl->num_out; i++) {
614 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
615 char *propname = g_strdup_printf("%s[%d]", nm, i);
616
617 object_property_add_alias(OBJECT(container), propname,
618 OBJECT(dev), propname);
619 g_free(propname);
620 }
621 QLIST_REMOVE(ngl, node);
622 QLIST_INSERT_HEAD(&container->gpios, ngl, node);
623 }
624
625 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
626 {
627 BusState *bus;
628 Object *child = object_resolve_path_component(OBJECT(dev), name);
629
630 bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
631 if (bus) {
632 return bus;
633 }
634
635 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
636 if (strcmp(name, bus->name) == 0) {
637 return bus;
638 }
639 }
640 return NULL;
641 }
642
643 int qdev_walk_children(DeviceState *dev,
644 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
645 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
646 void *opaque)
647 {
648 BusState *bus;
649 int err;
650
651 if (pre_devfn) {
652 err = pre_devfn(dev, opaque);
653 if (err) {
654 return err;
655 }
656 }
657
658 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
659 err = qbus_walk_children(bus, pre_devfn, pre_busfn,
660 post_devfn, post_busfn, opaque);
661 if (err < 0) {
662 return err;
663 }
664 }
665
666 if (post_devfn) {
667 err = post_devfn(dev, opaque);
668 if (err) {
669 return err;
670 }
671 }
672
673 return 0;
674 }
675
676 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
677 {
678 BusChild *kid;
679 DeviceState *ret;
680 BusState *child;
681
682 WITH_RCU_READ_LOCK_GUARD() {
683 QTAILQ_FOREACH_RCU(kid, &bus->children, sibling) {
684 DeviceState *dev = kid->child;
685
686 if (dev->id && strcmp(dev->id, id) == 0) {
687 return dev;
688 }
689
690 QLIST_FOREACH(child, &dev->child_bus, sibling) {
691 ret = qdev_find_recursive(child, id);
692 if (ret) {
693 return ret;
694 }
695 }
696 }
697 }
698 return NULL;
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_class_add_legacy_property:
737 * @dev: Device to add the property to.
738 * @prop: The qdev property definition.
739 *
740 * Add a legacy QOM property to @dev for qdev property @prop.
741 *
742 * Legacy properties are string versions of QOM properties. The format of
743 * the string depends on the property type. Legacy properties are only
744 * needed for "info qtree".
745 *
746 * Do not use this in new code! QOM Properties added through this interface
747 * will be given names in the "legacy" namespace.
748 */
749 static void qdev_class_add_legacy_property(DeviceClass *dc, Property *prop)
750 {
751 g_autofree char *name = NULL;
752
753 /* Register pointer properties as legacy properties */
754 if (!prop->info->print && prop->info->get) {
755 return;
756 }
757
758 name = g_strdup_printf("legacy-%s", prop->name);
759 object_class_property_add(OBJECT_CLASS(dc), name, "str",
760 prop->info->print ? qdev_get_legacy_property : prop->info->get,
761 NULL, NULL, prop);
762 }
763
764 void qdev_property_add_static(DeviceState *dev, Property *prop)
765 {
766 Object *obj = OBJECT(dev);
767 ObjectProperty *op;
768
769 assert(!prop->info->create);
770
771 op = object_property_add(obj, prop->name, prop->info->name,
772 prop->info->get, prop->info->set,
773 prop->info->release,
774 prop);
775
776 object_property_set_description(obj, prop->name,
777 prop->info->description);
778
779 if (prop->set_default) {
780 prop->info->set_default_value(op, prop);
781 if (op->init) {
782 op->init(obj, op);
783 }
784 }
785 }
786
787 static void qdev_class_add_property(DeviceClass *klass, Property *prop)
788 {
789 ObjectClass *oc = OBJECT_CLASS(klass);
790
791 if (prop->info->create) {
792 prop->info->create(oc, prop);
793 } else {
794 ObjectProperty *op;
795
796 op = object_class_property_add(oc,
797 prop->name, prop->info->name,
798 prop->info->get, prop->info->set,
799 prop->info->release,
800 prop);
801 if (prop->set_default) {
802 prop->info->set_default_value(op, prop);
803 }
804 }
805 object_class_property_set_description(oc, prop->name,
806 prop->info->description);
807 }
808
809 void qdev_alias_all_properties(DeviceState *target, Object *source)
810 {
811 ObjectClass *class;
812 Property *prop;
813
814 class = object_get_class(OBJECT(target));
815 do {
816 DeviceClass *dc = DEVICE_CLASS(class);
817
818 for (prop = dc->props_; prop && prop->name; prop++) {
819 object_property_add_alias(source, prop->name,
820 OBJECT(target), prop->name);
821 }
822 class = object_class_get_parent(class);
823 } while (class != object_class_by_name(TYPE_DEVICE));
824 }
825
826 static bool device_get_realized(Object *obj, Error **errp)
827 {
828 DeviceState *dev = DEVICE(obj);
829 return dev->realized;
830 }
831
832 static bool check_only_migratable(Object *obj, Error **errp)
833 {
834 DeviceClass *dc = DEVICE_GET_CLASS(obj);
835
836 if (!vmstate_check_only_migratable(dc->vmsd)) {
837 error_setg(errp, "Device %s is not migratable, but "
838 "--only-migratable was specified",
839 object_get_typename(obj));
840 return false;
841 }
842
843 return true;
844 }
845
846 static void device_set_realized(Object *obj, bool value, Error **errp)
847 {
848 DeviceState *dev = DEVICE(obj);
849 DeviceClass *dc = DEVICE_GET_CLASS(dev);
850 HotplugHandler *hotplug_ctrl;
851 BusState *bus;
852 NamedClockList *ncl;
853 Error *local_err = NULL;
854 bool unattached_parent = false;
855 static int unattached_count;
856
857 if (dev->hotplugged && !dc->hotpluggable) {
858 error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
859 return;
860 }
861
862 if (value && !dev->realized) {
863 if (!check_only_migratable(obj, errp)) {
864 goto fail;
865 }
866
867 if (!obj->parent) {
868 gchar *name = g_strdup_printf("device[%d]", unattached_count++);
869
870 object_property_add_child(container_get(qdev_get_machine(),
871 "/unattached"),
872 name, obj);
873 unattached_parent = true;
874 g_free(name);
875 }
876
877 hotplug_ctrl = qdev_get_hotplug_handler(dev);
878 if (hotplug_ctrl) {
879 hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
880 if (local_err != NULL) {
881 goto fail;
882 }
883 }
884
885 if (dc->realize) {
886 dc->realize(dev, &local_err);
887 if (local_err != NULL) {
888 goto fail;
889 }
890 }
891
892 DEVICE_LISTENER_CALL(realize, Forward, dev);
893
894 /*
895 * always free/re-initialize here since the value cannot be cleaned up
896 * in device_unrealize due to its usage later on in the unplug path
897 */
898 g_free(dev->canonical_path);
899 dev->canonical_path = object_get_canonical_path(OBJECT(dev));
900 QLIST_FOREACH(ncl, &dev->clocks, node) {
901 if (ncl->alias) {
902 continue;
903 } else {
904 clock_setup_canonical_path(ncl->clock);
905 }
906 }
907
908 if (qdev_get_vmsd(dev)) {
909 if (vmstate_register_with_alias_id(VMSTATE_IF(dev),
910 VMSTATE_INSTANCE_ID_ANY,
911 qdev_get_vmsd(dev), dev,
912 dev->instance_id_alias,
913 dev->alias_required_for_version,
914 &local_err) < 0) {
915 goto post_realize_fail;
916 }
917 }
918
919 /*
920 * Clear the reset state, in case the object was previously unrealized
921 * with a dirty state.
922 */
923 resettable_state_clear(&dev->reset);
924
925 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
926 if (!qbus_realize(bus, errp)) {
927 goto child_realize_fail;
928 }
929 }
930 if (dev->hotplugged) {
931 /*
932 * Reset the device, as well as its subtree which, at this point,
933 * should be realized too.
934 */
935 resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD);
936 resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus),
937 NULL);
938 resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD);
939 }
940 dev->pending_deleted_event = false;
941
942 if (hotplug_ctrl) {
943 hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
944 if (local_err != NULL) {
945 goto child_realize_fail;
946 }
947 }
948
949 } else if (!value && dev->realized) {
950 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
951 qbus_unrealize(bus);
952 }
953 if (qdev_get_vmsd(dev)) {
954 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
955 }
956 if (dc->unrealize) {
957 dc->unrealize(dev);
958 }
959 dev->pending_deleted_event = true;
960 DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
961 }
962
963 assert(local_err == NULL);
964 dev->realized = value;
965 return;
966
967 child_realize_fail:
968 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
969 qbus_unrealize(bus);
970 }
971
972 if (qdev_get_vmsd(dev)) {
973 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
974 }
975
976 post_realize_fail:
977 g_free(dev->canonical_path);
978 dev->canonical_path = NULL;
979 if (dc->unrealize) {
980 dc->unrealize(dev);
981 }
982
983 fail:
984 error_propagate(errp, local_err);
985 if (unattached_parent) {
986 /*
987 * Beware, this doesn't just revert
988 * object_property_add_child(), it also runs bus_remove()!
989 */
990 object_unparent(OBJECT(dev));
991 unattached_count--;
992 }
993 }
994
995 static bool device_get_hotpluggable(Object *obj, Error **errp)
996 {
997 DeviceClass *dc = DEVICE_GET_CLASS(obj);
998 DeviceState *dev = DEVICE(obj);
999
1000 return dc->hotpluggable && (dev->parent_bus == NULL ||
1001 qbus_is_hotpluggable(dev->parent_bus));
1002 }
1003
1004 static bool device_get_hotplugged(Object *obj, Error **errp)
1005 {
1006 DeviceState *dev = DEVICE(obj);
1007
1008 return dev->hotplugged;
1009 }
1010
1011 static void device_initfn(Object *obj)
1012 {
1013 DeviceState *dev = DEVICE(obj);
1014
1015 if (qdev_hotplug) {
1016 dev->hotplugged = 1;
1017 qdev_hot_added = true;
1018 }
1019
1020 dev->instance_id_alias = -1;
1021 dev->realized = false;
1022 dev->allow_unplug_during_migration = false;
1023
1024 QLIST_INIT(&dev->gpios);
1025 QLIST_INIT(&dev->clocks);
1026 }
1027
1028 static void device_post_init(Object *obj)
1029 {
1030 /*
1031 * Note: ordered so that the user's global properties take
1032 * precedence.
1033 */
1034 object_apply_compat_props(obj);
1035 qdev_prop_set_globals(DEVICE(obj));
1036 }
1037
1038 /* Unlink device from bus and free the structure. */
1039 static void device_finalize(Object *obj)
1040 {
1041 NamedGPIOList *ngl, *next;
1042
1043 DeviceState *dev = DEVICE(obj);
1044
1045 QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1046 QLIST_REMOVE(ngl, node);
1047 qemu_free_irqs(ngl->in, ngl->num_in);
1048 g_free(ngl->name);
1049 g_free(ngl);
1050 /* ngl->out irqs are owned by the other end and should not be freed
1051 * here
1052 */
1053 }
1054
1055 qdev_finalize_clocklist(dev);
1056
1057 /* Only send event if the device had been completely realized */
1058 if (dev->pending_deleted_event) {
1059 g_assert(dev->canonical_path);
1060
1061 qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path);
1062 g_free(dev->canonical_path);
1063 dev->canonical_path = NULL;
1064 }
1065
1066 qemu_opts_del(dev->opts);
1067 }
1068
1069 static void device_class_base_init(ObjectClass *class, void *data)
1070 {
1071 DeviceClass *klass = DEVICE_CLASS(class);
1072
1073 /* We explicitly look up properties in the superclasses,
1074 * so do not propagate them to the subclasses.
1075 */
1076 klass->props_ = NULL;
1077 }
1078
1079 static void device_unparent(Object *obj)
1080 {
1081 DeviceState *dev = DEVICE(obj);
1082 BusState *bus;
1083
1084 if (dev->realized) {
1085 qdev_unrealize(dev);
1086 }
1087 while (dev->num_child_bus) {
1088 bus = QLIST_FIRST(&dev->child_bus);
1089 object_unparent(OBJECT(bus));
1090 }
1091 if (dev->parent_bus) {
1092 bus_remove_child(dev->parent_bus, dev);
1093 object_unref(OBJECT(dev->parent_bus));
1094 dev->parent_bus = NULL;
1095 }
1096 }
1097
1098 static char *
1099 device_vmstate_if_get_id(VMStateIf *obj)
1100 {
1101 DeviceState *dev = DEVICE(obj);
1102
1103 return qdev_get_dev_path(dev);
1104 }
1105
1106 /**
1107 * device_phases_reset:
1108 * Transition reset method for devices to allow moving
1109 * smoothly from legacy reset method to multi-phases
1110 */
1111 static void device_phases_reset(DeviceState *dev)
1112 {
1113 ResettableClass *rc = RESETTABLE_GET_CLASS(dev);
1114
1115 if (rc->phases.enter) {
1116 rc->phases.enter(OBJECT(dev), RESET_TYPE_COLD);
1117 }
1118 if (rc->phases.hold) {
1119 rc->phases.hold(OBJECT(dev));
1120 }
1121 if (rc->phases.exit) {
1122 rc->phases.exit(OBJECT(dev));
1123 }
1124 }
1125
1126 static void device_transitional_reset(Object *obj)
1127 {
1128 DeviceClass *dc = DEVICE_GET_CLASS(obj);
1129
1130 /*
1131 * This will call either @device_phases_reset (for multi-phases transitioned
1132 * devices) or a device's specific method for not-yet transitioned devices.
1133 * In both case, it does not reset children.
1134 */
1135 if (dc->reset) {
1136 dc->reset(DEVICE(obj));
1137 }
1138 }
1139
1140 /**
1141 * device_get_transitional_reset:
1142 * check if the device's class is ready for multi-phase
1143 */
1144 static ResettableTrFunction device_get_transitional_reset(Object *obj)
1145 {
1146 DeviceClass *dc = DEVICE_GET_CLASS(obj);
1147 if (dc->reset != device_phases_reset) {
1148 /*
1149 * dc->reset has been overridden by a subclass,
1150 * the device is not ready for multi phase yet.
1151 */
1152 return device_transitional_reset;
1153 }
1154 return NULL;
1155 }
1156
1157 static void device_class_init(ObjectClass *class, void *data)
1158 {
1159 DeviceClass *dc = DEVICE_CLASS(class);
1160 VMStateIfClass *vc = VMSTATE_IF_CLASS(class);
1161 ResettableClass *rc = RESETTABLE_CLASS(class);
1162
1163 class->unparent = device_unparent;
1164
1165 /* by default all devices were considered as hotpluggable,
1166 * so with intent to check it in generic qdev_unplug() /
1167 * device_set_realized() functions make every device
1168 * hotpluggable. Devices that shouldn't be hotpluggable,
1169 * should override it in their class_init()
1170 */
1171 dc->hotpluggable = true;
1172 dc->user_creatable = true;
1173 vc->get_id = device_vmstate_if_get_id;
1174 rc->get_state = device_get_reset_state;
1175 rc->child_foreach = device_reset_child_foreach;
1176
1177 /*
1178 * @device_phases_reset is put as the default reset method below, allowing
1179 * to do the multi-phase transition from base classes to leaf classes. It
1180 * allows a legacy-reset Device class to extend a multi-phases-reset
1181 * Device class for the following reason:
1182 * + If a base class B has been moved to multi-phase, then it does not
1183 * override this default reset method and may have defined phase methods.
1184 * + A child class C (extending class B) which uses
1185 * device_class_set_parent_reset() (or similar means) to override the
1186 * reset method will still work as expected. @device_phases_reset function
1187 * will be registered as the parent reset method and effectively call
1188 * parent reset phases.
1189 */
1190 dc->reset = device_phases_reset;
1191 rc->get_transitional_function = device_get_transitional_reset;
1192
1193 object_class_property_add_bool(class, "realized",
1194 device_get_realized, device_set_realized);
1195 object_class_property_add_bool(class, "hotpluggable",
1196 device_get_hotpluggable, NULL);
1197 object_class_property_add_bool(class, "hotplugged",
1198 device_get_hotplugged, NULL);
1199 object_class_property_add_link(class, "parent_bus", TYPE_BUS,
1200 offsetof(DeviceState, parent_bus), NULL, 0);
1201 }
1202
1203 void device_class_set_props(DeviceClass *dc, Property *props)
1204 {
1205 Property *prop;
1206
1207 dc->props_ = props;
1208 for (prop = props; prop && prop->name; prop++) {
1209 qdev_class_add_legacy_property(dc, prop);
1210 qdev_class_add_property(dc, prop);
1211 }
1212 }
1213
1214 void device_class_set_parent_reset(DeviceClass *dc,
1215 DeviceReset dev_reset,
1216 DeviceReset *parent_reset)
1217 {
1218 *parent_reset = dc->reset;
1219 dc->reset = dev_reset;
1220 }
1221
1222 void device_class_set_parent_realize(DeviceClass *dc,
1223 DeviceRealize dev_realize,
1224 DeviceRealize *parent_realize)
1225 {
1226 *parent_realize = dc->realize;
1227 dc->realize = dev_realize;
1228 }
1229
1230 void device_class_set_parent_unrealize(DeviceClass *dc,
1231 DeviceUnrealize dev_unrealize,
1232 DeviceUnrealize *parent_unrealize)
1233 {
1234 *parent_unrealize = dc->unrealize;
1235 dc->unrealize = dev_unrealize;
1236 }
1237
1238 void device_legacy_reset(DeviceState *dev)
1239 {
1240 DeviceClass *klass = DEVICE_GET_CLASS(dev);
1241
1242 trace_qdev_reset(dev, object_get_typename(OBJECT(dev)));
1243 if (klass->reset) {
1244 klass->reset(dev);
1245 }
1246 }
1247
1248 Object *qdev_get_machine(void)
1249 {
1250 static Object *dev;
1251
1252 if (dev == NULL) {
1253 dev = container_get(object_get_root(), "/machine");
1254 }
1255
1256 return dev;
1257 }
1258
1259 static const TypeInfo device_type_info = {
1260 .name = TYPE_DEVICE,
1261 .parent = TYPE_OBJECT,
1262 .instance_size = sizeof(DeviceState),
1263 .instance_init = device_initfn,
1264 .instance_post_init = device_post_init,
1265 .instance_finalize = device_finalize,
1266 .class_base_init = device_class_base_init,
1267 .class_init = device_class_init,
1268 .abstract = true,
1269 .class_size = sizeof(DeviceClass),
1270 .interfaces = (InterfaceInfo[]) {
1271 { TYPE_VMSTATE_IF },
1272 { TYPE_RESETTABLE_INTERFACE },
1273 { }
1274 }
1275 };
1276
1277 static void qdev_register_types(void)
1278 {
1279 type_register_static(&device_type_info);
1280 }
1281
1282 type_init(qdev_register_types)