xref: /openbmc/qemu/hw/core/qdev.c (revision db57fef1)
1  /*
2   *  Dynamic device configuration and creation.
3   *
4   *  Copyright (c) 2009 CodeSourcery
5   *
6   * This library is free software; you can redistribute it and/or
7   * modify it under the terms of the GNU Lesser General Public
8   * License as published by the Free Software Foundation; either
9   * version 2 of the License, or (at your option) any later version.
10   *
11   * This library is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14   * Lesser General Public License for more details.
15   *
16   * You should have received a copy of the GNU Lesser General Public
17   * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18   */
19  
20  /* The theory here is that it should be possible to create a machine without
21     knowledge of specific devices.  Historically board init routines have
22     passed a bunch of arguments to each device, requiring the board know
23     exactly which device it is dealing with.  This file provides an abstract
24     API for device configuration and initialization.  Devices will generally
25     inherit from a particular bus (e.g. PCI or I2C) rather than
26     this API directly.  */
27  
28  #include "qemu/osdep.h"
29  #include "qapi/error.h"
30  #include "qapi/qapi-events-qdev.h"
31  #include "qapi/qmp/qerror.h"
32  #include "qapi/visitor.h"
33  #include "qemu/error-report.h"
34  #include "qemu/option.h"
35  #include "hw/hotplug.h"
36  #include "hw/irq.h"
37  #include "hw/qdev-properties.h"
38  #include "hw/boards.h"
39  #include "hw/sysbus.h"
40  #include "hw/qdev-clock.h"
41  #include "migration/vmstate.h"
42  #include "trace.h"
43  
44  bool qdev_hotplug = false;
45  static bool qdev_hot_added = false;
46  bool qdev_hot_removed = false;
47  
48  const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
49  {
50      DeviceClass *dc = DEVICE_GET_CLASS(dev);
51      return dc->vmsd;
52  }
53  
54  static void bus_remove_child(BusState *bus, DeviceState *child)
55  {
56      BusChild *kid;
57  
58      QTAILQ_FOREACH(kid, &bus->children, sibling) {
59          if (kid->child == child) {
60              char name[32];
61  
62              snprintf(name, sizeof(name), "child[%d]", kid->index);
63              QTAILQ_REMOVE(&bus->children, kid, sibling);
64  
65              bus->num_children--;
66  
67              /* This gives back ownership of kid->child back to us.  */
68              object_property_del(OBJECT(bus), name);
69              object_unref(OBJECT(kid->child));
70              g_free(kid);
71              return;
72          }
73      }
74  }
75  
76  static void bus_add_child(BusState *bus, DeviceState *child)
77  {
78      char name[32];
79      BusChild *kid = g_malloc0(sizeof(*kid));
80  
81      bus->num_children++;
82      kid->index = bus->max_index++;
83      kid->child = child;
84      object_ref(OBJECT(kid->child));
85  
86      QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
87  
88      /* This transfers ownership of kid->child to the property.  */
89      snprintf(name, sizeof(name), "child[%d]", kid->index);
90      object_property_add_link(OBJECT(bus), name,
91                               object_get_typename(OBJECT(child)),
92                               (Object **)&kid->child,
93                               NULL, /* read-only property */
94                               0);
95  }
96  
97  void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
98  {
99      BusState *old_parent_bus = dev->parent_bus;
100      DeviceClass *dc = DEVICE_GET_CLASS(dev);
101  
102      assert(dc->bus_type && object_dynamic_cast(OBJECT(bus), dc->bus_type));
103  
104      if (old_parent_bus) {
105          trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)),
106              old_parent_bus, object_get_typename(OBJECT(old_parent_bus)),
107              OBJECT(bus), object_get_typename(OBJECT(bus)));
108          /*
109           * Keep a reference to the device while it's not plugged into
110           * any bus, to avoid it potentially evaporating when it is
111           * dereffed in bus_remove_child().
112           * Also keep the ref of the parent bus until the end, so that
113           * we can safely call resettable_change_parent() below.
114           */
115          object_ref(OBJECT(dev));
116          bus_remove_child(dev->parent_bus, dev);
117      }
118      dev->parent_bus = bus;
119      object_ref(OBJECT(bus));
120      bus_add_child(bus, dev);
121      if (dev->realized) {
122          resettable_change_parent(OBJECT(dev), OBJECT(bus),
123                                   OBJECT(old_parent_bus));
124      }
125      if (old_parent_bus) {
126          object_unref(OBJECT(old_parent_bus));
127          object_unref(OBJECT(dev));
128      }
129  }
130  
131  /*
132   * Create a device on the heap.
133   * A type @name must exist.
134   * This only initializes the device state structure and allows
135   * properties to be set.  The device still needs to be realized.  See
136   * qdev-core.h.
137   */
138  DeviceState *qdev_new(const char *name)
139  {
140      if (!object_class_by_name(name)) {
141          module_load_qom_one(name);
142      }
143      return DEVICE(object_new(name));
144  }
145  
146  /*
147   * Try to create a device on the heap.
148   * This is like qdev_new(), except it returns %NULL when type @name
149   * does not exist.
150   */
151  DeviceState *qdev_try_new(const char *name)
152  {
153      if (!module_object_class_by_name(name)) {
154          return NULL;
155      }
156      return DEVICE(object_new(name));
157  }
158  
159  static QTAILQ_HEAD(, DeviceListener) device_listeners
160      = QTAILQ_HEAD_INITIALIZER(device_listeners);
161  
162  enum ListenerDirection { Forward, Reverse };
163  
164  #define DEVICE_LISTENER_CALL(_callback, _direction, _args...)     \
165      do {                                                          \
166          DeviceListener *_listener;                                \
167                                                                    \
168          switch (_direction) {                                     \
169          case Forward:                                             \
170              QTAILQ_FOREACH(_listener, &device_listeners, link) {  \
171                  if (_listener->_callback) {                       \
172                      _listener->_callback(_listener, ##_args);     \
173                  }                                                 \
174              }                                                     \
175              break;                                                \
176          case Reverse:                                             \
177              QTAILQ_FOREACH_REVERSE(_listener, &device_listeners,  \
178                                     link) {                        \
179                  if (_listener->_callback) {                       \
180                      _listener->_callback(_listener, ##_args);     \
181                  }                                                 \
182              }                                                     \
183              break;                                                \
184          default:                                                  \
185              abort();                                              \
186          }                                                         \
187      } while (0)
188  
189  static int device_listener_add(DeviceState *dev, void *opaque)
190  {
191      DEVICE_LISTENER_CALL(realize, Forward, dev);
192  
193      return 0;
194  }
195  
196  void device_listener_register(DeviceListener *listener)
197  {
198      QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
199  
200      qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
201                         NULL, NULL);
202  }
203  
204  void device_listener_unregister(DeviceListener *listener)
205  {
206      QTAILQ_REMOVE(&device_listeners, listener, link);
207  }
208  
209  bool qdev_should_hide_device(QemuOpts *opts)
210  {
211      int rc = -1;
212      DeviceListener *listener;
213  
214      QTAILQ_FOREACH(listener, &device_listeners, link) {
215         if (listener->should_be_hidden) {
216              /*
217               * should_be_hidden_will return
218               *  1 if device matches opts and it should be hidden
219               *  0 if device matches opts and should not be hidden
220               *  -1 if device doesn't match ops
221               */
222              rc = listener->should_be_hidden(listener, opts);
223          }
224  
225          if (rc > 0) {
226              break;
227          }
228      }
229  
230      return rc > 0;
231  }
232  
233  void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
234                                   int required_for_version)
235  {
236      assert(!dev->realized);
237      dev->instance_id_alias = alias_id;
238      dev->alias_required_for_version = required_for_version;
239  }
240  
241  HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev)
242  {
243      MachineState *machine;
244      MachineClass *mc;
245      Object *m_obj = qdev_get_machine();
246  
247      if (object_dynamic_cast(m_obj, TYPE_MACHINE)) {
248          machine = MACHINE(m_obj);
249          mc = MACHINE_GET_CLASS(machine);
250          if (mc->get_hotplug_handler) {
251              return mc->get_hotplug_handler(machine, dev);
252          }
253      }
254  
255      return NULL;
256  }
257  
258  bool qdev_hotplug_allowed(DeviceState *dev, Error **errp)
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->hotplug_allowed) {
268              return mc->hotplug_allowed(machine, dev, errp);
269          }
270      }
271  
272      return true;
273  }
274  
275  HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev)
276  {
277      if (dev->parent_bus) {
278          return dev->parent_bus->hotplug_handler;
279      }
280      return NULL;
281  }
282  
283  HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
284  {
285      HotplugHandler *hotplug_ctrl = qdev_get_machine_hotplug_handler(dev);
286  
287      if (hotplug_ctrl == NULL && dev->parent_bus) {
288          hotplug_ctrl = qdev_get_bus_hotplug_handler(dev);
289      }
290      return hotplug_ctrl;
291  }
292  
293  static int qdev_prereset(DeviceState *dev, void *opaque)
294  {
295      trace_qdev_reset_tree(dev, object_get_typename(OBJECT(dev)));
296      return 0;
297  }
298  
299  static int qbus_prereset(BusState *bus, void *opaque)
300  {
301      trace_qbus_reset_tree(bus, object_get_typename(OBJECT(bus)));
302      return 0;
303  }
304  
305  static int qdev_reset_one(DeviceState *dev, void *opaque)
306  {
307      device_legacy_reset(dev);
308  
309      return 0;
310  }
311  
312  static int qbus_reset_one(BusState *bus, void *opaque)
313  {
314      BusClass *bc = BUS_GET_CLASS(bus);
315      trace_qbus_reset(bus, object_get_typename(OBJECT(bus)));
316      if (bc->reset) {
317          bc->reset(bus);
318      }
319      return 0;
320  }
321  
322  void qdev_reset_all(DeviceState *dev)
323  {
324      trace_qdev_reset_all(dev, object_get_typename(OBJECT(dev)));
325      qdev_walk_children(dev, qdev_prereset, qbus_prereset,
326                         qdev_reset_one, qbus_reset_one, NULL);
327  }
328  
329  void qdev_reset_all_fn(void *opaque)
330  {
331      qdev_reset_all(DEVICE(opaque));
332  }
333  
334  void qbus_reset_all(BusState *bus)
335  {
336      trace_qbus_reset_all(bus, object_get_typename(OBJECT(bus)));
337      qbus_walk_children(bus, qdev_prereset, qbus_prereset,
338                         qdev_reset_one, qbus_reset_one, NULL);
339  }
340  
341  void qbus_reset_all_fn(void *opaque)
342  {
343      BusState *bus = opaque;
344      qbus_reset_all(bus);
345  }
346  
347  void device_cold_reset(DeviceState *dev)
348  {
349      resettable_reset(OBJECT(dev), RESET_TYPE_COLD);
350  }
351  
352  bool device_is_in_reset(DeviceState *dev)
353  {
354      return resettable_is_in_reset(OBJECT(dev));
355  }
356  
357  static ResettableState *device_get_reset_state(Object *obj)
358  {
359      DeviceState *dev = DEVICE(obj);
360      return &dev->reset;
361  }
362  
363  static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb,
364                                         void *opaque, ResetType type)
365  {
366      DeviceState *dev = DEVICE(obj);
367      BusState *bus;
368  
369      QLIST_FOREACH(bus, &dev->child_bus, sibling) {
370          cb(OBJECT(bus), opaque, type);
371      }
372  }
373  
374  /* can be used as ->unplug() callback for the simple cases */
375  void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
376                                    DeviceState *dev, Error **errp)
377  {
378      qdev_unrealize(dev);
379  }
380  
381  /*
382   * Realize @dev.
383   * @dev must not be plugged into a bus.
384   * If @bus, plug @dev into @bus.  This takes a reference to @dev.
385   * If @dev has no QOM parent, make one up, taking another reference.
386   * On success, return true.
387   * On failure, store an error through @errp and return false.
388   */
389  bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp)
390  {
391      assert(!dev->realized && !dev->parent_bus);
392  
393      if (bus) {
394          qdev_set_parent_bus(dev, bus);
395      } else {
396          assert(!DEVICE_GET_CLASS(dev)->bus_type);
397      }
398  
399      return object_property_set_bool(OBJECT(dev), "realized", true, errp);
400  }
401  
402  /*
403   * Realize @dev and drop a reference.
404   * This is like qdev_realize(), except the caller must hold a
405   * (private) reference, which is dropped on return regardless of
406   * success or failure.  Intended use:
407   *     dev = qdev_new();
408   *     [...]
409   *     qdev_realize_and_unref(dev, bus, errp);
410   * Now @dev can go away without further ado.
411   */
412  bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp)
413  {
414      bool ret;
415  
416      ret = qdev_realize(dev, bus, errp);
417      object_unref(OBJECT(dev));
418      return ret;
419  }
420  
421  void qdev_unrealize(DeviceState *dev)
422  {
423      object_property_set_bool(OBJECT(dev), "realized", false, &error_abort);
424  }
425  
426  static int qdev_assert_realized_properly(Object *obj, void *opaque)
427  {
428      DeviceState *dev = DEVICE(object_dynamic_cast(obj, TYPE_DEVICE));
429      DeviceClass *dc;
430  
431      if (dev) {
432          dc = DEVICE_GET_CLASS(dev);
433          assert(dev->realized);
434          assert(dev->parent_bus || !dc->bus_type);
435      }
436      return 0;
437  }
438  
439  void qdev_machine_creation_done(void)
440  {
441      /*
442       * ok, initial machine setup is done, starting from now we can
443       * only create hotpluggable devices
444       */
445      qdev_hotplug = true;
446  
447      object_child_foreach_recursive(object_get_root(),
448                                     qdev_assert_realized_properly, NULL);
449  }
450  
451  bool qdev_machine_modified(void)
452  {
453      return qdev_hot_added || qdev_hot_removed;
454  }
455  
456  BusState *qdev_get_parent_bus(DeviceState *dev)
457  {
458      return dev->parent_bus;
459  }
460  
461  static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
462                                                 const char *name)
463  {
464      NamedGPIOList *ngl;
465  
466      QLIST_FOREACH(ngl, &dev->gpios, node) {
467          /* NULL is a valid and matchable name. */
468          if (g_strcmp0(name, ngl->name) == 0) {
469              return ngl;
470          }
471      }
472  
473      ngl = g_malloc0(sizeof(*ngl));
474      ngl->name = g_strdup(name);
475      QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
476      return ngl;
477  }
478  
479  void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
480                                           qemu_irq_handler handler,
481                                           void *opaque,
482                                           const char *name, int n)
483  {
484      int i;
485      NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
486  
487      assert(gpio_list->num_out == 0 || !name);
488      gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
489                                       opaque, n);
490  
491      if (!name) {
492          name = "unnamed-gpio-in";
493      }
494      for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
495          gchar *propname = g_strdup_printf("%s[%u]", name, i);
496  
497          object_property_add_child(OBJECT(dev), propname,
498                                    OBJECT(gpio_list->in[i]));
499          g_free(propname);
500      }
501  
502      gpio_list->num_in += n;
503  }
504  
505  void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
506  {
507      qdev_init_gpio_in_named(dev, handler, NULL, n);
508  }
509  
510  void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
511                                const char *name, int n)
512  {
513      int i;
514      NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
515  
516      assert(gpio_list->num_in == 0 || !name);
517  
518      if (!name) {
519          name = "unnamed-gpio-out";
520      }
521      memset(pins, 0, sizeof(*pins) * n);
522      for (i = 0; i < n; ++i) {
523          gchar *propname = g_strdup_printf("%s[%u]", name,
524                                            gpio_list->num_out + i);
525  
526          object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
527                                   (Object **)&pins[i],
528                                   object_property_allow_set_link,
529                                   OBJ_PROP_LINK_STRONG);
530          g_free(propname);
531      }
532      gpio_list->num_out += n;
533  }
534  
535  void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
536  {
537      qdev_init_gpio_out_named(dev, pins, NULL, n);
538  }
539  
540  qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
541  {
542      NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
543  
544      assert(n >= 0 && n < gpio_list->num_in);
545      return gpio_list->in[n];
546  }
547  
548  qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
549  {
550      return qdev_get_gpio_in_named(dev, NULL, n);
551  }
552  
553  void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
554                                   qemu_irq pin)
555  {
556      char *propname = g_strdup_printf("%s[%d]",
557                                       name ? name : "unnamed-gpio-out", n);
558      if (pin && !OBJECT(pin)->parent) {
559          /* We need a name for object_property_set_link to work */
560          object_property_add_child(container_get(qdev_get_machine(),
561                                                  "/unattached"),
562                                    "non-qdev-gpio[*]", OBJECT(pin));
563      }
564      object_property_set_link(OBJECT(dev), propname, OBJECT(pin), &error_abort);
565      g_free(propname);
566  }
567  
568  qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
569  {
570      g_autofree char *propname = g_strdup_printf("%s[%d]",
571                                       name ? name : "unnamed-gpio-out", n);
572  
573      qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
574                                                        NULL);
575  
576      return ret;
577  }
578  
579  /* disconnect a GPIO output, returning the disconnected input (if any) */
580  
581  static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
582                                                 const char *name, int n)
583  {
584      char *propname = g_strdup_printf("%s[%d]",
585                                       name ? name : "unnamed-gpio-out", n);
586  
587      qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
588                                                        NULL);
589      if (ret) {
590          object_property_set_link(OBJECT(dev), propname, NULL, NULL);
591      }
592      g_free(propname);
593      return ret;
594  }
595  
596  qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
597                                   const char *name, int n)
598  {
599      qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
600      qdev_connect_gpio_out_named(dev, name, n, icpt);
601      return disconnected;
602  }
603  
604  void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
605  {
606      qdev_connect_gpio_out_named(dev, NULL, n, pin);
607  }
608  
609  void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
610                       const char *name)
611  {
612      int i;
613      NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
614  
615      for (i = 0; i < ngl->num_in; i++) {
616          const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
617          char *propname = g_strdup_printf("%s[%d]", nm, i);
618  
619          object_property_add_alias(OBJECT(container), propname,
620                                    OBJECT(dev), propname);
621          g_free(propname);
622      }
623      for (i = 0; i < ngl->num_out; i++) {
624          const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
625          char *propname = g_strdup_printf("%s[%d]", nm, i);
626  
627          object_property_add_alias(OBJECT(container), propname,
628                                    OBJECT(dev), propname);
629          g_free(propname);
630      }
631      QLIST_REMOVE(ngl, node);
632      QLIST_INSERT_HEAD(&container->gpios, ngl, node);
633  }
634  
635  BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
636  {
637      BusState *bus;
638      Object *child = object_resolve_path_component(OBJECT(dev), name);
639  
640      bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
641      if (bus) {
642          return bus;
643      }
644  
645      QLIST_FOREACH(bus, &dev->child_bus, sibling) {
646          if (strcmp(name, bus->name) == 0) {
647              return bus;
648          }
649      }
650      return NULL;
651  }
652  
653  int qdev_walk_children(DeviceState *dev,
654                         qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
655                         qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
656                         void *opaque)
657  {
658      BusState *bus;
659      int err;
660  
661      if (pre_devfn) {
662          err = pre_devfn(dev, opaque);
663          if (err) {
664              return err;
665          }
666      }
667  
668      QLIST_FOREACH(bus, &dev->child_bus, sibling) {
669          err = qbus_walk_children(bus, pre_devfn, pre_busfn,
670                                   post_devfn, post_busfn, opaque);
671          if (err < 0) {
672              return err;
673          }
674      }
675  
676      if (post_devfn) {
677          err = post_devfn(dev, opaque);
678          if (err) {
679              return err;
680          }
681      }
682  
683      return 0;
684  }
685  
686  DeviceState *qdev_find_recursive(BusState *bus, const char *id)
687  {
688      BusChild *kid;
689      DeviceState *ret;
690      BusState *child;
691  
692      QTAILQ_FOREACH(kid, &bus->children, sibling) {
693          DeviceState *dev = kid->child;
694  
695          if (dev->id && strcmp(dev->id, id) == 0) {
696              return dev;
697          }
698  
699          QLIST_FOREACH(child, &dev->child_bus, sibling) {
700              ret = qdev_find_recursive(child, id);
701              if (ret) {
702                  return ret;
703              }
704          }
705      }
706      return NULL;
707  }
708  
709  char *qdev_get_dev_path(DeviceState *dev)
710  {
711      BusClass *bc;
712  
713      if (!dev || !dev->parent_bus) {
714          return NULL;
715      }
716  
717      bc = BUS_GET_CLASS(dev->parent_bus);
718      if (bc->get_dev_path) {
719          return bc->get_dev_path(dev);
720      }
721  
722      return NULL;
723  }
724  
725  /**
726   * Legacy property handling
727   */
728  
729  static void qdev_get_legacy_property(Object *obj, Visitor *v,
730                                       const char *name, void *opaque,
731                                       Error **errp)
732  {
733      DeviceState *dev = DEVICE(obj);
734      Property *prop = opaque;
735  
736      char buffer[1024];
737      char *ptr = buffer;
738  
739      prop->info->print(dev, prop, buffer, sizeof(buffer));
740      visit_type_str(v, name, &ptr, errp);
741  }
742  
743  /**
744   * qdev_class_add_legacy_property:
745   * @dev: Device to add the property to.
746   * @prop: The qdev property definition.
747   *
748   * Add a legacy QOM property to @dev for qdev property @prop.
749   *
750   * Legacy properties are string versions of QOM properties.  The format of
751   * the string depends on the property type.  Legacy properties are only
752   * needed for "info qtree".
753   *
754   * Do not use this in new code!  QOM Properties added through this interface
755   * will be given names in the "legacy" namespace.
756   */
757  static void qdev_class_add_legacy_property(DeviceClass *dc, Property *prop)
758  {
759      g_autofree char *name = NULL;
760  
761      /* Register pointer properties as legacy properties */
762      if (!prop->info->print && prop->info->get) {
763          return;
764      }
765  
766      name = g_strdup_printf("legacy-%s", prop->name);
767      object_class_property_add(OBJECT_CLASS(dc), name, "str",
768          prop->info->print ? qdev_get_legacy_property : prop->info->get,
769          NULL, NULL, prop);
770  }
771  
772  void qdev_property_add_static(DeviceState *dev, Property *prop)
773  {
774      Object *obj = OBJECT(dev);
775      ObjectProperty *op;
776  
777      assert(!prop->info->create);
778  
779      op = object_property_add(obj, prop->name, prop->info->name,
780                               prop->info->get, prop->info->set,
781                               prop->info->release,
782                               prop);
783  
784      object_property_set_description(obj, prop->name,
785                                      prop->info->description);
786  
787      if (prop->set_default) {
788          prop->info->set_default_value(op, prop);
789          if (op->init) {
790              op->init(obj, op);
791          }
792      }
793  }
794  
795  static void qdev_class_add_property(DeviceClass *klass, Property *prop)
796  {
797      ObjectClass *oc = OBJECT_CLASS(klass);
798  
799      if (prop->info->create) {
800          prop->info->create(oc, prop);
801      } else {
802          ObjectProperty *op;
803  
804          op = object_class_property_add(oc,
805                                         prop->name, prop->info->name,
806                                         prop->info->get, prop->info->set,
807                                         prop->info->release,
808                                         prop);
809          if (prop->set_default) {
810              prop->info->set_default_value(op, prop);
811          }
812      }
813      object_class_property_set_description(oc, prop->name,
814                                            prop->info->description);
815  }
816  
817  /* @qdev_alias_all_properties - Add alias properties to the source object for
818   * all qdev properties on the target DeviceState.
819   */
820  void qdev_alias_all_properties(DeviceState *target, Object *source)
821  {
822      ObjectClass *class;
823      Property *prop;
824  
825      class = object_get_class(OBJECT(target));
826      do {
827          DeviceClass *dc = DEVICE_CLASS(class);
828  
829          for (prop = dc->props_; prop && prop->name; prop++) {
830              object_property_add_alias(source, prop->name,
831                                        OBJECT(target), prop->name);
832          }
833          class = object_class_get_parent(class);
834      } while (class != object_class_by_name(TYPE_DEVICE));
835  }
836  
837  static bool device_get_realized(Object *obj, Error **errp)
838  {
839      DeviceState *dev = DEVICE(obj);
840      return dev->realized;
841  }
842  
843  static bool check_only_migratable(Object *obj, Error **errp)
844  {
845      DeviceClass *dc = DEVICE_GET_CLASS(obj);
846  
847      if (!vmstate_check_only_migratable(dc->vmsd)) {
848          error_setg(errp, "Device %s is not migratable, but "
849                     "--only-migratable was specified",
850                     object_get_typename(obj));
851          return false;
852      }
853  
854      return true;
855  }
856  
857  static void device_set_realized(Object *obj, bool value, Error **errp)
858  {
859      DeviceState *dev = DEVICE(obj);
860      DeviceClass *dc = DEVICE_GET_CLASS(dev);
861      HotplugHandler *hotplug_ctrl;
862      BusState *bus;
863      NamedClockList *ncl;
864      Error *local_err = NULL;
865      bool unattached_parent = false;
866      static int unattached_count;
867  
868      if (dev->hotplugged && !dc->hotpluggable) {
869          error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
870          return;
871      }
872  
873      if (value && !dev->realized) {
874          if (!check_only_migratable(obj, errp)) {
875              goto fail;
876          }
877  
878          if (!obj->parent) {
879              gchar *name = g_strdup_printf("device[%d]", unattached_count++);
880  
881              object_property_add_child(container_get(qdev_get_machine(),
882                                                      "/unattached"),
883                                        name, obj);
884              unattached_parent = true;
885              g_free(name);
886          }
887  
888          hotplug_ctrl = qdev_get_hotplug_handler(dev);
889          if (hotplug_ctrl) {
890              hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
891              if (local_err != NULL) {
892                  goto fail;
893              }
894          }
895  
896          if (dc->realize) {
897              dc->realize(dev, &local_err);
898              if (local_err != NULL) {
899                  goto fail;
900              }
901          }
902  
903          DEVICE_LISTENER_CALL(realize, Forward, dev);
904  
905          /*
906           * always free/re-initialize here since the value cannot be cleaned up
907           * in device_unrealize due to its usage later on in the unplug path
908           */
909          g_free(dev->canonical_path);
910          dev->canonical_path = object_get_canonical_path(OBJECT(dev));
911          QLIST_FOREACH(ncl, &dev->clocks, node) {
912              if (ncl->alias) {
913                  continue;
914              } else {
915                  clock_setup_canonical_path(ncl->clock);
916              }
917          }
918  
919          if (qdev_get_vmsd(dev)) {
920              if (vmstate_register_with_alias_id(VMSTATE_IF(dev),
921                                                 VMSTATE_INSTANCE_ID_ANY,
922                                                 qdev_get_vmsd(dev), dev,
923                                                 dev->instance_id_alias,
924                                                 dev->alias_required_for_version,
925                                                 &local_err) < 0) {
926                  goto post_realize_fail;
927              }
928          }
929  
930          /*
931           * Clear the reset state, in case the object was previously unrealized
932           * with a dirty state.
933           */
934          resettable_state_clear(&dev->reset);
935  
936          QLIST_FOREACH(bus, &dev->child_bus, sibling) {
937              if (!qbus_realize(bus, errp)) {
938                  goto child_realize_fail;
939              }
940          }
941          if (dev->hotplugged) {
942              /*
943               * Reset the device, as well as its subtree which, at this point,
944               * should be realized too.
945               */
946              resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD);
947              resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus),
948                                       NULL);
949              resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD);
950          }
951          dev->pending_deleted_event = false;
952  
953          if (hotplug_ctrl) {
954              hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
955              if (local_err != NULL) {
956                  goto child_realize_fail;
957              }
958         }
959  
960      } else if (!value && dev->realized) {
961          QLIST_FOREACH(bus, &dev->child_bus, sibling) {
962              qbus_unrealize(bus);
963          }
964          if (qdev_get_vmsd(dev)) {
965              vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
966          }
967          if (dc->unrealize) {
968              dc->unrealize(dev);
969          }
970          dev->pending_deleted_event = true;
971          DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
972      }
973  
974      assert(local_err == NULL);
975      dev->realized = value;
976      return;
977  
978  child_realize_fail:
979      QLIST_FOREACH(bus, &dev->child_bus, sibling) {
980          qbus_unrealize(bus);
981      }
982  
983      if (qdev_get_vmsd(dev)) {
984          vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
985      }
986  
987  post_realize_fail:
988      g_free(dev->canonical_path);
989      dev->canonical_path = NULL;
990      if (dc->unrealize) {
991          dc->unrealize(dev);
992      }
993  
994  fail:
995      error_propagate(errp, local_err);
996      if (unattached_parent) {
997          /*
998           * Beware, this doesn't just revert
999           * object_property_add_child(), it also runs bus_remove()!
1000           */
1001          object_unparent(OBJECT(dev));
1002          unattached_count--;
1003      }
1004  }
1005  
1006  static bool device_get_hotpluggable(Object *obj, Error **errp)
1007  {
1008      DeviceClass *dc = DEVICE_GET_CLASS(obj);
1009      DeviceState *dev = DEVICE(obj);
1010  
1011      return dc->hotpluggable && (dev->parent_bus == NULL ||
1012                                  qbus_is_hotpluggable(dev->parent_bus));
1013  }
1014  
1015  static bool device_get_hotplugged(Object *obj, Error **errp)
1016  {
1017      DeviceState *dev = DEVICE(obj);
1018  
1019      return dev->hotplugged;
1020  }
1021  
1022  static void device_initfn(Object *obj)
1023  {
1024      DeviceState *dev = DEVICE(obj);
1025  
1026      if (qdev_hotplug) {
1027          dev->hotplugged = 1;
1028          qdev_hot_added = true;
1029      }
1030  
1031      dev->instance_id_alias = -1;
1032      dev->realized = false;
1033      dev->allow_unplug_during_migration = false;
1034  
1035      QLIST_INIT(&dev->gpios);
1036      QLIST_INIT(&dev->clocks);
1037  }
1038  
1039  static void device_post_init(Object *obj)
1040  {
1041      /*
1042       * Note: ordered so that the user's global properties take
1043       * precedence.
1044       */
1045      object_apply_compat_props(obj);
1046      qdev_prop_set_globals(DEVICE(obj));
1047  }
1048  
1049  /* Unlink device from bus and free the structure.  */
1050  static void device_finalize(Object *obj)
1051  {
1052      NamedGPIOList *ngl, *next;
1053  
1054      DeviceState *dev = DEVICE(obj);
1055  
1056      QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1057          QLIST_REMOVE(ngl, node);
1058          qemu_free_irqs(ngl->in, ngl->num_in);
1059          g_free(ngl->name);
1060          g_free(ngl);
1061          /* ngl->out irqs are owned by the other end and should not be freed
1062           * here
1063           */
1064      }
1065  
1066      qdev_finalize_clocklist(dev);
1067  
1068      /* Only send event if the device had been completely realized */
1069      if (dev->pending_deleted_event) {
1070          g_assert(dev->canonical_path);
1071  
1072          qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path);
1073          g_free(dev->canonical_path);
1074          dev->canonical_path = NULL;
1075      }
1076  
1077      qemu_opts_del(dev->opts);
1078  }
1079  
1080  static void device_class_base_init(ObjectClass *class, void *data)
1081  {
1082      DeviceClass *klass = DEVICE_CLASS(class);
1083  
1084      /* We explicitly look up properties in the superclasses,
1085       * so do not propagate them to the subclasses.
1086       */
1087      klass->props_ = NULL;
1088  }
1089  
1090  static void device_unparent(Object *obj)
1091  {
1092      DeviceState *dev = DEVICE(obj);
1093      BusState *bus;
1094  
1095      if (dev->realized) {
1096          qdev_unrealize(dev);
1097      }
1098      while (dev->num_child_bus) {
1099          bus = QLIST_FIRST(&dev->child_bus);
1100          object_unparent(OBJECT(bus));
1101      }
1102      if (dev->parent_bus) {
1103          bus_remove_child(dev->parent_bus, dev);
1104          object_unref(OBJECT(dev->parent_bus));
1105          dev->parent_bus = NULL;
1106      }
1107  }
1108  
1109  static char *
1110  device_vmstate_if_get_id(VMStateIf *obj)
1111  {
1112      DeviceState *dev = DEVICE(obj);
1113  
1114      return qdev_get_dev_path(dev);
1115  }
1116  
1117  /**
1118   * device_phases_reset:
1119   * Transition reset method for devices to allow moving
1120   * smoothly from legacy reset method to multi-phases
1121   */
1122  static void device_phases_reset(DeviceState *dev)
1123  {
1124      ResettableClass *rc = RESETTABLE_GET_CLASS(dev);
1125  
1126      if (rc->phases.enter) {
1127          rc->phases.enter(OBJECT(dev), RESET_TYPE_COLD);
1128      }
1129      if (rc->phases.hold) {
1130          rc->phases.hold(OBJECT(dev));
1131      }
1132      if (rc->phases.exit) {
1133          rc->phases.exit(OBJECT(dev));
1134      }
1135  }
1136  
1137  static void device_transitional_reset(Object *obj)
1138  {
1139      DeviceClass *dc = DEVICE_GET_CLASS(obj);
1140  
1141      /*
1142       * This will call either @device_phases_reset (for multi-phases transitioned
1143       * devices) or a device's specific method for not-yet transitioned devices.
1144       * In both case, it does not reset children.
1145       */
1146      if (dc->reset) {
1147          dc->reset(DEVICE(obj));
1148      }
1149  }
1150  
1151  /**
1152   * device_get_transitional_reset:
1153   * check if the device's class is ready for multi-phase
1154   */
1155  static ResettableTrFunction device_get_transitional_reset(Object *obj)
1156  {
1157      DeviceClass *dc = DEVICE_GET_CLASS(obj);
1158      if (dc->reset != device_phases_reset) {
1159          /*
1160           * dc->reset has been overridden by a subclass,
1161           * the device is not ready for multi phase yet.
1162           */
1163          return device_transitional_reset;
1164      }
1165      return NULL;
1166  }
1167  
1168  static void device_class_init(ObjectClass *class, void *data)
1169  {
1170      DeviceClass *dc = DEVICE_CLASS(class);
1171      VMStateIfClass *vc = VMSTATE_IF_CLASS(class);
1172      ResettableClass *rc = RESETTABLE_CLASS(class);
1173  
1174      class->unparent = device_unparent;
1175  
1176      /* by default all devices were considered as hotpluggable,
1177       * so with intent to check it in generic qdev_unplug() /
1178       * device_set_realized() functions make every device
1179       * hotpluggable. Devices that shouldn't be hotpluggable,
1180       * should override it in their class_init()
1181       */
1182      dc->hotpluggable = true;
1183      dc->user_creatable = true;
1184      vc->get_id = device_vmstate_if_get_id;
1185      rc->get_state = device_get_reset_state;
1186      rc->child_foreach = device_reset_child_foreach;
1187  
1188      /*
1189       * @device_phases_reset is put as the default reset method below, allowing
1190       * to do the multi-phase transition from base classes to leaf classes. It
1191       * allows a legacy-reset Device class to extend a multi-phases-reset
1192       * Device class for the following reason:
1193       * + If a base class B has been moved to multi-phase, then it does not
1194       *   override this default reset method and may have defined phase methods.
1195       * + A child class C (extending class B) which uses
1196       *   device_class_set_parent_reset() (or similar means) to override the
1197       *   reset method will still work as expected. @device_phases_reset function
1198       *   will be registered as the parent reset method and effectively call
1199       *   parent reset phases.
1200       */
1201      dc->reset = device_phases_reset;
1202      rc->get_transitional_function = device_get_transitional_reset;
1203  
1204      object_class_property_add_bool(class, "realized",
1205                                     device_get_realized, device_set_realized);
1206      object_class_property_add_bool(class, "hotpluggable",
1207                                     device_get_hotpluggable, NULL);
1208      object_class_property_add_bool(class, "hotplugged",
1209                                     device_get_hotplugged, NULL);
1210      object_class_property_add_link(class, "parent_bus", TYPE_BUS,
1211                                     offsetof(DeviceState, parent_bus), NULL, 0);
1212  }
1213  
1214  void device_class_set_props(DeviceClass *dc, Property *props)
1215  {
1216      Property *prop;
1217  
1218      dc->props_ = props;
1219      for (prop = props; prop && prop->name; prop++) {
1220          qdev_class_add_legacy_property(dc, prop);
1221          qdev_class_add_property(dc, prop);
1222      }
1223  }
1224  
1225  void device_class_set_parent_reset(DeviceClass *dc,
1226                                     DeviceReset dev_reset,
1227                                     DeviceReset *parent_reset)
1228  {
1229      *parent_reset = dc->reset;
1230      dc->reset = dev_reset;
1231  }
1232  
1233  void device_class_set_parent_realize(DeviceClass *dc,
1234                                       DeviceRealize dev_realize,
1235                                       DeviceRealize *parent_realize)
1236  {
1237      *parent_realize = dc->realize;
1238      dc->realize = dev_realize;
1239  }
1240  
1241  void device_class_set_parent_unrealize(DeviceClass *dc,
1242                                         DeviceUnrealize dev_unrealize,
1243                                         DeviceUnrealize *parent_unrealize)
1244  {
1245      *parent_unrealize = dc->unrealize;
1246      dc->unrealize = dev_unrealize;
1247  }
1248  
1249  void device_legacy_reset(DeviceState *dev)
1250  {
1251      DeviceClass *klass = DEVICE_GET_CLASS(dev);
1252  
1253      trace_qdev_reset(dev, object_get_typename(OBJECT(dev)));
1254      if (klass->reset) {
1255          klass->reset(dev);
1256      }
1257  }
1258  
1259  Object *qdev_get_machine(void)
1260  {
1261      static Object *dev;
1262  
1263      if (dev == NULL) {
1264          dev = container_get(object_get_root(), "/machine");
1265      }
1266  
1267      return dev;
1268  }
1269  
1270  static const TypeInfo device_type_info = {
1271      .name = TYPE_DEVICE,
1272      .parent = TYPE_OBJECT,
1273      .instance_size = sizeof(DeviceState),
1274      .instance_init = device_initfn,
1275      .instance_post_init = device_post_init,
1276      .instance_finalize = device_finalize,
1277      .class_base_init = device_class_base_init,
1278      .class_init = device_class_init,
1279      .abstract = true,
1280      .class_size = sizeof(DeviceClass),
1281      .interfaces = (InterfaceInfo[]) {
1282          { TYPE_VMSTATE_IF },
1283          { TYPE_RESETTABLE_INTERFACE },
1284          { }
1285      }
1286  };
1287  
1288  static void qdev_register_types(void)
1289  {
1290      type_register_static(&device_type_info);
1291  }
1292  
1293  type_init(qdev_register_types)
1294