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

已于 2024-08-20 22:15:18 修改
阅读量603 收藏 9
点赞数 10
分类专栏： QEMU/KVM 文章标签： QEMU KVM virtio
于 2023-12-17 11:45:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/135041979
版权
QEMU/KVM 专栏收录该内容
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文继续探讨QEMU源码中的virtio设备实现，重点解析virtio_device_realize函数中如何通过virtio_bus_device_plugged将virtio设备插入到virtio总线的过程。这一操作在virtio-bus.c的virtio_bus_device_plugged函数中进行，该函数调用VirtioBusClass的device_plugged回调，实际执行者为virtio_pci_device_plugged函数，定义于virtio-pci.c。后续文章将深入分析virtio_pci_device_plugged的详细工作原理。
摘要由CSDN通过智能技术生成

展开

接前一篇文章：

通过前文书（从 QEMU源码全解析 —— virtio（9） 开始）对整个流程以及各个相关函数的解析，可以看到从 virtio PCI代理设备的具现化到virtio设备的具现化过程。但前述分析还遗漏了一部分，就是virtio设备挂载到virtio总线上的行为。这个过程是在virtio_device_realize函数中通过调用virtio_bus_device_plugged函数完成的。在 QEMU源码全解析 —— virtio（11） 中提到过，有图为证：

d96a462e8eaa79f7c03c4c4871c64b09.png

virtio_bus_device_plugged函数的作用就是将virtio设备插入到virtio总线上去。其源码在hw/virtio/virtio-bus.c中，如下： 

  1. /* A VirtIODevice is being plugged */
  2. void virtio_bus_device_plugged(VirtIODevice *vdev, Error **errp)
  3. {
  4.     DeviceState *qdev = DEVICE(vdev);
  5.     BusState *qbus = BUS(qdev_get_parent_bus(qdev));
  6.     VirtioBusState *bus = VIRTIO_BUS(qbus);
  7.     VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus);
  8.     VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
  9.     bool has_iommu = virtio_host_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM);
  10.     bool vdev_has_iommu;
  11.     Error *local_err = NULL;
  12.  
  13.     DPRINTF("%s: plug device.\n", qbus->name);
  14.  
  15.     if (klass->pre_plugged != NULL) {
  16.         klass->pre_plugged(qbus->parent, &local_err);
  17.         if (local_err) {
  18.             error_propagate(errp, local_err);
  19.             return;
  20.         }
  21.     }
  22.  
  23.     /* Get the features of the plugged device. */
  24.     assert(vdc->get_features != NULL);
  25.     vdev->host_features = vdc->get_features(vdev, vdev->host_features,
  26.                                             &local_err);
  27.     if (local_err) {
  28.         error_propagate(errp, local_err);
  29.         return;
  30.     }
  31.  
  32.     if (klass->device_plugged != NULL) {
  33.         klass->device_plugged(qbus->parent, &local_err);
  34.     }
  35.     if (local_err) {
  36.         error_propagate(errp, local_err);
  37.         return;
  38.     }
  39.  
  40.     vdev->dma_as = &address_space_memory;
  41.     if (has_iommu) {
  42.         vdev_has_iommu = virtio_host_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM);
  43.         /*
  44.          * Present IOMMU_PLATFORM to the driver iff iommu_plattform=on and
  45.          * device operational. If the driver does not accept IOMMU_PLATFORM
  46.          * we fail the device.
  47.          */
  48.         virtio_add_feature(&vdev->host_features, VIRTIO_F_IOMMU_PLATFORM);
  49.         if (klass->get_dma_as) {
  50.             vdev->dma_as = klass->get_dma_as(qbus->parent);
  51.             if (!vdev_has_iommu && vdev->dma_as != &address_space_memory) {
  52.                 error_setg(errp,
  53.                        "iommu_platform=true is not supported by the device");
  54.                 return;
  55.             }
  56.         }
  57.     }
  58. }

virtio_bus_device_plugged函数主要是调用了VirtioBusClass类型的device_plugged回调函数。代码片段如下： 

  1.     VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus);
  2.     ……
  3.     if (klass->device_plugged != NULL) {
  4.         klass->device_plugged(qbus->parent, &local_err);
  5.     }
  6.     if (local_err) {
  7.         error_propagate(errp, local_err);
  8.         return;
  9.     }

