devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

virtio的qemu总线与设备模型_qemu pit set channel gate

作者：神奇cpp | 2024-07-26 11:34:53

赞

踩

qemu pit set channel gate

（很多内容是网上找的，+上我个人的一点理解，推荐大家去看 http://mnstory.net/2014/10/qemu-device-simulation 这篇文章）

qemu启动时，如果配置了相应virtio设备，会对guest的pci总线，virtio设备等进行模拟，先来看看qemu的设备模拟，那i8254/PIT为例（PIT的硬件规范略过，有兴趣的话可以参考 http://wiki.osdev.org/Programmable_Interval_Timer）

hw/timer/i8254.c定义了PIT设备的模拟，通过qom来定义设备对象模型，e.g.

  1. static const TypeInfo pit_info = {
  2.     .name          = TYPE_I8254,
  3.     .parent        = TYPE_PIT_COMMON,
  4.     .instance_size = sizeof(PITCommonState),
  5.     .class_init    = pit_class_initfn,
  6.     .class_size    = sizeof(PITClass),
  7. };
  8.  
  9. static void pit_register_types(void)
  10. {
  11.     type_register_static(&pit_info);
  12. }
  13.  
  14. type_init(pit_register_types)

type_init宏遵循qom的设备定义规范，实际调用的是module_init宏，这个宏被定义为__attribute__((constructor))属性，类似于cpp里面的构建函数，会在main函数之前被调用。

  1. typedef enum {
  2.     MODULE_INIT_BLOCK,
  3.     MODULE_INIT_MACHINE,
  4.     MODULE_INIT_QAPI,
  5.     MODULE_INIT_QOM,
  6.     MODULE_INIT_MAX
  7. } module_init_type;
  8.  
  9. #define type_init(function) module_init(function, MODULE_INIT_QOM)
  10. /* This should not be used directly.  Use block_init etc. instead.  */
  11. #define module_init(function, type)                                         \
  12. static void __attribute__((constructor)) do_qemu_init_ ## function(void)    \
  13. {                                                                           \
  14.     register_module_init(function, type);                                   \
  15. }
register_module_init的作用就是初始化type类型的ModuleEntry结构，并插入到init_type_list[type]的QLIST列表中。module_call_init则是对type的所有ModuleEntry，调用注册的初始化函数。 
  1. typedef struct ModuleEntry
  2. {
  3.     void (*init)(void);
  4.     QTAILQ_ENTRY(ModuleEntry) node;
  5.     module_init_type type;
  6. } ModuleEntry;
  7.  
  8. typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
  9.  
  10. static ModuleTypeList init_type_list[MODULE_INIT_MAX];
  11.  
  12. static ModuleTypeList *find_type(module_init_type type)
  13. {
  14.     ModuleTypeList *l;
  15.  
  16.     init_lists();
  17.  
  18.     l = &init_type_list[type];
  19.  
  20.     return l;
  21. }
  22.  
  23. void module_call_init(module_init_type type)
  24. {
  25.     ModuleTypeList *l;
  26.     ModuleEntry *e;
  27.  
  28.     module_load(type);
  29.     l = find_type(type);
  30.  
  31.     QTAILQ_FOREACH(e, l, node) {
  32.         e->init();
  33.     }
  34. }
