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

已于 2023-12-20 15:55:47 修改
阅读量546 收藏 7
点赞数 11
分类专栏： QEMU/KVM KVM 文章标签： QEMU KVM virtio
于 2023-12-19 10:09:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/135074699
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细介绍了QEMU virtio_pci_device_plugged函数的实现，包括virtio_pci_modern_regions_init初始化MemoryRegion和virtio_pci_modern_mem_region_map映射内存区域的过程，探讨了在虚拟机中如何处理MMIO操作。
摘要由CSDN通过智能技术生成

接前一篇文章：

上一回讲解了virtio_pci_device_plugged函数的前两部分，本回继续讲解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. }

2.1）virtio_pci_modern_regions_init函数 初始化 5个MemoryRegion，分别是virtio-pci-common、virtio-pci-isr、virtio-pci-device、virtio-pci-notify和virtio-pci-notify-pio。代码片段如下： 

    virtio_pci_modern_regions_init(proxy, vdev->name);

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

  1. static void virtio_pci_modern_regions_init(VirtIOPCIProxy *proxy,
  2.                                            const char *vdev_name)
  3. {
  4.     static const MemoryRegionOps common_ops = {
  5.         .read = virtio_pci_common_read,
  6.         .write = virtio_pci_common_write,
  7.         .impl = {
  8.             .min_access_size = 1,
  9.             .max_access_size = 4,
  10.         },
  11.         .endianness = DEVICE_LITTLE_ENDIAN,
  12.     };
  13.     static const MemoryRegionOps isr_ops = {
  14.         .read = virtio_pci_isr_read,
  15.         .write = virtio_pci_isr_write,
  16.         .impl = {
  17.             .min_access_size = 1,
  18.             .max_access_size = 4,
  19.         },
  20.         .endianness = DEVICE_LITTLE_ENDIAN,
  21.     };
  22.     static const MemoryRegionOps device_ops = {
  23.         .read = virtio_pci_device_read,
  24.         .write = virtio_pci_device_write,
  25.         .impl = {
  26.             .min_access_size = 1,
  27.             .max_access_size = 4,
  28.         },
  29.         .endianness = DEVICE_LITTLE_ENDIAN,
  30.     };
  31.     static const MemoryRegionOps notify_ops = {
  32.         .read = virtio_pci_notify_read,
  33.         .write = virtio_pci_notify_write,
  34.         .impl = {
  35.             .min_access_size = 1,
  36.             .max_access_size = 4,
  37.         },
  38.         .endianness = DEVICE_LITTLE_ENDIAN,
  39.     };
  40.     static const MemoryRegionOps notify_pio_ops = {
  41.         .read = virtio_pci_notify_read,
  42.         .write = virtio_pci_notify_write_pio,
  43.         .impl = {
  44.             .min_access_size = 1,
  45.             .max_access_size = 4,
  46.         },
  47.         .endianness = DEVICE_LITTLE_ENDIAN,
  48.     };
  49.     g_autoptr(GString) name = g_string_new(NULL);
  50.  
  51.     g_string_printf(name, "virtio-pci-common-%s", vdev_name);
  52.     memory_region_init_io(&proxy->common.mr, OBJECT(proxy),
  53.                           &common_ops,
  54.                           proxy,
  55.                           name->str,
  56.                           proxy->common.size);
  57.  
  58.     g_string_printf(name, "virtio-pci-isr-%s", vdev_name);
  59.     memory_region_init_io(&proxy->isr.mr, OBJECT(proxy),
  60.                           &isr_ops,
  61.                           proxy,
  62.                           name->str,
  63.                           proxy->isr.size);
  64.  
  65.     g_string_printf(name, "virtio-pci-device-%s", vdev_name);
  66.     memory_region_init_io(&proxy->device.mr, OBJECT(proxy),
  67.                           &device_ops,
  68.                           proxy,
  69.                           name->str,
  70.                           proxy->device.size);
  71.  
  72.     g_string_printf(name, "virtio-pci-notify-%s", vdev_name);
  73.     memory_region_init_io(&proxy->notify.mr, OBJECT(proxy),
  74.                           &notify_ops,
  75.                           proxy,
  76.                           name->str,
  77.                           proxy->notify.size);
  78.  
  79.     g_string_printf(name, "virtio-pci-notify-pio-%s", vdev_name);
  80.     memory_region_init_io(&proxy->notify_pio.mr, OBJECT(proxy),
  81.                           &notify_pio_ops,
  82.                           proxy,
  83.                           name->str,
  84.                           proxy->notify_pio.size);
  85. }