device_plugged回调函数也即klass->device_plugged函数指针所指向的函数在virtio_pci_bus_class_init函数中被初始化成了virtio_pci_device_plugged函数。virtio_pci_bus_class_init函数在hw/virtio/virtio- pci .c中，代码如下： 

  1. static void virtio_pci_bus_class_init(ObjectClass *klass, void *data)
  2. {
  3.     BusClass *bus_class = BUS_CLASS(klass);
  4.     VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
  5.     bus_class->max_dev = 1;
  6.     k->notify = virtio_pci_notify;
  7.     k->save_config = virtio_pci_save_config;
  8.     k->load_config = virtio_pci_load_config;
  9.     k->save_queue = virtio_pci_save_queue;
  10.     k->load_queue = virtio_pci_load_queue;
  11.     k->save_extra_state = virtio_pci_save_extra_state;
  12.     k->load_extra_state = virtio_pci_load_extra_state;
  13.     k->has_extra_state = virtio_pci_has_extra_state;
  14.     k->query_guest_notifiers = virtio_pci_query_guest_notifiers;
  15.     k->set_guest_notifiers = virtio_pci_set_guest_notifiers;
  16.     k->set_host_notifier_mr = virtio_pci_set_host_notifier_mr;
  17.     k->vmstate_change = virtio_pci_vmstate_change;
  18.     k->pre_plugged = virtio_pci_pre_plugged;
  19.     k->device_plugged = virtio_pci_device_plugged;
  20.     k->device_unplugged = virtio_pci_device_unplugged;
  21.     k->query_nvectors = virtio_pci_query_nvectors;
  22.     k->ioeventfd_enabled = virtio_pci_ioeventfd_enabled;
  23.     k->ioeventfd_assign = virtio_pci_ioeventfd_assign;
  24.     k->get_dma_as = virtio_pci_get_dma_as;
  25.     k->iommu_enabled = virtio_pci_iommu_enabled;
  26.     k->queue_enabled = virtio_pci_queue_enabled;
  27. }