现在回到PIT的设备注册函数pit_register_types，最终是通过传入的TypeInfo生成一个TypeImpl，并把这个TypeImpl插入到一个全局静态的GHashTable type_table中。 
  1. static const TypeInfo pit_info = {
  2.     .name          = TYPE_I8254,
  3.     .parent        = TYPE_PIT_COMMON,
  4.     .instance_size = sizeof(PITCommonState),
  5.     .class_init    = pit_class_initfn,
  6.     .class_size    = sizeof(PITClass),
  7. };
  8.  
  9. static void pit_register_types(void)
  10. {
  11.     type_register_static(&pit_info);
  12. }
  13.  
  14. TypeImpl *type_register_static(const TypeInfo *info)
  15. {
  16.     return type_register(info);
  17. }
  18.  
  19. TypeImpl *type_register(const TypeInfo *info)
  20. {
  21.     assert(info->parent);
  22.     return type_register_internal(info);
  23. }
  24.  
  25. static TypeImpl *type_register_internal(const TypeInfo *info)
  26. {
  27.     TypeImpl *ti;
  28.     ti = type_new(info);
  29.  
  30.     type_table_add(ti);
  31.     return ti;
  32. }
  33.  
  34. static void type_table_add(TypeImpl *ti)
  35. {
  36.     assert(!enumerating_types);
  37.     g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
  38. }

从PITClass也可以看出，qom实际上把qemu的设备对象模型搞成了类似cpp的对象，通过父子类，继承，虚函数等一系列特性，让qemu设备对象形成了一个树形结构，树根就是object，同时TypeInfo, TypeImpl, Object, ObjectClass都可以支持这种树形结构，e.g. 

  1. static const TypeInfo pit_info = {
  2.     .name          = TYPE_I8254,
  3.     .parent        = TYPE_PIT_COMMON,
  4.     .instance_size = sizeof(PITCommonState),
  5.     .class_init    = pit_class_initfn,
  6.     .class_size    = sizeof(PITClass),
  7. };
  8.  
  9. static const TypeInfo pit_common_type = {
  10.     .name          = TYPE_PIT_COMMON,
  11.     .parent        = TYPE_ISA_DEVICE,
  12.     .instance_size = sizeof(PITCommonState),
  13.     .class_size    = sizeof(PITCommonClass),
  14.     .class_init    = pit_common_class_init,
  15.     .abstract      = true,
  16. };
  17.  
  18. static const TypeInfo isa_device_type_info = {
  19.     .name = TYPE_ISA_DEVICE,
  20.     .parent = TYPE_DEVICE,
  21.     .instance_size = sizeof(ISADevice),
  22.     .instance_init = isa_device_init,
  23.     .abstract = true,
  24.     .class_size = sizeof(ISADeviceClass),
  25.     .class_init = isa_device_class_init,
  26. };
  27.  
  28. static const TypeInfo device_type_info = {
  29.     .name = TYPE_DEVICE,
  30.     .parent = TYPE_OBJECT,
  31.     .instance_size = sizeof(DeviceState),
  32.     .instance_init = device_initfn,
  33.     .instance_post_init = device_post_init,
  34.     .instance_finalize = device_finalize,
  35.     .class_base_init = device_class_base_init,
  36.     .class_init = device_class_init,
  37.     .abstract = true,
  38.     .class_size = sizeof(DeviceClass),
  39. };
  40.  
  41. static TypeInfo object_info = {
  42.     .name = TYPE_OBJECT,
  43.     .instance_size = sizeof(Object),
  44.     .instance_init = object_instance_init,
  45.     .abstract = true,
  46. };
ObjectClass这层同样体现了这种继承关系，同时ObjectClass也被用来实现多态，即Object对象的ObjectClass指针实际是一个虚函数的指针，e.g. 
  1. typedef struct PITCommonClass {
  2.     ISADeviceClass parent_class;
  3.  
  4.     void (*set_channel_gate)(PITCommonState *s, PITChannelState *sc, int val);
  5.     void (*get_channel_info)(PITCommonState *s, PITChannelState *sc,
  6.                              PITChannelInfo *info);
  7.     void (*pre_save)(PITCommonState *s);
  8.     void (*post_load)(PITCommonState *s);
  9. } PITCommonClass;
  10.  
  11. typedef struct ISADeviceClass {
  12.     DeviceClass parent_class;
  13. } ISADeviceClass;
  14.  
  15. typedef struct DeviceClass {
  16.     /*< private >*/
  17.     ObjectClass parent_class;
  18.     /*< public >*/
  19.  
  20.     DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX);
  21.     const char *fw_name;
  22.     const char *desc;
  23.     Property *props;
  24.     ...
  25. } DeviceClass
  26.  
  27. struct ObjectClass
  28. {
  29.     /*< private >*/
  30.     Type type;
  31.     GSList *interfaces;
  32.  
  33.     const char *object_cast_cache[OBJECT_CLASS_CAST_CACHE];
  34.     const char *class_cast_cache[OBJECT_CLASS_CAST_CACHE];
  35.  
  36.     ObjectUnparent *unparent;
  37. };
