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

已于 2024-08-21 08:10:23 修改
阅读量594 收藏 6
点赞数 14
分类专栏： QEMU/KVM 文章标签： QEMU KVM virtio
于 2023-12-18 16:13:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/135063565
版权
QEMU/KVM 专栏收录该内容
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文深入解析QEMU中virtio_pci_device_plugged函数，探讨在modern模式下如何设置virtio PCI设备的vendor id、device id，并详细解释如何将virtio设备寄存器配置信息作为PCI capability写入配置空间，涉及pci capability概念及virtio_pci_cap结构的作用。
摘要由CSDN通过智能技术生成

接前一篇文章：

本回对于virtio_pci_device_plugged函数进行详细解析。为了便于理解，再次贴出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是modern模式的情况，也就是代码中非legacy的情况。

（1）virtio_pci_device_plugged函数设置virtio PCI 代理设备的配置空间的vendor id和device id。代码片段如下： 

  1.     if (legacy) {
  2.     {
  3.         ……
  4.     } else {
  5.         /* pure virtio-1.0 */
  6.         pci_set_word(config + PCI_VENDOR_ID,
  7.                      PCI_VENDOR_ID_REDHAT_QUMRANET);
  8.         pci_set_word(config + PCI_DEVICE_ID,
  9.                      PCI_DEVICE_ID_VIRTIO_10_BASE + virtio_bus_get_vdev_id(bus));
  10.         pci_config_set_revision(config, 1);
  11.     }
  • vendor id

将 vendor id设置为PCI_VENDOR_ID_REDHAT_QUMRANE。相关宏定义在include/hw/pci/pci.h中，如下： 

  1. /* Red Hat / Qumranet (for QEMU) -- see pci-ids.txt */
  2. #define PCI_VENDOR_ID_REDHAT_QUMRANET    0x1af4
  3. #define PCI_SUBVENDOR_ID_REDHAT_QUMRANET 0x1af4
  4. #define PCI_SUBDEVICE_ID_QEMU            0x1100
  • device id

将device id设置为PCI_DEVICE_ID_VIRTIO_10_BASE加上virtio设备类型的id。相关宏定义在include/hw/pci/pci.h中，如下： 

  1. /*
  2.  * modern virtio-pci devices get their id assigned automatically,
  3.  * there is no need to add #defines here.  It gets calculated as
  4.  *
  5.  * PCI_DEVICE_ID = PCI_DEVICE_ID_VIRTIO_10_BASE +
  6.  *                 virtio_bus_get_vdev_id(bus)
  7.  */
  8. #define PCI_DEVICE_ID_VIRTIO_10_BASE     0x1040

对于virtual balloon来说是VIRTIO_ID_BALLOON。相关宏定义在include/standard-headers/ linux /virtio_ids.h中，如下： 

#define VIRTIO_ID_BALLOON		5 /* virtio balloon */

（2）接下来将virtio设备的寄存器配置信息作为PCIcapability写入到配置空间中。代码片段如下： 

  1.     if (modern) {
  2.         struct virtio_pci_cap cap = {
  3.             .cap_len = sizeof cap,
  4.         };
  5.         struct virtio_pci_notify_cap notify = {
  6.             .cap.cap_len = sizeof notify,
  7.             .notify_off_multiplier =
  8.                 cpu_to_le32(virtio_pci_queue_mem_mult(proxy)),
  9.         };
  10.         struct virtio_pci_cfg_cap cfg = {
  11.             .cap.cap_len = sizeof cfg,
  12.             .cap.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,
  13.         };
  14.         struct virtio_pci_notify_cap notify_pio = {
  15.             .cap.cap_len = sizeof notify,
  16.             .notify_off_multiplier = cpu_to_le32(0x0),
  17.         };
  18.  
  19.         struct virtio_pci_cfg_cap *cfg_mask;
  20.  
  21.         virtio_pci_modern_regions_init(proxy, vdev->name);
  22.  
  23.         virtio_pci_modern_mem_region_map(proxy, &proxy->common, &cap);
  24.         virtio_pci_modern_mem_region_map(proxy, &proxy->isr, &cap);
  25.         virtio_pci_modern_mem_region_map(proxy, &proxy->device, &cap);
  26.         virtio_pci_modern_mem_region_map(proxy, &proxy->notify, &notify.cap);
  27.  
  28.         if (modern_pio) {
  29.             memory_region_init(&proxy->io_bar, OBJECT(proxy),
  30.                                "virtio-pci-io", 0x4);
  31.  
  32.             pci_register_bar(&proxy->pci_dev, proxy->modern_io_bar_idx,
  33.                              PCI_BASE_ADDRESS_SPACE_IO, &proxy->io_bar);
  34.  
  35.             virtio_pci_modern_io_region_map(proxy, &proxy->notify_pio,
  36.                                             &notify_pio.cap);
  37.         }
  38.  
  39.         pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar_idx,
  40.                          PCI_BASE_ADDRESS_SPACE_MEMORY |
  41.                          PCI_BASE_ADDRESS_MEM_PREFETCH |
  42.                          PCI_BASE_ADDRESS_MEM_TYPE_64,
  43.                          &proxy->modern_bar);
  44.  
  45.         proxy->config_cap = virtio_pci_add_mem_cap(proxy, &cfg.cap);
  46.         cfg_mask = (void *)(proxy->pci_dev.wmask + proxy->config_cap);
  47.         pci_set_byte(&cfg_mask->cap.bar, ~0x0);
  48.         pci_set_long((uint8_t *)&cfg_mask->cap.offset, ~0x0);
  49.         pci_set_long((uint8_t *)&cfg_mask->cap.length, ~0x0);
  50.         pci_set_long(cfg_mask->pci_cfg_data, ~0x0);
  51.     }

