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