实际的设备对象继承关系如下： 
  1. typedef struct PITCommonState {
  2.     ISADevice dev;
  3.     MemoryRegion ioports;
  4.     uint32_t iobase;
  5.     PITChannelState channels[3];
  6. } PITCommonState;
  7.  
  8. struct ISADevice {
  9.     /*< private >*/
  10.     DeviceState parent_obj;
  11.     /*< public >*/
  12.  
  13.     uint32_t isairq[2];
  14.     int nirqs;
  15.     int ioport_id;
  16. };
  17.  
  18. struct DeviceState {
  19.     /*< private >*/
  20.     Object parent_obj;
  21.     /*< public >*/
  22.  
  23.     const char *id;
  24.     bool realized;
  25.     bool pending_deleted_event;
  26.     QemuOpts *opts;
  27.     int hotplugged;
  28.     BusState *parent_bus;
  29.     QLIST_HEAD(, NamedGPIOList) gpios;
  30.     QLIST_HEAD(, BusState) child_bus;
  31.     int num_child_bus;
  32.     int instance_id_alias;
  33.     int alias_required_for_version;
  34. };
  35.  
  36. struct Object
  37. {
  38.     ObjectClass *class;
  39.     ObjectFree *free;
  40.     QTAILQ_HEAD(, ObjectProperty) properties;
  41.     uint32_t ref;
  42.     Object *parent;
  43. };
下图清晰的解释了多态是如何实现的，注意ObjectClass* 指针实际指向的是PITCommonClass


言归正传，现在来看下qemu端的virtio pci设备。在qemu里，virtio pci设备是所有其他virtio设备，e.g. virtio block, virtio net, virtio ballon的父类，其定义如下

  1. static void virtio_device_class_init(ObjectClass *klass, void *data)
  2. {
  3.     /* Set the default value here. */
  4.     DeviceClass *dc = DEVICE_CLASS(klass);
  5.  
  6.     dc->realize = virtio_device_realize;
  7.     dc->unrealize = virtio_device_unrealize;
  8.     dc->bus_type = TYPE_VIRTIO_BUS;
  9. }
  10.  
  11. static const TypeInfo virtio_device_info = {
  12.     .name = TYPE_VIRTIO_DEVICE,
  13.     .parent = TYPE_DEVICE,
  14.     .instance_size = sizeof(VirtIODevice),
  15.     .class_init = virtio_device_class_init,
  16.     .abstract = true,
  17.     .class_size = sizeof(VirtioDeviceClass),
  18. };
  19.  
  20. static void virtio_register_types(void)
  21. {
  22.     type_register_static(&virtio_device_info);
  23. }
  24.  
  25. type_init(virtio_register_types)