virtio_pci_device_plugged函数在hw/virtio/virtio-pci.c中，代码如下： 

  1. /* This is called by virtio-bus just after the device is plugged. */
  2. static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
  3. {
  4.     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
  5.     VirtioBusState *bus = &proxy->bus;
  6.     bool legacy = virtio_pci_legacy(proxy);
  7.     bool modern;
  8.     bool modern_pio = proxy->flags & VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY;
  9.     uint8_t *config;
  10.     uint32_t size;
  11.     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  12.  
  13.     /*
  14.      * Virtio capabilities present without
  15.      * VIRTIO_F_VERSION_1 confuses guests
  16.      */
  17.     if (!proxy->ignore_backend_features &&
  18.             !virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) {
  19.         virtio_pci_disable_modern(proxy);
  20.  
  21.         if (!legacy) {
  22.             error_setg(errp, "Device doesn't support modern mode, and legacy"
  23.                              " mode is disabled");
  24.             error_append_hint(errp, "Set disable-legacy to off\n");
  25.  
  26.             return;
  27.         }
  28.     }
  29.  
  30.     modern = virtio_pci_modern(proxy);
  31.  
  32.     config = proxy->pci_dev.config;
  33.     if (proxy->class_code) {
  34.         pci_config_set_class(config, proxy->class_code);
  35.     }
  36.  
  37.     if (legacy) {
  38.         if (!virtio_legacy_allowed(vdev)) {
  39.             /*
  40.              * To avoid migration issues, we allow legacy mode when legacy
  41.              * check is disabled in the old machine types (< 5.1).
  42.              */
  43.             if (virtio_legacy_check_disabled(vdev)) {
  44.                 warn_report("device is modern-only, but for backward "
  45.                             "compatibility legacy is allowed");
  46.             } else {
  47.                 error_setg(errp,
  48.                            "device is modern-only, use disable-legacy=on");
  49.                 return;
  50.             }
  51.         }
  52.         if (virtio_host_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM)) {
  53.             error_setg(errp, "VIRTIO_F_IOMMU_PLATFORM was supported by"
  54.                        " neither legacy nor transitional device");
  55.             return;
  56.         }
  57.         /*
  58.          * Legacy and transitional devices use specific subsystem IDs.
  59.          * Note that the subsystem vendor ID (config + PCI_SUBSYSTEM_VENDOR_ID)
  60.          * is set to PCI_SUBVENDOR_ID_REDHAT_QUMRANET by default.
  61.          */
  62.         pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus));
  63.         if (proxy->trans_devid) {
  64.             pci_config_set_device_id(config, proxy->trans_devid);
  65.         }
  66.     } else {
  67.         /* pure virtio-1.0 */
  68.         pci_set_word(config + PCI_VENDOR_ID,
  69.                      PCI_VENDOR_ID_REDHAT_QUMRANET);
  70.         pci_set_word(config + PCI_DEVICE_ID,
  71.                      PCI_DEVICE_ID_VIRTIO_10_BASE + virtio_bus_get_vdev_id(bus));
  72.         pci_config_set_revision(config, 1);
  73.     }
  74.     config[PCI_INTERRUPT_PIN] = 1;
  75.  
  76.  
  77.     if (modern) {
  78.         struct virtio_pci_cap cap = {
  79.             .cap_len = sizeof cap,
  80.         };
  81.         struct virtio_pci_notify_cap notify = {
  82.             .cap.cap_len = sizeof notify,
  83.             .notify_off_multiplier =
  84.                 cpu_to_le32(virtio_pci_queue_mem_mult(proxy)),
  85.         };
  86.         struct virtio_pci_cfg_cap cfg = {
  87.             .cap.cap_len = sizeof cfg,
  88.             .cap.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,
  89.         };
  90.         struct virtio_pci_notify_cap notify_pio = {
  91.             .cap.cap_len = sizeof notify,
  92.             .notify_off_multiplier = cpu_to_le32(0x0),
  93.         };
  94.  
  95.         struct virtio_pci_cfg_cap *cfg_mask;
  96.  
  97.         virtio_pci_modern_regions_init(proxy, vdev->name);
  98.  
  99.         virtio_pci_modern_mem_region_map(proxy, &proxy->common, &cap);
  100.         virtio_pci_modern_mem_region_map(proxy, &proxy->isr, &cap);
  101.         virtio_pci_modern_mem_region_map(proxy, &proxy->device, &cap);
  102.         virtio_pci_modern_mem_region_map(proxy, &proxy->notify, &notify.cap);
  103.  
  104.         if (modern_pio) {
  105.             memory_region_init(&proxy->io_bar, OBJECT(proxy),
  106.                                "virtio-pci-io", 0x4);
  107.  
  108.             pci_register_bar(&proxy->pci_dev, proxy->modern_io_bar_idx,
  109.                              PCI_BASE_ADDRESS_SPACE_IO, &proxy->io_bar);
  110.  
  111.             virtio_pci_modern_io_region_map(proxy, &proxy->notify_pio,
  112.                                             &notify_pio.cap);
  113.         }
  114.  
  115.         pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar_idx,
  116.                          PCI_BASE_ADDRESS_SPACE_MEMORY |
  117.                          PCI_BASE_ADDRESS_MEM_PREFETCH |
  118.                          PCI_BASE_ADDRESS_MEM_TYPE_64,
  119.                          &proxy->modern_bar);
  120.  
  121.         proxy->config_cap = virtio_pci_add_mem_cap(proxy, &cfg.cap);
  122.         cfg_mask = (void *)(proxy->pci_dev.wmask + proxy->config_cap);
  123.         pci_set_byte(&cfg_mask->cap.bar, ~0x0);
  124.         pci_set_long((uint8_t *)&cfg_mask->cap.offset, ~0x0);
  125.         pci_set_long((uint8_t *)&cfg_mask->cap.length, ~0x0);
  126.         pci_set_long(cfg_mask->pci_cfg_data, ~0x0);
  127.     }
  128.  
  129.     if (proxy->nvectors) {
  130.         int err = msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,
  131.                                           proxy->msix_bar_idx, NULL);
  132.         if (err) {
  133.             /* Notice when a system that supports MSIx can't initialize it */
  134.             if (err != -ENOTSUP) {
  135.                 warn_report("unable to init msix vectors to %" PRIu32,
  136.                             proxy->nvectors);
  137.             }
  138.             proxy->nvectors = 0;
  139.         }
  140.     }
  141.  
  142.     proxy->pci_dev.config_write = virtio_write_config;
  143.     proxy->pci_dev.config_read = virtio_read_config;
  144.  
  145.     if (legacy) {
  146.         size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
  147.             + virtio_bus_get_vdev_config_len(bus);
  148.         size = pow2ceil(size);
  149.  
  150.         memory_region_init_io(&proxy->bar, OBJECT(proxy),
  151.                               &virtio_pci_config_ops,
  152.                               proxy, "virtio-pci", size);
  153.  
  154.         pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar_idx,
  155.                          PCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);
  156.     }
  157. }

可以看到，virtio_pci_device_plugged函数比较长，在笔者选用的 qemu -8.1.3版本的源码中有160行左右。

对于virtio_pci_device_plugged函数的详细解析，请看下回。

举报

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

取消

确定