QEMU源码全解析 —— virtio（6）

于 2023-12-14 07:27:39 发布
阅读量849 收藏 6
点赞数 25
分类专栏： QEMU/KVM KVM 文章标签： QEMU KVM virtio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/134984951
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文深入探讨QEMU中virtio设备的初始化，特别是在设备具现化过程中的工作细节。通过分析`device_set_realized`函数及其调用的设备类`realize`函数，揭示virtio balloon设备在QEMU启动时如何被实例化和激活。文章还介绍了设备类的继承链关系，为理解virtio在QEMU中的实现提供了关键洞察。
摘要由CSDN通过智能技术生成

接前一篇文章：

上一回以 virtio balloon设备为例开始对于virtio设备的初始化过程进行分析，讲解了“virtio_balloon_pci_instance_init() -> virtio_instance_init_common() -> object_initialize_child_with_props() -> object_initialize_child_with_propsv() -> object_initialize（）”的过程。并指出从这一过程中可以看出来，vitrtio设备在实例创建过程中并没有做很多事情，大部分的工作都是在设备的具现化过程中做的。本回就来深入解析这一过程。

在讲解virtio balloon设备的具现化之前，先来回顾一下设备具现化所调用的函数。QEMU在main函数中会对所有的“-device”参数进行具现化（前文书讲过，实际是在main函数中的qemu_init函数中进行的），设备的具现化函数都会调用device_set_realized函数，在该函数中会调用设备类的realize函数。相关代码如下：

  • -device选项

与-device选项相对应的代码在softmmu/qdev-monitor.c中，如下所示： 

  1. QemuOptsList qemu_device_opts = {
  2.     .name = "device",
  3.     .implied_opt_name = "driver",
  4.     .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
  5.     .desc = {
  6.         /*
  7.          * no elements => accept any
  8.          * sanity checking will happen later
  9.          * when setting device properties
  10.          */
  11.         { /* end of list */ }
  12.     },
  13. };
  • device_set_realized函数