virtio设备的结构如下，其中最关键的是VirtQueue的指针，我理解VirtIODevice主要是封装了VirtQueue

  1. struct VirtIODevice
  2. {
  3.     DeviceState parent_obj;
  4.     const char *name;
  5.     uint8_t status;
  6.     uint8_t isr;
  7.     uint16_t queue_sel;
  8.     uint32_t guest_features;
  9.     size_t config_len;
  10.     void *config;
  11.     uint16_t config_vector;
  12.     int nvectors;
  13.     VirtQueue *vq;
  14.     uint16_t device_id;
  15.     bool vm_running;
  16.     VMChangeStateEntry *vmstate;
  17.     char *bus_name;
  18.     uint8_t device_endian;
  19. };
  20.  
  21. typedef struct VirtioDeviceClass {
  22.     /*< private >*/
  23.     DeviceClass parent;
  24.     /*< public >*/
  25.  
  26.     /* This is what a VirtioDevice must implement */
  27.     DeviceRealize realize;
  28.     DeviceUnrealize unrealize;
  29.     uint32_t (*get_features)(VirtIODevice *vdev, uint32_t requested_features);
  30.     uint32_t (*bad_features)(VirtIODevice *vdev);
  31.     void (*set_features)(VirtIODevice *vdev, uint32_t val);
  32.     void (*get_config)(VirtIODevice *vdev, uint8_t *config);
  33.     void (*set_config)(VirtIODevice *vdev, const uint8_t *config);
  34.     void (*reset)(VirtIODevice *vdev);
  35.     void (*set_status)(VirtIODevice *vdev, uint8_t val);
  36.     void (*set_version)(VirtIODevice *vdev, uint32_t val);
  37.     /* Test and clear event pending status.
  38.      * Should be called after unmask to avoid losing events.
  39.      * If backend does not support masking,
  40.      * must check in frontend instead.
  41.      */
  42.     bool (*guest_notifier_pending)(VirtIODevice *vdev, int n);
  43.     /* Mask/unmask events from this vq. Any events reported
  44.      * while masked will become pending.
  45.      * If backend does not support masking,
  46.      * must mask in frontend instead.
  47.      */
  48.     void (*guest_notifier_mask)(VirtIODevice *vdev, int n, bool mask);
  49.     void (*save)(VirtIODevice *vdev, QEMUFile *f);
  50.     int (*load)(VirtIODevice *vdev, QEMUFile *f, int version_id);
  51. } VirtioDeviceClass;

qemu内部也定义了VirtQueue和VRing的结构，注意这里需要保证前端virtio驱动和qemu的vring两者的ABI一致，即内存结构保证一致性，e.g.

  1. /* The standard layout for the ring is a continuous chunk of memory which looks
  2.  * like this.  We assume num is a power of 2.
  3.  *
  4.  * struct vring
  5.  * {
  6.  *  // The actual descriptors (16 bytes each)
  7.  *  struct vring_desc desc[num];
  8.  *
  9.  *  // A ring of available descriptor heads with free-running index.
  10.  *  __u16 avail_flags;
  11.  *  __u16 avail_idx;
  12.  *  __u16 available[num];
  13.  *  __u16 used_event_idx;
  14.  *
  15.  *  // Padding to the next align boundary.
  16.  *  char pad[];
  17.  *
  18.  *  // A ring of used descriptor heads with free-running index.
  19.  *  __u16 used_flags;
  20.  *  __u16 used_idx;
  21.  *  struct vring_used_elem used[num];
  22.  *  __u16 avail_event_idx;
  23.  * };
注意qemu对于VRing的操作一般都只限于VRingUsed这部分以及avail_event_idx的更新 
  1. #define VIRTIO_PCI_VRING_ALIGN         4096
  2.  
  3. typedef struct VRingDesc
  4. {
  5.     uint64_t addr;
  6.     uint32_t len;
  7.     uint16_t flags;
  8.     uint16_t next;
  9. } VRingDesc;
  10.  
  11. typedef struct VRingAvail
  12. {
  13.     uint16_t flags;
  14.     uint16_t idx;
  15.     uint16_t ring[0];
  16. } VRingAvail;
  17.  
  18. typedef struct VRingUsedElem
  19. {
  20.     uint32_t id;
  21.     uint32_t len;
  22. } VRingUsedElem;
  23.  
  24. typedef struct VRingUsed
  25. {
  26.     uint16_t flags;
  27.     uint16_t idx;
  28.     VRingUsedElem ring[0];
  29. } VRingUsed;
  30.  
  31. typedef struct VRing
  32. {
  33.     unsigned int num;
  34.     unsigned int align;
  35.     hwaddr desc;
  36.     hwaddr avail;
  37.     hwaddr used;
  38. } VRing;
  39.  
  40. struct VirtQueue
  41. {
  42.     VRing vring;
  43.     hwaddr pa;
  44.     uint16_t last_avail_idx;
  45.     /* Last used index value we have signalled on */
  46.     uint16_t signalled_used;
  47.  
  48.     /* Last used index value we have signalled on */
  49.     bool signalled_used_valid;
  50.  
  51.     /* Notification enabled? */
  52.     bool notification;  /* 是否使能notification，只有enable了event_idx才有效 */
  53.  
  54.     uint16_t queue_index;
  55.  
  56.     int inuse;
  57.  
  58.     uint16_t vector;
  59.     void (*handle_output)(VirtIODevice *vdev, VirtQueue *vq);
  60.     VirtIODevice *vdev;
  61.     EventNotifier guest_notifier; /* guest notifier fd，目前只有vhost使用 */
  62.     EventNotifier host_notifier;  /* host notifier fd, 目前只有vhost使用 */
  63. };
