Merge remote-tracking branch 'remotes/afaerber/tags/ppc-for-2.0' 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 "hw/qdev.h"
29 #include "hw/fw-path-provider.h"
30 #include "sysemu/sysemu.h"
31 #include "qapi/error.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "monitor/monitor.h"
36 #include "hw/hotplug.h"
37
38 int qdev_hotplug = 0;
39 static bool qdev_hot_added = false;
40 static bool qdev_hot_removed = false;
41
42 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
43 {
44 DeviceClass *dc = DEVICE_GET_CLASS(dev);
45 return dc->vmsd;
46 }
47
48 const char *qdev_fw_name(DeviceState *dev)
49 {
50 DeviceClass *dc = DEVICE_GET_CLASS(dev);
51
52 if (dc->fw_name) {
53 return dc->fw_name;
54 }
55
56 return object_get_typename(OBJECT(dev));
57 }
58
59 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
60 Error **errp);
61
62 static void bus_remove_child(BusState *bus, DeviceState *child)
63 {
64 BusChild *kid;
65
66 QTAILQ_FOREACH(kid, &bus->children, sibling) {
67 if (kid->child == child) {
68 char name[32];
69
70 snprintf(name, sizeof(name), "child[%d]", kid->index);
71 QTAILQ_REMOVE(&bus->children, kid, sibling);
72
73 /* This gives back ownership of kid->child back to us. */
74 object_property_del(OBJECT(bus), name, NULL);
75 object_unref(OBJECT(kid->child));
76 g_free(kid);
77 return;
78 }
79 }
80 }
81
82 static void bus_add_child(BusState *bus, DeviceState *child)
83 {
84 char name[32];
85 BusChild *kid = g_malloc0(sizeof(*kid));
86
87 if (qdev_hotplug) {
88 assert(bus->allow_hotplug);
89 }
90
91 kid->index = bus->max_index++;
92 kid->child = child;
93 object_ref(OBJECT(kid->child));
94
95 QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
96
97 /* This transfers ownership of kid->child to the property. */
98 snprintf(name, sizeof(name), "child[%d]", kid->index);
99 object_property_add_link(OBJECT(bus), name,
100 object_get_typename(OBJECT(child)),
101 (Object **)&kid->child,
102 NULL, /* read-only property */
103 0, /* return ownership on prop deletion */
104 NULL);
105 }
106
107 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
108 {
109 dev->parent_bus = bus;
110 object_ref(OBJECT(bus));
111 bus_add_child(bus, dev);
112 }
113
114 /* Create a new device. This only initializes the device state structure
115 and allows properties to be set. qdev_init should be called to
116 initialize the actual device emulation. */
117 DeviceState *qdev_create(BusState *bus, const char *name)
118 {
119 DeviceState *dev;
120
121 dev = qdev_try_create(bus, name);
122 if (!dev) {
123 if (bus) {
124 error_report("Unknown device '%s' for bus '%s'", name,
125 object_get_typename(OBJECT(bus)));
126 } else {
127 error_report("Unknown device '%s' for default sysbus", name);
128 }
129 abort();
130 }
131
132 return dev;
133 }
134
135 DeviceState *qdev_try_create(BusState *bus, const char *type)
136 {
137 DeviceState *dev;
138
139 if (object_class_by_name(type) == NULL) {
140 return NULL;
141 }
142 dev = DEVICE(object_new(type));
143 if (!dev) {
144 return NULL;
145 }
146
147 if (!bus) {
148 bus = sysbus_get_default();
149 }
150
151 qdev_set_parent_bus(dev, bus);
152 object_unref(OBJECT(dev));
153 return dev;
154 }
155
156 /* Initialize a device. Device properties should be set before calling
157 this function. IRQs and MMIO regions should be connected/mapped after
158 calling this function.
159 On failure, destroy the device and return negative value.
160 Return 0 on success. */
161 int qdev_init(DeviceState *dev)
162 {
163 Error *local_err = NULL;
164
165 assert(!dev->realized);
166
167 object_property_set_bool(OBJECT(dev), true, "realized", &local_err);
168 if (local_err != NULL) {
169 qerror_report_err(local_err);
170 error_free(local_err);
171 object_unparent(OBJECT(dev));
172 return -1;
173 }
174 return 0;
175 }
176
177 static void device_realize(DeviceState *dev, Error **err)
178 {
179 DeviceClass *dc = DEVICE_GET_CLASS(dev);
180
181 if (dc->init) {
182 int rc = dc->init(dev);
183 if (rc < 0) {
184 error_setg(err, "Device initialization failed.");
185 return;
186 }
187 }
188 }
189
190 static void device_unrealize(DeviceState *dev, Error **errp)
191 {
192 DeviceClass *dc = DEVICE_GET_CLASS(dev);
193
194 if (dc->exit) {
195 int rc = dc->exit(dev);
196 if (rc < 0) {
197 error_setg(errp, "Device exit failed.");
198 return;
199 }
200 }
201 }
202
203 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
204 int required_for_version)
205 {
206 assert(!dev->realized);
207 dev->instance_id_alias = alias_id;
208 dev->alias_required_for_version = required_for_version;
209 }
210
211 void qdev_unplug(DeviceState *dev, Error **errp)
212 {
213 DeviceClass *dc = DEVICE_GET_CLASS(dev);
214
215 if (dev->parent_bus && !dev->parent_bus->allow_hotplug) {
216 error_set(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
217 return;
218 }
219
220 if (!dc->hotpluggable) {
221 error_set(errp, QERR_DEVICE_NO_HOTPLUG,
222 object_get_typename(OBJECT(dev)));
223 return;
224 }
225
226 qdev_hot_removed = true;
227
228 if (dev->parent_bus && dev->parent_bus->hotplug_handler) {
229 hotplug_handler_unplug(dev->parent_bus->hotplug_handler, dev, errp);
230 } else {
231 assert(dc->unplug != NULL);
232 if (dc->unplug(dev) < 0) { /* legacy handler */
233 error_set(errp, QERR_UNDEFINED_ERROR);
234 }
235 }
236 }
237
238 static int qdev_reset_one(DeviceState *dev, void *opaque)
239 {
240 device_reset(dev);
241
242 return 0;
243 }
244
245 static int qbus_reset_one(BusState *bus, void *opaque)
246 {
247 BusClass *bc = BUS_GET_CLASS(bus);
248 if (bc->reset) {
249 bc->reset(bus);
250 }
251 return 0;
252 }
253
254 void qdev_reset_all(DeviceState *dev)
255 {
256 qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
257 }
258
259 void qbus_reset_all(BusState *bus)
260 {
261 qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
262 }
263
264 void qbus_reset_all_fn(void *opaque)
265 {
266 BusState *bus = opaque;
267 qbus_reset_all(bus);
268 }
269
270 /* can be used as ->unplug() callback for the simple cases */
271 int qdev_simple_unplug_cb(DeviceState *dev)
272 {
273 /* just zap it */
274 object_unparent(OBJECT(dev));
275 return 0;
276 }
277
278
279 /* Like qdev_init(), but terminate program via error_report() instead of
280 returning an error value. This is okay during machine creation.
281 Don't use for hotplug, because there callers need to recover from
282 failure. Exception: if you know the device's init() callback can't
283 fail, then qdev_init_nofail() can't fail either, and is therefore
284 usable even then. But relying on the device implementation that
285 way is somewhat unclean, and best avoided. */
286 void qdev_init_nofail(DeviceState *dev)
287 {
288 const char *typename = object_get_typename(OBJECT(dev));
289
290 if (qdev_init(dev) < 0) {
291 error_report("Initialization of device %s failed", typename);
292 exit(1);
293 }
294 }
295
296 void qdev_machine_creation_done(void)
297 {
298 /*
299 * ok, initial machine setup is done, starting from now we can
300 * only create hotpluggable devices
301 */
302 qdev_hotplug = 1;
303 }
304
305 bool qdev_machine_modified(void)
306 {
307 return qdev_hot_added || qdev_hot_removed;
308 }
309
310 BusState *qdev_get_parent_bus(DeviceState *dev)
311 {
312 return dev->parent_bus;
313 }
314
315 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
316 {
317 dev->gpio_in = qemu_extend_irqs(dev->gpio_in, dev->num_gpio_in, handler,
318 dev, n);
319 dev->num_gpio_in += n;
320 }
321
322 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
323 {
324 assert(dev->num_gpio_out == 0);
325 dev->num_gpio_out = n;
326 dev->gpio_out = pins;
327 }
328
329 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
330 {
331 assert(n >= 0 && n < dev->num_gpio_in);
332 return dev->gpio_in[n];
333 }
334
335 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
336 {
337 assert(n >= 0 && n < dev->num_gpio_out);
338 dev->gpio_out[n] = pin;
339 }
340
341 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
342 {
343 BusState *bus;
344
345 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
346 if (strcmp(name, bus->name) == 0) {
347 return bus;
348 }
349 }
350 return NULL;
351 }
352
353 int qbus_walk_children(BusState *bus,
354 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
355 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
356 void *opaque)
357 {
358 BusChild *kid;
359 int err;
360
361 if (pre_busfn) {
362 err = pre_busfn(bus, opaque);
363 if (err) {
364 return err;
365 }
366 }
367
368 QTAILQ_FOREACH(kid, &bus->children, sibling) {
369 err = qdev_walk_children(kid->child,
370 pre_devfn, pre_busfn,
371 post_devfn, post_busfn, opaque);
372 if (err < 0) {
373 return err;
374 }
375 }
376
377 if (post_busfn) {
378 err = post_busfn(bus, opaque);
379 if (err) {
380 return err;
381 }
382 }
383
384 return 0;
385 }
386
387 int qdev_walk_children(DeviceState *dev,
388 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
389 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
390 void *opaque)
391 {
392 BusState *bus;
393 int err;
394
395 if (pre_devfn) {
396 err = pre_devfn(dev, opaque);
397 if (err) {
398 return err;
399 }
400 }
401
402 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
403 err = qbus_walk_children(bus, pre_devfn, pre_busfn,
404 post_devfn, post_busfn, opaque);
405 if (err < 0) {
406 return err;
407 }
408 }
409
410 if (post_devfn) {
411 err = post_devfn(dev, opaque);
412 if (err) {
413 return err;
414 }
415 }
416
417 return 0;
418 }
419
420 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
421 {
422 BusChild *kid;
423 DeviceState *ret;
424 BusState *child;
425
426 QTAILQ_FOREACH(kid, &bus->children, sibling) {
427 DeviceState *dev = kid->child;
428
429 if (dev->id && strcmp(dev->id, id) == 0) {
430 return dev;
431 }
432
433 QLIST_FOREACH(child, &dev->child_bus, sibling) {
434 ret = qdev_find_recursive(child, id);
435 if (ret) {
436 return ret;
437 }
438 }
439 }
440 return NULL;
441 }
442
443 static void qbus_realize(BusState *bus, DeviceState *parent, const char *name)
444 {
445 const char *typename = object_get_typename(OBJECT(bus));
446 BusClass *bc;
447 char *buf;
448 int i, len, bus_id;
449
450 bus->parent = parent;
451
452 if (name) {
453 bus->name = g_strdup(name);
454 } else if (bus->parent && bus->parent->id) {
455 /* parent device has id -> use it plus parent-bus-id for bus name */
456 bus_id = bus->parent->num_child_bus;
457
458 len = strlen(bus->parent->id) + 16;
459 buf = g_malloc(len);
460 snprintf(buf, len, "%s.%d", bus->parent->id, bus_id);
461 bus->name = buf;
462 } else {
463 /* no id -> use lowercase bus type plus global bus-id for bus name */
464 bc = BUS_GET_CLASS(bus);
465 bus_id = bc->automatic_ids++;
466
467 len = strlen(typename) + 16;
468 buf = g_malloc(len);
469 len = snprintf(buf, len, "%s.%d", typename, bus_id);
470 for (i = 0; i < len; i++) {
471 buf[i] = qemu_tolower(buf[i]);
472 }
473 bus->name = buf;
474 }
475
476 if (bus->parent) {
477 QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
478 bus->parent->num_child_bus++;
479 object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL);
480 object_unref(OBJECT(bus));
481 } else if (bus != sysbus_get_default()) {
482 /* TODO: once all bus devices are qdevified,
483 only reset handler for main_system_bus should be registered here. */
484 qemu_register_reset(qbus_reset_all_fn, bus);
485 }
486 }
487
488 static void bus_unparent(Object *obj)
489 {
490 BusState *bus = BUS(obj);
491 BusChild *kid;
492
493 while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
494 DeviceState *dev = kid->child;
495 object_unparent(OBJECT(dev));
496 }
497 if (bus->parent) {
498 QLIST_REMOVE(bus, sibling);
499 bus->parent->num_child_bus--;
500 bus->parent = NULL;
501 } else {
502 assert(bus != sysbus_get_default()); /* main_system_bus is never freed */
503 qemu_unregister_reset(qbus_reset_all_fn, bus);
504 }
505 }
506
507 static bool bus_get_realized(Object *obj, Error **err)
508 {
509 BusState *bus = BUS(obj);
510
511 return bus->realized;
512 }
513
514 static void bus_set_realized(Object *obj, bool value, Error **err)
515 {
516 BusState *bus = BUS(obj);
517 BusClass *bc = BUS_GET_CLASS(bus);
518 Error *local_err = NULL;
519
520 if (value && !bus->realized) {
521 if (bc->realize) {
522 bc->realize(bus, &local_err);
523
524 if (local_err != NULL) {
525 goto error;
526 }
527
528 }
529 } else if (!value && bus->realized) {
530 if (bc->unrealize) {
531 bc->unrealize(bus, &local_err);
532
533 if (local_err != NULL) {
534 goto error;
535 }
536 }
537 }
538
539 bus->realized = value;
540 return;
541
542 error:
543 error_propagate(err, local_err);
544 }
545
546 void qbus_create_inplace(void *bus, size_t size, const char *typename,
547 DeviceState *parent, const char *name)
548 {
549 object_initialize(bus, size, typename);
550 qbus_realize(bus, parent, name);
551 }
552
553 BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
554 {
555 BusState *bus;
556
557 bus = BUS(object_new(typename));
558 qbus_realize(bus, parent, name);
559
560 return bus;
561 }
562
563 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
564 {
565 BusClass *bc = BUS_GET_CLASS(bus);
566
567 if (bc->get_fw_dev_path) {
568 return bc->get_fw_dev_path(dev);
569 }
570
571 return NULL;
572 }
573
574 static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
575 {
576 Object *obj = OBJECT(dev);
577 char *d = NULL;
578
579 while (!d && obj->parent) {
580 obj = obj->parent;
581 d = fw_path_provider_try_get_dev_path(obj, bus, dev);
582 }
583 return d;
584 }
585
586 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
587 {
588 int l = 0;
589
590 if (dev && dev->parent_bus) {
591 char *d;
592 l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
593 d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev);
594 if (!d) {
595 d = bus_get_fw_dev_path(dev->parent_bus, dev);
596 }
597 if (d) {
598 l += snprintf(p + l, size - l, "%s", d);
599 g_free(d);
600 } else {
601 return l;
602 }
603 }
604 l += snprintf(p + l , size - l, "/");
605
606 return l;
607 }
608
609 char* qdev_get_fw_dev_path(DeviceState *dev)
610 {
611 char path[128];
612 int l;
613
614 l = qdev_get_fw_dev_path_helper(dev, path, 128);
615
616 path[l-1] = '\0';
617
618 return g_strdup(path);
619 }
620
621 char *qdev_get_dev_path(DeviceState *dev)
622 {
623 BusClass *bc;
624
625 if (!dev || !dev->parent_bus) {
626 return NULL;
627 }
628
629 bc = BUS_GET_CLASS(dev->parent_bus);
630 if (bc->get_dev_path) {
631 return bc->get_dev_path(dev);
632 }
633
634 return NULL;
635 }
636
637 /**
638 * Legacy property handling
639 */
640
641 static void qdev_get_legacy_property(Object *obj, Visitor *v, void *opaque,
642 const char *name, Error **errp)
643 {
644 DeviceState *dev = DEVICE(obj);
645 Property *prop = opaque;
646
647 char buffer[1024];
648 char *ptr = buffer;
649
650 prop->info->print(dev, prop, buffer, sizeof(buffer));
651 visit_type_str(v, &ptr, name, errp);
652 }
653
654 /**
655 * @qdev_add_legacy_property - adds a legacy property
656 *
657 * Do not use this is new code! Properties added through this interface will
658 * be given names and types in the "legacy" namespace.
659 *
660 * Legacy properties are string versions of other OOM properties. The format
661 * of the string depends on the property type.
662 */
663 void qdev_property_add_legacy(DeviceState *dev, Property *prop,
664 Error **errp)
665 {
666 gchar *name;
667
668 /* Register pointer properties as legacy properties */
669 if (!prop->info->print && prop->info->get) {
670 return;
671 }
672
673 name = g_strdup_printf("legacy-%s", prop->name);
674 object_property_add(OBJECT(dev), name, "str",
675 prop->info->print ? qdev_get_legacy_property : prop->info->get,
676 NULL,
677 NULL,
678 prop, errp);
679
680 g_free(name);
681 }
682
683 /**
684 * @qdev_property_add_static - add a @Property to a device.
685 *
686 * Static properties access data in a struct. The actual type of the
687 * property and the field depends on the property type.
688 */
689 void qdev_property_add_static(DeviceState *dev, Property *prop,
690 Error **errp)
691 {
692 Error *local_err = NULL;
693 Object *obj = OBJECT(dev);
694
695 /*
696 * TODO qdev_prop_ptr does not have getters or setters. It must
697 * go now that it can be replaced with links. The test should be
698 * removed along with it: all static properties are read/write.
699 */
700 if (!prop->info->get && !prop->info->set) {
701 return;
702 }
703
704 object_property_add(obj, prop->name, prop->info->name,
705 prop->info->get, prop->info->set,
706 prop->info->release,
707 prop, &local_err);
708
709 if (local_err) {
710 error_propagate(errp, local_err);
711 return;
712 }
713 if (prop->qtype == QTYPE_NONE) {
714 return;
715 }
716
717 if (prop->qtype == QTYPE_QBOOL) {
718 object_property_set_bool(obj, prop->defval, prop->name, &error_abort);
719 } else if (prop->info->enum_table) {
720 object_property_set_str(obj, prop->info->enum_table[prop->defval],
721 prop->name, &error_abort);
722 } else if (prop->qtype == QTYPE_QINT) {
723 object_property_set_int(obj, prop->defval, prop->name, &error_abort);
724 }
725 }
726
727 static bool device_get_realized(Object *obj, Error **err)
728 {
729 DeviceState *dev = DEVICE(obj);
730 return dev->realized;
731 }
732
733 static void device_set_realized(Object *obj, bool value, Error **err)
734 {
735 DeviceState *dev = DEVICE(obj);
736 DeviceClass *dc = DEVICE_GET_CLASS(dev);
737 BusState *bus;
738 Error *local_err = NULL;
739
740 if (dev->hotplugged && !dc->hotpluggable) {
741 error_set(err, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
742 return;
743 }
744
745 if (value && !dev->realized) {
746 if (!obj->parent && local_err == NULL) {
747 static int unattached_count;
748 gchar *name = g_strdup_printf("device[%d]", unattached_count++);
749
750 object_property_add_child(container_get(qdev_get_machine(),
751 "/unattached"),
752 name, obj, &local_err);
753 g_free(name);
754 }
755
756 if (dc->realize) {
757 dc->realize(dev, &local_err);
758 }
759
760 if (dev->parent_bus && dev->parent_bus->hotplug_handler &&
761 local_err == NULL) {
762 hotplug_handler_plug(dev->parent_bus->hotplug_handler,
763 dev, &local_err);
764 }
765
766 if (qdev_get_vmsd(dev) && local_err == NULL) {
767 vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
768 dev->instance_id_alias,
769 dev->alias_required_for_version);
770 }
771 if (local_err == NULL) {
772 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
773 object_property_set_bool(OBJECT(bus), true, "realized",
774 &local_err);
775 if (local_err != NULL) {
776 break;
777 }
778 }
779 }
780 if (dev->hotplugged && local_err == NULL) {
781 device_reset(dev);
782 }
783 } else if (!value && dev->realized) {
784 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
785 object_property_set_bool(OBJECT(bus), false, "realized",
786 &local_err);
787 if (local_err != NULL) {
788 break;
789 }
790 }
791 if (qdev_get_vmsd(dev) && local_err == NULL) {
792 vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
793 }
794 if (dc->unrealize && local_err == NULL) {
795 dc->unrealize(dev, &local_err);
796 }
797 }
798
799 if (local_err != NULL) {
800 error_propagate(err, local_err);
801 return;
802 }
803
804 dev->realized = value;
805 }
806
807 static bool device_get_hotpluggable(Object *obj, Error **err)
808 {
809 DeviceClass *dc = DEVICE_GET_CLASS(obj);
810 DeviceState *dev = DEVICE(obj);
811
812 return dc->hotpluggable && (dev->parent_bus == NULL ||
813 dev->parent_bus->allow_hotplug);
814 }
815
816 static void device_initfn(Object *obj)
817 {
818 DeviceState *dev = DEVICE(obj);
819 ObjectClass *class;
820 Property *prop;
821
822 if (qdev_hotplug) {
823 dev->hotplugged = 1;
824 qdev_hot_added = true;
825 }
826
827 dev->instance_id_alias = -1;
828 dev->realized = false;
829
830 object_property_add_bool(obj, "realized",
831 device_get_realized, device_set_realized, NULL);
832 object_property_add_bool(obj, "hotpluggable",
833 device_get_hotpluggable, NULL, NULL);
834
835 class = object_get_class(OBJECT(dev));
836 do {
837 for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
838 qdev_property_add_legacy(dev, prop, &error_abort);
839 qdev_property_add_static(dev, prop, &error_abort);
840 }
841 class = object_class_get_parent(class);
842 } while (class != object_class_by_name(TYPE_DEVICE));
843
844 object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
845 (Object **)&dev->parent_bus, NULL, 0,
846 &error_abort);
847 }
848
849 static void device_post_init(Object *obj)
850 {
851 qdev_prop_set_globals(DEVICE(obj), &error_abort);
852 }
853
854 /* Unlink device from bus and free the structure. */
855 static void device_finalize(Object *obj)
856 {
857 DeviceState *dev = DEVICE(obj);
858 if (dev->opts) {
859 qemu_opts_del(dev->opts);
860 }
861 }
862
863 static void device_class_base_init(ObjectClass *class, void *data)
864 {
865 DeviceClass *klass = DEVICE_CLASS(class);
866
867 /* We explicitly look up properties in the superclasses,
868 * so do not propagate them to the subclasses.
869 */
870 klass->props = NULL;
871 }
872
873 static void device_unparent(Object *obj)
874 {
875 DeviceState *dev = DEVICE(obj);
876 BusState *bus;
877 QObject *event_data;
878 bool have_realized = dev->realized;
879
880 if (dev->realized) {
881 object_property_set_bool(obj, false, "realized", NULL);
882 }
883 while (dev->num_child_bus) {
884 bus = QLIST_FIRST(&dev->child_bus);
885 object_unparent(OBJECT(bus));
886 }
887 if (dev->parent_bus) {
888 bus_remove_child(dev->parent_bus, dev);
889 object_unref(OBJECT(dev->parent_bus));
890 dev->parent_bus = NULL;
891 }
892
893 /* Only send event if the device had been completely realized */
894 if (have_realized) {
895 gchar *path = object_get_canonical_path(OBJECT(dev));
896
897 if (dev->id) {
898 event_data = qobject_from_jsonf("{ 'device': %s, 'path': %s }",
899 dev->id, path);
900 } else {
901 event_data = qobject_from_jsonf("{ 'path': %s }", path);
902 }
903 monitor_protocol_event(QEVENT_DEVICE_DELETED, event_data);
904 qobject_decref(event_data);
905 g_free(path);
906 }
907 }
908
909 static void device_class_init(ObjectClass *class, void *data)
910 {
911 DeviceClass *dc = DEVICE_CLASS(class);
912
913 class->unparent = device_unparent;
914 dc->realize = device_realize;
915 dc->unrealize = device_unrealize;
916
917 /* by default all devices were considered as hotpluggable,
918 * so with intent to check it in generic qdev_unplug() /
919 * device_set_realized() functions make every device
920 * hotpluggable. Devices that shouldn't be hotpluggable,
921 * should override it in their class_init()
922 */
923 dc->hotpluggable = true;
924 }
925
926 void device_reset(DeviceState *dev)
927 {
928 DeviceClass *klass = DEVICE_GET_CLASS(dev);
929
930 if (klass->reset) {
931 klass->reset(dev);
932 }
933 }
934
935 Object *qdev_get_machine(void)
936 {
937 static Object *dev;
938
939 if (dev == NULL) {
940 dev = container_get(object_get_root(), "/machine");
941 }
942
943 return dev;
944 }
945
946 static const TypeInfo device_type_info = {
947 .name = TYPE_DEVICE,
948 .parent = TYPE_OBJECT,
949 .instance_size = sizeof(DeviceState),
950 .instance_init = device_initfn,
951 .instance_post_init = device_post_init,
952 .instance_finalize = device_finalize,
953 .class_base_init = device_class_base_init,
954 .class_init = device_class_init,
955 .abstract = true,
956 .class_size = sizeof(DeviceClass),
957 };
958
959 static void qbus_initfn(Object *obj)
960 {
961 BusState *bus = BUS(obj);
962
963 QTAILQ_INIT(&bus->children);
964 object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
965 TYPE_HOTPLUG_HANDLER,
966 (Object **)&bus->hotplug_handler,
967 object_property_allow_set_link,
968 OBJ_PROP_LINK_UNREF_ON_RELEASE,
969 NULL);
970 object_property_add_bool(obj, "realized",
971 bus_get_realized, bus_set_realized, NULL);
972 }
973
974 static char *default_bus_get_fw_dev_path(DeviceState *dev)
975 {
976 return g_strdup(object_get_typename(OBJECT(dev)));
977 }
978
979 static void bus_class_init(ObjectClass *class, void *data)
980 {
981 BusClass *bc = BUS_CLASS(class);
982
983 class->unparent = bus_unparent;
984 bc->get_fw_dev_path = default_bus_get_fw_dev_path;
985 }
986
987 static void qbus_finalize(Object *obj)
988 {
989 BusState *bus = BUS(obj);
990
991 g_free((char *)bus->name);
992 }
993
994 static const TypeInfo bus_info = {
995 .name = TYPE_BUS,
996 .parent = TYPE_OBJECT,
997 .instance_size = sizeof(BusState),
998 .abstract = true,
999 .class_size = sizeof(BusClass),
1000 .instance_init = qbus_initfn,
1001 .instance_finalize = qbus_finalize,
1002 .class_init = bus_class_init,
1003 };
1004
1005 static void qdev_register_types(void)
1006 {
1007 type_register_static(&bus_info);
1008 type_register_static(&device_type_info);
1009 }
1010
1011 type_init(qdev_register_types)