device_set_realized函数在hw/core/qdev.c中，代码如下： 

  1. static void device_set_realized(Object *obj, bool value, Error **errp)
  2. {
  3.     DeviceState *dev = DEVICE(obj);
  4.     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  5.     HotplugHandler *hotplug_ctrl;
  6.     BusState *bus;
  7.     NamedClockList *ncl;
  8.     Error *local_err = NULL;
  9.     bool unattached_parent = false;
  10.     static int unattached_count;
  11.  
  12.     if (dev->hotplugged && !dc->hotpluggable) {
  13.         error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
  14.         return;
  15.     }
  16.  
  17.     if (value && !dev->realized) {
  18.         if (!check_only_migratable(obj, errp)) {
  19.             goto fail;
  20.         }
  21.  
  22.         if (!obj->parent) {
  23.             gchar *name = g_strdup_printf("device[%d]", unattached_count++);
  24.  
  25.             object_property_add_child(container_get(qdev_get_machine(),
  26.                                                     "/unattached"),
  27.                                       name, obj);
  28.             unattached_parent = true;
  29.             g_free(name);
  30.         }
  31.  
  32.         hotplug_ctrl = qdev_get_hotplug_handler(dev);
  33.         if (hotplug_ctrl) {
  34.             hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
  35.             if (local_err != NULL) {
  36.                 goto fail;
  37.             }
  38.         }
  39.  
  40.         if (dc->realize) {
  41.             dc->realize(dev, &local_err);
  42.             if (local_err != NULL) {
  43.                 goto fail;
  44.             }
  45.         }
  46.  
  47.         DEVICE_LISTENER_CALL(realize, Forward, dev);
  48.  
  49.         /*
  50.          * always free/re-initialize here since the value cannot be cleaned up
  51.          * in device_unrealize due to its usage later on in the unplug path
  52.          */
  53.         g_free(dev->canonical_path);
  54.         dev->canonical_path = object_get_canonical_path(OBJECT(dev));
  55.         QLIST_FOREACH(ncl, &dev->clocks, node) {
  56.             if (ncl->alias) {
  57.                 continue;
  58.             } else {
  59.                 clock_setup_canonical_path(ncl->clock);
  60.             }
  61.         }
  62.  
  63.         if (qdev_get_vmsd(dev)) {
  64.             if (vmstate_register_with_alias_id(VMSTATE_IF(dev),
  65.                                                VMSTATE_INSTANCE_ID_ANY,
  66.                                                qdev_get_vmsd(dev), dev,
  67.                                                dev->instance_id_alias,
  68.                                                dev->alias_required_for_version,
  69.                                                &local_err) < 0) {
  70.                 goto post_realize_fail;
  71.             }
  72.         }
  73.  
  74.         /*
  75.          * Clear the reset state, in case the object was previously unrealized
  76.          * with a dirty state.
  77.          */
  78.         resettable_state_clear(&dev->reset);
  79.  
  80.         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
  81.             if (!qbus_realize(bus, errp)) {
  82.                 goto child_realize_fail;
  83.             }
  84.         }
  85.         if (dev->hotplugged) {
  86.             /*
  87.              * Reset the device, as well as its subtree which, at this point,
  88.              * should be realized too.
  89.              */
  90.             resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD);
  91.             resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus),
  92.                                      NULL);
  93.             resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD);
  94.         }
  95.         dev->pending_deleted_event = false;
  96.  
  97.         if (hotplug_ctrl) {
  98.             hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
  99.             if (local_err != NULL) {
  100.                 goto child_realize_fail;
  101.             }
  102.        }
  103.  
  104.        qatomic_store_release(&dev->realized, value);
  105.  
  106.     } else if (!value && dev->realized) {
  107.  
  108.         /*
  109.          * Change the value so that any concurrent users are aware
  110.          * that the device is going to be unrealized
  111.          *
  112.          * TODO: change .realized property to enum that states
  113.          * each phase of the device realization/unrealization
  114.          */
  115.  
  116.         qatomic_set(&dev->realized, value);
  117.         /*
  118.          * Ensure that concurrent users see this update prior to
  119.          * any other changes done by unrealize.
  120.          */
  121.         smp_wmb();
  122.  
  123.         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
  124.             qbus_unrealize(bus);
  125.         }
  126.         if (qdev_get_vmsd(dev)) {
  127.             vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
  128.         }
  129.         if (dc->unrealize) {
  130.             dc->unrealize(dev);
  131.         }
  132.         dev->pending_deleted_event = true;
  133.         DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
  134.     }
  135.  
  136.     assert(local_err == NULL);
  137.     return;
  138.  
  139. child_realize_fail:
  140.     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
  141.         qbus_unrealize(bus);
  142.     }
  143.  
  144.     if (qdev_get_vmsd(dev)) {
  145.         vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
  146.     }
  147.  
  148. post_realize_fail:
  149.     g_free(dev->canonical_path);
  150.     dev->canonical_path = NULL;
  151.     if (dc->unrealize) {
  152.         dc->unrealize(dev);
  153.     }
  154.  
  155. fail:
  156.     error_propagate(errp, local_err);
  157.     if (unattached_parent) {
  158.         /*
  159.          * Beware, this doesn't just revert
  160.          * object_property_add_child(), it also runs bus_remove()!
  161.          */
  162.         object_unparent(OBJECT(dev));
  163.         unattached_count--;
  164.     }
  165. }
  • 设备类的realize函数

相关代码片段： 

  1.  
  2.         if (dc->realize) {
  3.             dc->realize(dev, &local_err);
  4.             if (local_err != NULL) {
  5.                 goto fail;
  6.             }
  7.         }

设备类的realize函数最开始调用的是DeviceClass的realize函数，这个回调的默认函数是xxx_device_realize()。当然，如果是继承自Device的类，也可以重写这个函数。如PCIDeviceClass类就在其类 初始化 函数pci_device_class_init()中将DeviceClass->realize重写为了pci_qdev_realize。代码在hw/pci/pci.c中，如下所示： 

  1. static void pci_device_class_init(ObjectClass *klass, void *data)
  2. {
  3.     DeviceClass *k = DEVICE_CLASS(klass);
  4.  
  5.     k->realize = pci_qdev_realize;
  6.     k->unrealize = pci_qdev_unrealize;
  7.     k->bus_type = TYPE_PCI_BUS;
  8.     device_class_set_props(k, pci_props);
  9. }

对于PCIDeviceClass本身来说，其PCIDeviceClass->realize可以设置为pci_default_realize函数（此处只是为了更好地说明问题，新版QEMU中已无此函数）。后边继承PCIDeviceClass的类可以在自己的类初始化函数中设置其自己的realize函数。

virtio设备类的继承链关系为“DeviceClass -> PCIDeviceClass ->VirtioPCIClass”。

下一回将分析在VirtioPCIClass类还没有初始化时的realize函数。

欲知后事如何，且看下回分解。

举报

选择你想要举报的内容（必选）
  • 内容涉黄
  • 政治相关
  • 内容抄袭
  • 涉嫌广告
  • 内容侵权
  • 侮辱谩骂
  • 样式问题
  • 其他

取消

确定