qemu的VRing通过查看avail_event_idx来判断是否有新的avail buffer到达。关于VirtQueue和VRing的部分后面再详细阐述。


除了TYPE_DEVICE -> TYPE_VIRTIO_DEVICE -> TYPE_VIRTIO_XXX_DEVICE这条继承关系之外，qemu的virtio设备同时也是PCI设备，因此还存在有TYPE_DEVICE -> TYPE_PCI_DEVICE -> TYPE_VIRTIO_PCI -> TYPE_VIRTIO_XXX_PCI的继承关系，同时总线上也存在TYPE_BUS -> TYPE_VIRTIO_BUS -> TYPE_VIRTIO_PCI_BUS

virtio bus定义如下

  1. static const TypeInfo virtio_bus_info = {
  2.     .name = TYPE_VIRTIO_BUS,
  3.     .parent = TYPE_BUS,
  4.     .instance_size = sizeof(VirtioBusState),
  5.     .abstract = true,
  6.     .class_size = sizeof(VirtioBusClass),
  7.     .class_init = virtio_bus_class_init
  8. };
  9.  
  10. static void virtio_register_types(void)
  11. {
  12.     type_register_static(&virtio_bus_info);
  13. }
  14.  
  15. type_init(virtio_register_types)

总线设备virtio-bus，对应类型是VirtioBusClass。设备定义了多个虚函数的接口，具体实现分为TYPE_VIRTIO_MMIO_BUS和TYPE_VIRTIO_PCI_BUS两种，对应设备是virtio-pci-bus和virtio-mmio-bus

  1. static const TypeInfo virtio_pci_bus_info = {
  2.     .name          = TYPE_VIRTIO_PCI_BUS,
  3.     .parent        = TYPE_VIRTIO_BUS,
  4.     .instance_size = sizeof(VirtioPCIBusState),
  5.     .class_init    = virtio_pci_bus_class_init,
  6. };
  7.  
  8. static void virtio_pci_bus_class_init(ObjectClass *klass, void *data)
  9. {
  10.     BusClass *bus_class = BUS_CLASS(klass);
  11.     VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
  12.     bus_class->max_dev = 1;
  13.     k->notify = virtio_pci_notify;
  14.     k->save_config = virtio_pci_save_config;
  15.     k->load_config = virtio_pci_load_config;
  16.     k->save_queue = virtio_pci_save_queue;
  17.     k->load_queue = virtio_pci_load_queue;
  18.     k->get_features = virtio_pci_get_features;
  19.     k->query_guest_notifiers = virtio_pci_query_guest_notifiers;
  20.     k->set_host_notifier = virtio_pci_set_host_notifier;
  21.     k->start_host_notifier = virtio_pci_start_host_notifier;
  22.     k->set_guest_notifiers = virtio_pci_set_guest_notifiers;
  23.     k->vmstate_change = virtio_pci_vmstate_change;
  24.     k->device_plugged = virtio_pci_device_plugged;
  25.     k->device_unplugged = virtio_pci_device_unplugged;
  26. }
