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