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