另一个相关的设备是virtio-pci，代表了挂载virtio pci总线上的pci设备模型，定义如下 
  1. static const TypeInfo virtio_pci_info = {
  2.     .name          = TYPE_VIRTIO_PCI,
  3.     .parent        = TYPE_PCI_DEVICE,
  4.     .instance_size = sizeof(VirtIOPCIProxy),
  5.     .class_init    = virtio_pci_class_init,
  6.     .class_size    = sizeof(VirtioPCIClass),
  7.     .abstract      = true,
  8. };
  9.  
  10. struct VirtIOPCIProxy {
  11.     PCIDevice pci_dev;
  12.     MemoryRegion bar;
  13.     uint32_t flags;
  14.     uint32_t class_code;
  15.     uint32_t nvectors;
  16.     uint32_t host_features;
  17.     bool ioeventfd_disabled;
  18.     bool ioeventfd_started;
  19.     VirtIOIRQFD *vector_irqfd;
  20.     int nvqs_with_notifiers;
  21.     VirtioBusState bus;
  22. };
  23.  
  24. typedef struct VirtioPCIClass {
  25.     PCIDeviceClass parent_class;
  26.     int (*init)(VirtIOPCIProxy *vpci_dev);
  27. } VirtioPCIClass;

VirtioPCIBusState除了虚函数的实现，其他地方和VirtioBusState完全一致，同样VirtioBusClass和VirtioPCIBusClass也是完全一致。从代码实现上看，和内核的virtio pci设备基本类似。

virtio_pci_notify用于通知guest中断，根据pci设备是否enable msix

  1. static void virtio_pci_notify(DeviceState *d, uint16_t vector)
  2. {
  3.     VirtIOPCIProxy *proxy = to_virtio_pci_proxy_fast(d);
  4.  
  5.     if (msix_enabled(&proxy->pci_dev))
  6.         msix_notify(&proxy->pci_dev, vector); /* msix_notify通过写pci配置空间来传递中断 */
  7.     else {
  8.         VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  9.         pci_set_irq(&proxy->pci_dev, vdev->isr & 1);  /* 通过irq传递中断 */
  10.     }
  11. }
virtio_pci_get_features用于获取pci配置空间的HOST_FEATURES 
  1. static unsigned virtio_pci_get_features(DeviceState *d)
  2. {
  3.     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
  4.     return proxy->host_features;
  5. }
virtio_pci_save_config/virtio_pci_load_config，virtio_pci_save_queue/virtio_pci_load_queue用于save/load pci的配置信息和队列信息