VirtIOPCIProxy结构的定义在include/hw/virtio/virtio-pci.h中，如下： 

  1. struct VirtIOPCIProxy {
  2.     PCIDevice pci_dev;
  3.     MemoryRegion bar;
  4.     union {
  5.         struct {
  6.             VirtIOPCIRegion common;
  7.             VirtIOPCIRegion isr;
  8.             VirtIOPCIRegion device;
  9.             VirtIOPCIRegion notify;
  10.             VirtIOPCIRegion notify_pio;
  11.         };
  12.         VirtIOPCIRegion regs[5];
  13.     };
  14.     MemoryRegion modern_bar;
  15.     MemoryRegion io_bar;
  16.     uint32_t legacy_io_bar_idx;
  17.     uint32_t msix_bar_idx;
  18.     uint32_t modern_io_bar_idx;
  19.     uint32_t modern_mem_bar_idx;
  20.     int config_cap;
  21.     uint32_t flags;
  22.     bool disable_modern;
  23.     bool ignore_backend_features;
  24.     OnOffAuto disable_legacy;
  25.     /* Transitional device id */
  26.     uint16_t trans_devid;
  27.     uint32_t class_code;
  28.     uint32_t nvectors;
  29.     uint32_t dfselect;
  30.     uint32_t gfselect;
  31.     uint32_t guest_features[2];
  32.     VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];
  33.  
  34.     VirtIOIRQFD *vector_irqfd;
  35.     int nvqs_with_notifiers;
  36.     VirtioBusState bus;
  37. };

virtio-pci-common、virtio-pci-isr、virtio-pci-device、virtio-pci-notify和virtio-pci-notify-pio这5个MemoryRegion的相关信息存放在VirtIOPCIProxy结构中的几个VirtIOPCIRegion成员中。

2.2）virtio_pci_device_plugged接下来调用virtio_pci_modern_mem_region_map函。代码片段如下： 

  1.     virtio_pci_modern_mem_region_map(proxy, &proxy->common, &cap);
  2.     virtio_pci_modern_mem_region_map(proxy, &proxy->isr, &cap);
  3.     virtio_pci_modern_mem_region_map(proxy, &proxy->device, &cap);
  4.     virtio_pci_modern_mem_region_map(proxy, &proxy->notify, &notify.cap);

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

  1. static void virtio_pci_modern_mem_region_map(VirtIOPCIProxy *proxy,
  2.                                              VirtIOPCIRegion *region,
  3.                                              struct virtio_pci_cap *cap)
  4. {
  5.     virtio_pci_modern_region_map(proxy, region, cap,
  6.                                  &proxy->modern_bar, proxy->modern_mem_bar_idx);
  7. }

virtio_pci_modern_mem_region_map函数仅仅调用了virtio_pci_modern_region_map函数。该函数也在hw/virtio/virtio-pci.c中（就在上边），代码如下： 

  1. static void virtio_pci_modern_region_map(VirtIOPCIProxy *proxy,
  2.                                          VirtIOPCIRegion *region,
  3.                                          struct virtio_pci_cap *cap,
  4.                                          MemoryRegion *mr,
  5.                                          uint8_t bar)
  6. {
  7.     memory_region_add_subregion(mr, region->offset, &region->mr);
  8.  
  9.     cap->cfg_type = region->type;
  10.     cap->bar = bar;
  11.     cap->offset = cpu_to_le32(region->offset);
  12.     cap->length = cpu_to_le32(region->size);
  13.     virtio_pci_add_mem_cap(proxy, cap);
  14.  
  15. }

virtio_pci_modern_region_map函数完成了两个功能：

  • 将VirtIOPCIRegion的mr成员virtio-pci-***作为子MemoryRegion加入到VirtIOProxy的modern_bar成员中去。所以当在虚拟机内部写virtio PCI proxy的MMIO时会落入这几个virtio设备的MemoryRegion的回调函数。
  • 调用virtio_pci_add_mem_cap函数将这些寄存器信息加入到virtio PCI代理设备的pci capability上去。virtio_pci_add_mem_cap函数同样在hw/virtio/virtio-pci.c中，代码如下： 
  1. static int virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,
  2.                                    struct virtio_pci_cap *cap)
  3. {
  4.     PCIDevice *dev = &proxy->pci_dev;
  5.     int offset;
  6.  
  7.     offset = pci_add_capability(dev, PCI_CAP_ID_VNDR, 0,
  8.                                 cap->cap_len, &error_abort);
  9.  
  10.     assert(cap->cap_len >= sizeof *cap);
  11.     memcpy(dev->config + offset + PCI_CAP_FLAGS, &cap->cap_len,
  12.            cap->cap_len - PCI_CAP_FLAGS);
  13.  
  14.     return offset;
  15. }

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

举报

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

取消

确定