Merge remote-tracking branch 'remotes/elmarco/tags/slirp-pull-request' into staging
[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 "migration/vmstate.h"
41 #include "trace.h"
42
43 bool qdev_hotplug = false;
44 static bool qdev_hot_added = false;
45 bool qdev_hot_removed = false;
46
47 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
48 {
49 DeviceClass *dc = DEVICE_GET_CLASS(dev);
50 return dc->vmsd;
51 }
52
53 static void bus_remove_child(BusState *bus, DeviceState *child)
54 {
55 BusChild *kid;
56
57 QTAILQ_FOREACH(kid, &bus->children, sibling) {
58 if (kid->child == child) {
59 char name[32];
60
61 snprintf(name, sizeof(name), "child[%d]", kid->index);
62 QTAILQ_REMOVE(&bus->children, kid, sibling);
63
64 bus->num_children--;
65
66 /* This gives back ownership of kid->child back to us. */
67 object_property_del(OBJECT(bus), name, NULL);
68 object_unref(OBJECT(kid->child));
69 g_free(kid);
70 return;
71 }
72 }
73 }
74
75 static void bus_add_child(BusState *bus, DeviceState *child)
76 {
77 char name[32];
78 BusChild *kid = g_malloc0(sizeof(*kid));
79
80 bus->num_children++;
81 kid->index = bus->max_index++;
82 kid->child = child;
83 object_ref(OBJECT(kid->child));
84
85 QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
86
87 /* This transfers ownership of kid->child to the property. */
88 snprintf(name, sizeof(name), "child[%d]", kid->index);
89 object_property_add_link(OBJECT(bus), name,
90 object_get_typename(OBJECT(child)),
91 (Object **)&kid->child,
92 NULL, /* read-only property */
93 0, /* return ownership on prop deletion */
94 NULL);
95 }
96
97 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
98 {
99 BusState *old_parent_bus = dev->parent_bus;
100
101 if (old_parent_bus) {
102 trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)),
103 old_parent_bus, object_get_typename(OBJECT(old_parent_bus)),
104 OBJECT(bus), object_get_typename(OBJECT(bus)));
105 /*
106 * Keep a reference to the device while it's not plugged into
107 * any bus, to avoid it potentially evaporating when it is
108 * dereffed in bus_remove_child().
109 * Also keep the ref of the parent bus until the end, so that
110 * we can safely call resettable_change_parent() below.
111 */
112 object_ref(OBJECT(dev));
113 bus_remove_child(dev->parent_bus, dev);
114 }
115 dev->parent_bus = bus;
116 object_ref(OBJECT(bus));
117 bus_add_child(bus, dev);
118 if (dev->realized) {
119 resettable_change_parent(OBJECT(dev), OBJECT(bus),
120 OBJECT(old_parent_bus));
121 }
122 if (old_parent_bus) {
123 object_unref(OBJECT(old_parent_bus));
124 object_unref(OBJECT(dev));
125 }
126 }
127
128 /* Create a new device. This only initializes the device state
129 structure and allows properties to be set. The device still needs
130 to be realized. See qdev-core.h. */
131 DeviceState *qdev_create(BusState *bus, const char *name)
132 {
133 DeviceState *dev;
134
135 dev = qdev_try_create(bus, name);
136 if (!dev) {
137 if (bus) {
138 error_report("Unknown device '%s' for bus '%s'", name,
139 object_get_typename(OBJECT(bus)));
140 } else {
141 error_report("Unknown device '%s' for default sysbus", name);
142 }
143 abort();
144 }
145
146 return dev;
147 }
148
149 DeviceState *qdev_try_create(BusState *bus, const char *type)
150 {
151 DeviceState *dev;
152
153 if (object_class_by_name(type) == NULL) {
154 return NULL;
155 }
156 dev = DEVICE(object_new(type));
157 if (!dev) {
158 return NULL;
159 }
160
161 if (!bus) {
162 /* Assert that the device really is a SysBusDevice before
163 * we put it onto the sysbus. Non-sysbus devices which aren't
164 * being put onto a bus should be created with object_new(TYPE_FOO),
165 * not qdev_create(NULL, TYPE_FOO).
166 */
167 g_assert(object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE));
168 bus = sysbus_get_default();
169 }
170
171 qdev_set_parent_bus(dev, bus);
172 object_unref(OBJECT(dev));
173 return dev;
174 }
175
176 static QTAILQ_HEAD(, DeviceListener) device_listeners
177 = QTAILQ_HEAD_INITIALIZER(device_listeners);
178
179 enum ListenerDirection { Forward, Reverse };
180
181 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
182 do { \
183 DeviceListener *_listener; \
184 \
185 switch (_direction) { \
186 case Forward: \
187 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
188 if (_listener->_callback) { \
189 _listener->_callback(_listener, ##_args); \
190 } \
191 } \
192 break; \
193 case Reverse: \
194 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
195 link) { \
196 if (_listener->_callback) { \
197 _listener->_callback(_listener, ##_args); \
198 } \
199 } \
200 break; \
201 default: \
202 abort(); \
203 } \
204 } while (0)
205
206 static int device_listener_add(DeviceState *dev, void *opaque)
207 {
208 DEVICE_LISTENER_CALL(realize, Forward, dev);
209
210 return 0;
211 }
212
213 void device_listener_register(DeviceListener *listener)
214 {
215 QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
216
217 qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
218 NULL, NULL);
219 }
220
221 void device_listener_unregister(DeviceListener *listener)
222 {
223 QTAILQ_REMOVE(&device_listeners, listener, link);
224 }
225
226 bool qdev_should_hide_device(QemuOpts *opts)
227 {
228 int rc = -1;
229 DeviceListener *listener;
230
231 QTAILQ_FOREACH(listener, &device_listeners, link) {
232 if (listener->should_be_hidden) {
233 /*
234 * should_be_hidden_will return
235 * 1 if device matches opts and it should be hidden
236 * 0 if device matches opts and should not be hidden
237 * -1 if device doesn't match ops
238 */
239 rc = listener->should_be_hidden(listener, opts);
240 }
241
242 if (rc > 0) {
243 break;
244 }
245 }
246
247 return rc > 0;
248 }
249
250 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
251 int required_for_version)
252 {
253 assert(!dev->realized);
254 dev->instance_id_alias = alias_id;
255 dev->alias_required_for_version = required_for_version;
256 }
257
258 HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev)
259 {
260 MachineState *machine;
261 MachineClass *mc;
262 Object *m_obj = qdev_get_machine();
263
264 if (object_dynamic_cast(m_obj, TYPE_MACHINE)) {
265 machine = MACHINE(m_obj);
266 mc = MACHINE_GET_CLASS(machine);
267 if (mc->get_hotplug_handler) {
268 return mc->get_hotplug_handler(machine, dev);
269 }
270 }
271
272 return NULL;
273 }
274
275 bool qdev_hotplug_allowed(DeviceState *dev, Error **errp)
276 {
277 MachineState *machine;
278 MachineClass *mc;
279 Object *m_obj = qdev_get_machine();
280
281 if (object_dynamic_cast(m_obj, TYPE_MACHINE)) {
282 machine = MACHINE(m_obj);
283 mc = MACHINE_GET_CLASS(machine);
284 if (mc->hotplug_allowed) {
285 return mc->hotplug_allowed(machine, dev, errp);
286 }
287 }
288
289 return true;
290 }
291
292 HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev)
293 {
294 if (dev->parent_bus) {
295 return dev->parent_bus->hotplug_handler;
296 }
297 return NULL;
298 }
299
300 HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
301 {
302 HotplugHandler *hotplug_ctrl = qdev_get_machine_hotplug_handler(dev);
303
304 if (hotplug_ctrl == NULL && dev->parent_bus) {
305 hotplug_ctrl = qdev_get_bus_hotplug_handler(dev);
306 }
307 return hotplug_ctrl;
308 }
309
310 static int qdev_prereset(DeviceState *dev, void *opaque)
311 {
312 trace_qdev_reset_tree(dev, object_get_typename(OBJECT(dev)));
313 return 0;
314 }
315
316 static int qbus_prereset(BusState *bus, void *opaque)
317 {
318 trace_qbus_reset_tree(bus, object_get_typename(OBJECT(bus)));
319 return 0;
320 }
321
322 static int qdev_reset_one(DeviceState *dev, void *opaque)
323 {
324 device_legacy_reset(dev);
325
326 return 0;
327 }
328
329 static int qbus_reset_one(BusState *bus, void *opaque)
330 {
331 BusClass *bc = BUS_GET_CLASS(bus);
332 trace_qbus_reset(bus, object_get_typename(OBJECT(bus)));
333 if (bc->reset) {
334 bc->reset(bus);
335 }
336 return 0;
337 }
338
339 void qdev_reset_all(DeviceState *dev)
340 {
341 trace_qdev_reset_all(dev, object_get_typename(OBJECT(dev)));
342 qdev_walk_children(dev, qdev_prereset, qbus_prereset,
343 qdev_reset_one, qbus_reset_one, NULL);
344 }
345
346 void qdev_reset_all_fn(void *opaque)
347 {
348 qdev_reset_all(DEVICE(opaque));
349 }
350
351 void qbus_reset_all(BusState *bus)
352 {
353 trace_qbus_reset_all(bus, object_get_typename(OBJECT(bus)));
354 qbus_walk_children(bus, qdev_prereset, qbus_prereset,
355 qdev_reset_one, qbus_reset_one, NULL);
356 }
357
358 void qbus_reset_all_fn(void *opaque)
359 {
360 BusState *bus = opaque;
361 qbus_reset_all(bus);
362 }
363
364 void device_cold_reset(DeviceState *dev)
365 {
366 resettable_reset(OBJECT(dev), RESET_TYPE_COLD);
367 }
368
369 bool device_is_in_reset(DeviceState *dev)
370 {
371 return resettable_is_in_reset(OBJECT(dev));
372 }
373
374 static ResettableState *device_get_reset_state(Object *obj)
375 {
376 DeviceState *dev = DEVICE(obj);
377 return &dev->reset;
378 }
379
380 static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb,
381 void *opaque, ResetType type)
382 {
383 DeviceState *dev = DEVICE(obj);
384 BusState *bus;
385
386 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
387 cb(OBJECT(bus), opaque, type);
388 }
389 }
390
391 /* can be used as ->unplug() callback for the simple cases */
392 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
393 DeviceState *dev, Error **errp)
394 {
395 object_property_set_bool(OBJECT(dev), false, "realized", NULL);
396 }
397
398 /*
399 * Realize @dev.
400 * Device properties should be set before calling this function. IRQs
401 * and MMIO regions should be connected/mapped after calling this
402 * function.
403 * On failure, report an error with error_report() and terminate the
404 * program. This is okay during machine creation. Don't use for
405 * hotplug, because there callers need to recover from failure.
406 * Exception: if you know the device's init() callback can't fail,
407 * then qdev_init_nofail() can't fail either, and is therefore usable
408 * even then. But relying on the device implementation that way is
409 * somewhat unclean, and best avoided.
410 */
411 void qdev_init_nofail(DeviceState *dev)
412 {
413 Error *err = NULL;
414
415 assert(!dev->realized);
416
417 object_ref(OBJECT(dev));
418 object_property_set_bool(OBJECT(dev), true, "realized", &err);
419 if (err) {
420 error_reportf_err(err, "Initialization of device %s failed: ",
421 object_get_typename(OBJECT(dev)));
422 exit(1);
423 }
424 object_unref(OBJECT(dev));
425 }
426
427 void qdev_machine_creation_done(void)
428 {
429 /*
430 * ok, initial machine setup is done, starting from now we can
431 * only create hotpluggable devices
432 */
433 qdev_hotplug = true;
434 }
435
436 bool qdev_machine_modified(void)
437 {
438 return qdev_hot_added || qdev_hot_removed;
439 }
440
441 BusState *qdev_get_parent_bus(DeviceState *dev)
442 {
443 return dev->parent_bus;
444 }
445
446 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
447 const char *name)
448 {
449 NamedGPIOList *ngl;
450
451 QLIST_FOREACH(ngl, &dev->gpios, node) {
452 /* NULL is a valid and matchable name. */
453 if (g_strcmp0(name, ngl->name) == 0) {
454 return ngl;
455 }
456 }
457
458 ngl = g_malloc0(sizeof(*ngl));
459 ngl->name = g_strdup(name);
460 QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
461 return ngl;
462 }
463
464 void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
465 qemu_irq_handler handler,
466 void *opaque,
467 const char *name, int n)
468 {
469 int i;
470 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
471
472 assert(gpio_list->num_out == 0 || !name);
473 gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
474 opaque, n);
475
476 if (!name) {
477 name = "unnamed-gpio-in";
478 }
479 for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
480 gchar *propname = g_strdup_printf("%s[%u]", name, i);
481
482 object_property_add_child(OBJECT(dev), propname,
483 OBJECT(gpio_list->in[i]), &error_abort);
484 g_free(propname);
485 }
486
487 gpio_list->num_in += n;
488 }
489
490 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
491 {
492 qdev_init_gpio_in_named(dev, handler, NULL, n);
493 }
494
495 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
496 const char *name, int n)
497 {
498 int i;
499 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
500
501 assert(gpio_list->num_in == 0 || !name);
502
503 if (!name) {
504 name = "unnamed-gpio-out";
505 }
506 memset(pins, 0, sizeof(*pins) * n);
507 for (i = 0; i < n; ++i) {
508 gchar *propname = g_strdup_printf("%s[%u]", name,
509 gpio_list->num_out + i);
510
511 object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
512 (Object **)&pins[i],
513 object_property_allow_set_link,
514 OBJ_PROP_LINK_STRONG,
515 &error_abort);
516 g_free(propname);
517 }
518 gpio_list->num_out += n;
519 }
520
521 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
522 {
523 qdev_init_gpio_out_named(dev, pins, NULL, n);
524 }
525
526 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
527 {
528 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
529
530 assert(n >= 0 && n < gpio_list->num_in);
531 return gpio_list->in[n];
532 }
533
534 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
535 {
536 return qdev_get_gpio_in_named(dev, NULL, n);
537 }
538
539 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
540 qemu_irq pin)
541 {
542 char *propname = g_strdup_printf("%s[%d]",
543 name ? name : "unnamed-gpio-out", n);
544 if (pin) {
545 /* We need a name for object_property_set_link to work. If the
546 * object has a parent, object_property_add_child will come back
547 * with an error without doing anything. If it has none, it will
548 * never fail. So we can just call it with a NULL Error pointer.
549 */
550 object_property_add_child(container_get(qdev_get_machine(),
551 "/unattached"),
552 "non-qdev-gpio[*]", OBJECT(pin), NULL);
553 }
554 object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &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), NULL, propname, 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 &error_abort);
612 g_free(propname);
613 }
614 for (i = 0; i < ngl->num_out; i++) {
615 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
616 char *propname = g_strdup_printf("%s[%d]", nm, i);
617
618 object_property_add_alias(OBJECT(container), propname,
619 OBJECT(dev), propname,
620 &error_abort);
621 g_free(propname);
622 }
623 QLIST_REMOVE(ngl, node);
624 QLIST_INSERT_HEAD(&container->gpios, ngl, node);
625 }
626
627 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
628 {
629 BusState *bus;
630 Object *child = object_resolve_path_component(OBJECT(dev), name);
631
632 bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
633 if (bus) {
634 return bus;
635 }
636
637 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
638 if (strcmp(name, bus->name) == 0) {
639 return bus;
640 }
641 }
642 return NULL;
643 }
644
645 int qdev_walk_children(DeviceState *dev,
646 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
647 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
648 void *opaque)
649 {
650 BusState *bus;
651 int err;
652
653 if (pre_devfn) {
654 err = pre_devfn(dev, opaque);
655 if (err) {
656 return err;
657 }
658 }
659
660 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
661 err = qbus_walk_children(bus, pre_devfn, pre_busfn,
662 post_devfn, post_busfn, opaque);
663 if (err < 0) {
664 return err;
665 }
666 }
667
668 if (post_devfn) {
669 err = post_devfn(dev, opaque);
670 if (err) {
671 return err;
672 }
673 }
674
675 return 0;
676 }
677
678 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
679 {
680 BusChild *kid;
681 DeviceState *ret;
682 BusState *child;
683
684 QTAILQ_FOREACH(kid, &bus->children, sibling) {
685 DeviceState *dev = kid->child;
686
687 if (dev->id && strcmp(dev->id, id) == 0) {
688 return dev;
689 }
690
691 QLIST_FOREACH(child, &dev->child_bus, sibling) {
692 ret = qdev_find_recursive(child, id);
693 if (ret) {
694 return ret;
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, &error_abort);
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, &error_abort);
775
776 object_property_set_description(obj, prop->name,
777 prop->info->description,
778 &error_abort);
779
780 if (prop->set_default) {
781 prop->info->set_default_value(op, prop);
782 if (op->init) {
783 op->init(obj, op);
784 }
785 }
786 }
787
788 static void qdev_class_add_property(DeviceClass *klass, Property *prop)
789 {
790 ObjectClass *oc = OBJECT_CLASS(klass);
791
792 if (prop->info->create) {
793 prop->info->create(oc, prop, &error_abort);
794 } else {
795 ObjectProperty *op;
796
797 op = object_class_property_add(oc,
798 prop->name, prop->info->name,
799 prop->info->get, prop->info->set,
800 prop->info->release,
801 prop, &error_abort);
802 if (prop->set_default) {
803 prop->info->set_default_value(op, prop);
804 }
805 }
806 object_class_property_set_description(oc, prop->name,
807 prop->info->description,
808 &error_abort);
809 }
810
811 /* @qdev_alias_all_properties - Add alias properties to the source object for
812 * all qdev properties on the target DeviceState.
813 */
814 void qdev_alias_all_properties(DeviceState *target, Object *source)
815 {
816 ObjectClass *class;
817 Property *prop;
818
819 class = object_get_class(OBJECT(target));
820 do {
821 DeviceClass *dc = DEVICE_CLASS(class);
822
823 for (prop = dc->props_; prop && prop->name; prop++) {
824 object_property_add_alias(source, prop->name,
825 OBJECT(target), prop->name,
826 &error_abort);
827 }
828 class = object_class_get_parent(class);
829 } while (class != object_class_by_name(TYPE_DEVICE));
830 }
831
832 static bool device_get_realized(Object *obj, Error **errp)
833 {
834 DeviceState *dev = DEVICE(obj);
835 return dev->realized;
836 }
837
838 static bool check_only_migratable(Object *obj, Error **errp)
839 {
840 DeviceClass *dc = DEVICE_GET_CLASS(obj);
841
842 if (!vmstate_check_only_migratable(dc->vmsd)) {
843 error_setg(errp, "Device %s is not migratable, but "
844 "--only-migratable was specified",
845 object_get_typename(obj));
846 return false;
847 }
848
849 return true;
850 }
851
852 static void device_set_realized(Object *obj, bool value, Error **errp)
853 {
854 DeviceState *dev = DEVICE(obj);
855 DeviceClass *dc = DEVICE_GET_CLASS(dev);
856 HotplugHandler *hotplug_ctrl;
857 BusState *bus;
858 Error *local_err = NULL;
859 bool unattached_parent = false;
860 static int unattached_count;
861
862 if (dev->hotplugged && !dc->hotpluggable) {
863 error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
864 return;
865 }
866
867 if (value && !dev->realized) {
868 if (!check_only_migratable(obj, &local_err)) {
869 goto fail;
870 }
871
872 if (!obj->parent) {
873 gchar *name = g_strdup_printf("device[%d]", unattached_count++);
874
875 object_property_add_child(container_get(qdev_get_machine(),
876 "/unattached"),
877 name, obj, &error_abort);
878 unattached_parent = true;
879 g_free(name);
880 }
881
882 hotplug_ctrl = qdev_get_hotplug_handler(dev);
883 if (hotplug_ctrl) {
884 hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
885 if (local_err != NULL) {
886 goto fail;
887 }
888 }
889
890 if (dc->realize) {
891 dc->realize(dev, &local_err);
892 if (local_err != NULL) {
893 goto fail;
894 }
895 }
896
897 DEVICE_LISTENER_CALL(realize, Forward, dev);
898
899 /*
900 * always free/re-initialize here since the value cannot be cleaned up
901 * in device_unrealize due to its usage later on in the unplug path
902 */
903 g_free(dev->canonical_path);
904 dev->canonical_path = object_get_canonical_path(OBJECT(dev));
905
906 if (qdev_get_vmsd(dev)) {
907 if (vmstate_register_with_alias_id(VMSTATE_IF(dev),
908 VMSTATE_INSTANCE_ID_ANY,
909 qdev_get_vmsd(dev), dev,
910 dev->instance_id_alias,
911 dev->alias_required_for_version,
912 &local_err) < 0) {
913 goto post_realize_fail;
914 }
915 }
916
917 /*
918 * Clear the reset state, in case the object was previously unrealized
919 * with a dirty state.
920 */
921 resettable_state_clear(&dev->reset);
922
923 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
924 object_property_set_bool(OBJECT(bus), true, "realized",
925 &local_err);
926 if (local_err != NULL) {
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 /* We want local_err to track only the first error */
951 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
952 object_property_set_bool(OBJECT(bus), false, "realized",
953 local_err ? NULL : &local_err);
954 }
955 if (qdev_get_vmsd(dev)) {
956 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
957 }
958 if (dc->unrealize) {
959 dc->unrealize(dev, local_err ? NULL : &local_err);
960 }
961 dev->pending_deleted_event = true;
962 DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
963
964 if (local_err != NULL) {
965 goto fail;
966 }
967 }
968
969 assert(local_err == NULL);
970 dev->realized = value;
971 return;
972
973 child_realize_fail:
974 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
975 object_property_set_bool(OBJECT(bus), false, "realized",
976 NULL);
977 }
978
979 if (qdev_get_vmsd(dev)) {
980 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
981 }
982
983 post_realize_fail:
984 g_free(dev->canonical_path);
985 dev->canonical_path = NULL;
986 if (dc->unrealize) {
987 dc->unrealize(dev, NULL);
988 }
989
990 fail:
991 error_propagate(errp, local_err);
992 if (unattached_parent) {
993 object_unparent(OBJECT(dev));
994 unattached_count--;
995 }
996 }
997
998 static bool device_get_hotpluggable(Object *obj, Error **errp)
999 {
1000 DeviceClass *dc = DEVICE_GET_CLASS(obj);
1001 DeviceState *dev = DEVICE(obj);
1002
1003 return dc->hotpluggable && (dev->parent_bus == NULL ||
1004 qbus_is_hotpluggable(dev->parent_bus));
1005 }
1006
1007 static bool device_get_hotplugged(Object *obj, Error **errp)
1008 {
1009 DeviceState *dev = DEVICE(obj);
1010
1011 return dev->hotplugged;
1012 }
1013
1014 static void device_initfn(Object *obj)
1015 {
1016 DeviceState *dev = DEVICE(obj);
1017
1018 if (qdev_hotplug) {
1019 dev->hotplugged = 1;
1020 qdev_hot_added = true;
1021 }
1022
1023 dev->instance_id_alias = -1;
1024 dev->realized = false;
1025 dev->allow_unplug_during_migration = false;
1026
1027 QLIST_INIT(&dev->gpios);
1028 }
1029
1030 static void device_post_init(Object *obj)
1031 {
1032 /*
1033 * Note: ordered so that the user's global properties take
1034 * precedence.
1035 */
1036 object_apply_compat_props(obj);
1037 qdev_prop_set_globals(DEVICE(obj));
1038 }
1039
1040 /* Unlink device from bus and free the structure. */
1041 static void device_finalize(Object *obj)
1042 {
1043 NamedGPIOList *ngl, *next;
1044
1045 DeviceState *dev = DEVICE(obj);
1046
1047 QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1048 QLIST_REMOVE(ngl, node);
1049 qemu_free_irqs(ngl->in, ngl->num_in);
1050 g_free(ngl->name);
1051 g_free(ngl);
1052 /* ngl->out irqs are owned by the other end and should not be freed
1053 * here
1054 */
1055 }
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 object_property_set_bool(obj, false, "realized", NULL);
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 &error_abort);
1196 object_class_property_add_bool(class, "hotpluggable",
1197 device_get_hotpluggable, NULL,
1198 &error_abort);
1199 object_class_property_add_bool(class, "hotplugged",
1200 device_get_hotplugged, NULL,
1201 &error_abort);
1202 object_class_property_add_link(class, "parent_bus", TYPE_BUS,
1203 offsetof(DeviceState, parent_bus), NULL, 0,
1204 &error_abort);
1205 }
1206
1207 void device_class_set_props(DeviceClass *dc, Property *props)
1208 {
1209 Property *prop;
1210
1211 dc->props_ = props;
1212 for (prop = props; prop && prop->name; prop++) {
1213 qdev_class_add_legacy_property(dc, prop);
1214 qdev_class_add_property(dc, prop);
1215 }
1216 }
1217
1218 void device_class_set_parent_reset(DeviceClass *dc,
1219 DeviceReset dev_reset,
1220 DeviceReset *parent_reset)
1221 {
1222 *parent_reset = dc->reset;
1223 dc->reset = dev_reset;
1224 }
1225
1226 void device_class_set_parent_realize(DeviceClass *dc,
1227 DeviceRealize dev_realize,
1228 DeviceRealize *parent_realize)
1229 {
1230 *parent_realize = dc->realize;
1231 dc->realize = dev_realize;
1232 }
1233
1234 void device_class_set_parent_unrealize(DeviceClass *dc,
1235 DeviceUnrealize dev_unrealize,
1236 DeviceUnrealize *parent_unrealize)
1237 {
1238 *parent_unrealize = dc->unrealize;
1239 dc->unrealize = dev_unrealize;
1240 }
1241
1242 void device_legacy_reset(DeviceState *dev)
1243 {
1244 DeviceClass *klass = DEVICE_GET_CLASS(dev);
1245
1246 trace_qdev_reset(dev, object_get_typename(OBJECT(dev)));
1247 if (klass->reset) {
1248 klass->reset(dev);
1249 }
1250 }
1251
1252 Object *qdev_get_machine(void)
1253 {
1254 static Object *dev;
1255
1256 if (dev == NULL) {
1257 dev = container_get(object_get_root(), "/machine");
1258 }
1259
1260 return dev;
1261 }
1262
1263 static const TypeInfo device_type_info = {
1264 .name = TYPE_DEVICE,
1265 .parent = TYPE_OBJECT,
1266 .instance_size = sizeof(DeviceState),
1267 .instance_init = device_initfn,
1268 .instance_post_init = device_post_init,
1269 .instance_finalize = device_finalize,
1270 .class_base_init = device_class_base_init,
1271 .class_init = device_class_init,
1272 .abstract = true,
1273 .class_size = sizeof(DeviceClass),
1274 .interfaces = (InterfaceInfo[]) {
1275 { TYPE_VMSTATE_IF },
1276 { TYPE_RESETTABLE_INTERFACE },
1277 { }
1278 }
1279 };
1280
1281 static void qdev_register_types(void)
1282 {
1283 type_register_static(&device_type_info);
1284 }
1285
1286 type_init(qdev_register_types)