virtio_pci_device_plugged当有virtio-pci设备被virtio-pci-bus启动时被调用

  1. static void virtio_pci_device_plugged(DeviceState *d)
  2. {
  3.     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
  4.     VirtioBusState *bus = &proxy->bus;
  5.     uint8_t *config;
  6.     uint32_t size;
  7.  
  8.     config = proxy->pci_dev.config;
  9.     if (proxy->class_code) {
  10.         pci_config_set_class(config, proxy->class_code); /* 设置pci配置空间的class code */
  11.     }
  12.     pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID,
  13.                  pci_get_word(config + PCI_VENDOR_ID)); /* 设置pci配置空间的VENDOR_ID */
  14.     pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus)); /* 设置pci配置空间的SUBSYSTEM_ID */
  15.     config[PCI_INTERRUPT_PIN] = 1;
  16.  
  17.     if (proxy->nvectors &&
  18.         msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors, 1)) { /* 初始化virtio bar的msix配置 */
  19.         error_report("unable to init msix vectors to %" PRIu32,
  20.                      proxy->nvectors);
  21.         proxy->nvectors = 0;
  22.     }
  23.  
  24.     proxy->pci_dev.config_write = virtio_write_config;
  25.  
  26.     size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
  27.          + virtio_bus_get_vdev_config_len(bus);
  28.     if (size & (size - 1)) {
  29.         size = 1 << qemu_fls(size);
  30.     }
  31.  
  32.     memory_region_init_io(&proxy->bar, OBJECT(proxy), &virtio_pci_config_ops,
  33.                           proxy, "virtio-pci", size); /* 初始化bar0的内存为virtio的配置空间 */
  34.     pci_register_bar(&proxy->pci_dev, 0, PCI_BASE_ADDRESS_SPACE_IO,
  35.                      &proxy->bar); /* 注册virtio pci的bar0 */
  36.  
  37.     if (!kvm_has_many_ioeventfds()) {
  38.         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
  39.     }
  40.  
  41.     proxy->host_features |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
  42.     proxy->host_features |= 0x1 << VIRTIO_F_BAD_FEATURE;
  43.     proxy->host_features = virtio_bus_get_vdev_features(bus,
  44.                                                       proxy->host_features);
  45. }
virtio_pci_device_unplugged当设备停用并从总线上删除时调用，对vhost而言，ioeventfd用于guest通过pci通知host，irqfd用于host把中断注入guest。这里调用了virtio_pci_stop_ioeventfd，该函数最终通过virtio_pci_set_host_notifier_internal来配置ioveventfd 
  1. static void virtio_pci_device_unplugged(DeviceState *d)
  2. {
  3.     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
  4.  
  5.     virtio_pci_stop_ioeventfd(proxy);
  6. }
VirtioBusClass需要支持guest notifier和host notifier的相关操作，e.g. 
  1. static int virtio_pci_set_host_notifier(DeviceState *d, int n, bool assign)
  2. {
  3.     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
  4.  
  5.     /* Stop using ioeventfd for virtqueue kick if the device starts using host
  6.      * notifiers.  This makes it easy to avoid stepping on each others' toes.
  7.      */
  8.     proxy->ioeventfd_disabled = assign; /* assign为true，说明设置host notifier；assign为false，说明清理host notifier */
  9.     if (assign) { /* 如果是assign新的fd，需要先清理掉老的fd */
  10.         virtio_pci_stop_ioeventfd(proxy);
  11.     }
  12.     /* We don't need to start here: it's not needed because backend
  13.      * currently only stops on status change away from ok,
  14.      * reset, vmstop and such. If we do add code to start here,
  15.      * need to check vmstate, device state etc. */
  16.     return virtio_pci_set_host_notifier_internal(proxy, n, assign, false);
  17. }
  18.  
  19. static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
  20.                                                  int n, bool assign, bool set_handler)
  21. {
  22.     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  23.     VirtQueue *vq = virtio_get_queue(vdev, n);
  24.     EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
  25.     int r = 0;
  26.  
  27.     if (assign) {
  28.         r = event_notifier_init(notifier, 1);
  29.         if (r < 0) {
  30.             error_report("%s: unable to init event notifier: %d",
  31.                          __func__, r);
  32.             return r;
  33.         }
  34.         virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler); /* set_host_notifier的时候set_handler设置为false */
  35.                                                                           /* start_ioeventfd的时候设置为true */
  36.         memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
  37.                                   true, n, notifier); /* 把ioport/iomem对应的memregion和fd关联起来 */
  38.     } else {
  39.         memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
  40.                                   true, n, notifier);
  41.         virtio_queue_set_host_notifier_fd_handler(vq, false, false);
  42.         event_notifier_cleanup(notifier);
  43.     }
  44.     return r;
  45. }