要看懂这段代码，需要先了解pci capability。pci capability用来表明设备的功能。virtio会把多个MemoryRegion作为VirtIOPCIProxy设备MMIO对应MemoryRegion的子MemoryRegion（比较拗口），这几个MemoryRegion的信息会作为capability写入到virtioPCI代理这个PCI设备的配置空间。这些capability的头结构用struct virtio_pci_cap表示。virtio_pci_cap结构的定义在include/standard-headers/linux/virtio_pci.h中，如下： 

  1. /* This is the PCI capability header: */
  2. struct virtio_pci_cap {
  3. 	uint8_t cap_vndr;		/* Generic PCI field: PCI_CAP_ID_VNDR */
  4. 	uint8_t cap_next;		/* Generic PCI field: next ptr. */
  5. 	uint8_t cap_len;		/* Generic PCI field: capability length */
  6. 	uint8_t cfg_type;		/* Identifies the structure. */
  7. 	uint8_t bar;		/* Where to find it. */
  8. 	uint8_t id;		/* Multiple capabilities of the same type */
  9. 	uint8_t padding[2];	/* Pad to full dword. */
  10. 	uint32_t offset;		/* Offset within bar. */
  11. 	uint32_t length;		/* Length of the structure, in bytes. */
  12. };

其中：

  • cap_vndr用来表示capability的id。除了一些标准的capability外，如果是设备自定义的（如这里的virtio设备），会设置为PCI_CAP_ID_VNDR。
  • cap_next指向下一个capability在PCI配置空间的偏移。
  • bar表示这个capability使用哪个bar。
  • offset表示这个capability代表的MemoryRegion在virtioPCI代理设备的bar中从哪里开始。
  • length则表示此capability的长度。

整体上，virtio_pci_cap结构用来描述virtioPCI代理设备modern MMIO中的一段地址空间。virtio驱动可以通过这些capability信息将对应的地址映射到内核虚拟地址空间中，从而便于之后访问。PCI配置空间与cap以及MMIO的关系如下图所示：

878cde2932219fba83a08f1920d0f9f6.png

virtio_pci_device_plugged函数的其余部分，将在下一回继续解析。

举报

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

取消

确定