上述的host notifier，实际对应VirtQueue EventNotifier的一个read fd，通常叫做ioevent_fd，可以通过virtio_pci_start_ioeventfd，virtio_pci_stop_ioeventfd来控制；而guest notifier通常对应于VirtIOPCIProxy的vector_irqfd，通常叫做irqfd，e.g. 
  1. static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign)
  2. {
  3.     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
  4.     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  5.     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
  6.     int r, n;
  7.     bool with_irqfd = msix_enabled(&proxy->pci_dev) &&
  8.         kvm_msi_via_irqfd_enabled();
  9.  
  10.     nvqs = MIN(nvqs, VIRTIO_PCI_QUEUE_MAX);
  11.  
  12.     /* When deassigning, pass a consistent nvqs value
  13.      * to avoid leaking notifiers.
  14.      */
  15.     assert(assign || nvqs == proxy->nvqs_with_notifiers);
  16.  
  17.     proxy->nvqs_with_notifiers = nvqs;
  18.  
  19.     /* Must unset vector notifier while guest notifier is still assigned */
  20.     if ((proxy->vector_irqfd || k->guest_notifier_mask) && !assign) {
  21.         msix_unset_vector_notifiers(&proxy->pci_dev); /* 修改pci配置空间清理msix vector */
  22.         if (proxy->vector_irqfd) {
  23.             kvm_virtio_pci_vector_release(proxy, nvqs);
  24.             g_free(proxy->vector_irqfd);
  25.             proxy->vector_irqfd = NULL;
  26.         }
  27.     }
  28.  
  29.     for (n = 0; n < nvqs; n++) {
  30.         if (!virtio_queue_get_num(vdev, n)) {
  31.             break;
  32.         }
  33.  
  34.         r = virtio_pci_set_guest_notifier(d, n, assign, with_irqfd); /* 对每个VirtQueue设置irqfd */
  35.         if (r < 0) {
  36.             goto assign_error;
  37.         }
  38.     }
  39.  
  40.     /* Must set vector notifier after guest notifier has been assigned */
  41.     if ((with_irqfd || k->guest_notifier_mask) && assign) {
  42.         if (with_irqfd) {
  43.             proxy->vector_irqfd =
  44.                 g_malloc0(sizeof(*proxy->vector_irqfd) *
  45.                           msix_nr_vectors_allocated(&proxy->pci_dev));
  46.             r = kvm_virtio_pci_vector_use(proxy, nvqs);
  47.             if (r < 0) {
  48.                 goto assign_error;
  49.             }
  50.         }
  51.         r = msix_set_vector_notifiers(&proxy->pci_dev,
  52.                                       virtio_pci_vector_unmask,
  53.                                       virtio_pci_vector_mask,
  54.                                       virtio_pci_vector_poll);  /* 同样配置pci空间增加msix vector */
  55.         if (r < 0) {
  56.             goto notifiers_error;
  57.         }
  58.     }
  59.  
  60.     return 0;
  61.  
  62. notifiers_error:
  63.     if (with_irqfd) {
  64.         assert(assign);
  65.         kvm_virtio_pci_vector_release(proxy, nvqs);
  66.     }
  67.  
  68. assign_error:
  69.     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
  70.     assert(assign);
  71.     while (--n >= 0) {
  72.         virtio_pci_set_guest_notifier(d, n, !assign, with_irqfd);
  73.     }
  74.     return r;
  75. }

virtio的pci配置空间的读写(bar0的IO空间)操作，用于pci配置空间的offset + size的读写操作，并分为单字节，双字节，四字节三种。对于virtio配置空间20字节之前的读写通过io port完成，20字节之后的通过mmio完成。

  1. static const MemoryRegionOps virtio_pci_config_ops = {
  2.     .read = virtio_pci_config_read,
  3.     .write = virtio_pci_config_write,
  4.     .impl = {
  5.         .min_access_size = 1,
  6.         .max_access_size = 4,
  7.     },
  8.     .endianness = DEVICE_LITTLE_ENDIAN,
  9. };





声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/885036
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号