QEMU源码全解析23 —— QOM介绍（12）

已于 2023-08-02 09:38:25 修改
阅读量605 收藏
点赞数
分类专栏： QEMU/KVM KVM 文章标签： QEMU KVM
于 2023-08-01 14:59:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/132033046
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细解析QEMU中QOM（Quantum Object Model）的实现，探讨对象构造、初始化及其与类型信息之间的关系。通过 EduState、PCIDevice 和 DeviceState 的例子，阐述QOM中对象的父子关系，并类比Java反射机制进行说明。
摘要由CSDN通过智能技术生成

接前一篇文章： QEMU源码全解析22 —— QOM介绍（11）

本文内容参考：

《趣谈 Linux操作系统 》 —— 刘超， 极客时间

《 QEMU /KVM》源码解析与应用 —— 李强，机械工业出版社

特此致谢！

上一回分析了 QEMU 对象的构造和初始化的函数调用流程，本回结合实例对此流程进行深入介绍和解析。

仍以前文的edu的TypeInfo为例。再次贴出edu相关代码如下（hw/misc/edu.c中）： 

  1. static void pci_edu_register_types(void)
  2. {
  3.     static InterfaceInfo interfaces[] = {
  4.         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
  5.         { },
  6.     };
  7.     static const TypeInfo edu_info = {
  8.         .name          = TYPE_PCI_EDU_DEVICE,
  9.         .parent        = TYPE_PCI_DEVICE,
  10.         .instance_size = sizeof(EduState),
  11.         .instance_init = edu_instance_init,
  12.         .class_init    = edu_class_init,
  13.         .interfaces = interfaces,
  14.     };
  15.  
  16.     type_register_static(&edu_info);
  17. }
  18. type_init(pci_edu_register_types)

edu的对象大小为sizeof(EduState)，因此实际上一个edu类型的对象是EduState结构体，每一个对象都会有一个XXXState与之对应，记录了该对象的相关信息。若edu是一个PCI设备，则EduState中就会有这个设备的一些信息，如：中断信息、设备状态、使用的MMIO和PIO对应的内存区域等。

在object_init_with_type函数中可以看到，调用的参数都是一个Object，却能够一直调用父类型的初始化函数，不出意外这里也会有一个层次关系。为了便于理解，再次贴出相关代码： 

  1. static void object_init_with_type(Object *obj, TypeImpl *ti)
  2. {
  3.     if (type_has_parent(ti)) {
  4.         object_init_with_type(obj, type_get_parent(ti));
  5.     }
  6.  
  7.     if (ti->instance_init) {
  8.         ti->instance_init(obj);
  9.     }
  10. }

具体来看一下EduState结构，其定义在hw/misc/edu.c中，如下所示： 

  1. struct EduState {
  2.     PCIDevice pdev;
  3.     MemoryRegion mmio;
  4.  
  5.     QemuThread thread;
  6.     QemuMutex thr_mutex;
  7.     QemuCond thr_cond;
  8.     bool stopping;
  9.  
  10.     uint32_t addr4;
  11.     uint32_t fact;
  12. #define EDU_STATUS_COMPUTING    0x01
  13. #define EDU_STATUS_IRQFACT      0x80
  14.     uint32_t status;
  15.  
  16.     uint32_t irq_status;
  17.  
  18. #define EDU_DMA_RUN             0x1
  19. #define EDU_DMA_DIR(cmd)        (((cmd) & 0x2) >> 1)
  20. # define EDU_DMA_FROM_PCI       0
  21. # define EDU_DMA_TO_PCI         1
  22. #define EDU_DMA_IRQ             0x4
  23.     struct dma_state {
  24.         dma_addr_t src;
  25.         dma_addr_t dst;
  26.         dma_addr_t cnt;
  27.         dma_addr_t cmd;
  28.     } dma;
  29.     QEMUTimer dma_timer;
  30.     char dma_buf[DMA_SIZE];
  31.     uint64_t dma_mask;
  32. };

关注其中第一个成员的类型：PCIDevice结构。其与pci_device_type_info对应，代码如下（hw/pci/pci.c中）： 

  1. static const TypeInfo pci_device_type_info = {
  2.     .name = TYPE_PCI_DEVICE,
  3.     .parent = TYPE_DEVICE,
  4.     .instance_size = sizeof(PCIDevice),
  5.     .abstract = true,
  6.     .class_size = sizeof(PCIDeviceClass),
  7.     .class_init = pci_device_class_init,
  8.     .class_base_init = pci_device_class_base_init,
  9. };

struct PCIDevice在include/hw/pci/pci.h中定义，代码如下： 

  1. struct PCIDevice {
  2.     DeviceState qdev;
  3.     bool partially_hotplugged;
  4.     bool has_power;
  5.  
  6.     /* PCI config space */
  7.     uint8_t *config;
  8.  
  9.     /* Used to enable config checks on load. Note that writable bits are
  10.      * never checked even if set in cmask. */
  11.     uint8_t *cmask;
  12.  
  13.     /* Used to implement R/W bytes */
  14.     uint8_t *wmask;
  15.  
  16.     /* Used to implement RW1C(Write 1 to Clear) bytes */
  17.     uint8_t *w1cmask;
  18.  
  19.     /* Used to allocate config space for capabilities. */
  20.     uint8_t *used;
  21.  
  22.     /* the following fields are read only */
  23.     int32_t devfn;
  24.     /* Cached device to fetch requester ID from, to avoid the PCI
  25.      * tree walking every time we invoke PCI request (e.g.,
  26.      * MSI). For conventional PCI root complex, this field is
  27.      * meaningless. */
  28.     PCIReqIDCache requester_id_cache;
  29.     char name[64];
  30.     PCIIORegion io_regions[PCI_NUM_REGIONS];
  31.     AddressSpace bus_master_as;
  32.     MemoryRegion bus_master_container_region;
  33.     MemoryRegion bus_master_enable_region;
  34.  
  35.     /* do not access the following fields */
  36.     PCIConfigReadFunc *config_read;
  37.     PCIConfigWriteFunc *config_write;
  38.  
  39.     /* Legacy PCI VGA regions */
  40.     MemoryRegion *vga_regions[QEMU_PCI_VGA_NUM_REGIONS];
  41.     bool has_vga;
  42.  
  43.     /* Current IRQ levels.  Used internally by the generic PCI code.  */
  44.     uint8_t irq_state;
  45.  
  46.     /* Capability bits */
  47.     uint32_t cap_present;
  48.  
  49.     /* Offset of MSI-X capability in config space */
  50.     uint8_t msix_cap;
  51.  
  52.     /* MSI-X entries */
  53.     int msix_entries_nr;
  54.  
  55.     /* Space to store MSIX table & pending bit array */
  56.     uint8_t *msix_table;
  57.     uint8_t *msix_pba;
  58.  
  59.     /* May be used by INTx or MSI during interrupt notification */
  60.     void *irq_opaque;
  61.  
  62.     MSITriggerFunc *msi_trigger;
  63.     MSIPrepareMessageFunc *msi_prepare_message;
  64.     MSIxPrepareMessageFunc *msix_prepare_message;
  65.  
  66.     /* MemoryRegion container for msix exclusive BAR setup */
  67.     MemoryRegion msix_exclusive_bar;
  68.     /* Memory Regions for MSIX table and pending bit entries. */
  69.     MemoryRegion msix_table_mmio;
  70.     MemoryRegion msix_pba_mmio;
  71.     /* Reference-count for entries actually in use by driver. */
  72.     unsigned *msix_entry_used;
  73.     /* MSIX function mask set or MSIX disabled */
  74.     bool msix_function_masked;
  75.     /* Version id needed for VMState */
  76.     int32_t version_id;
  77.  
  78.     /* Offset of MSI capability in config space */
  79.     uint8_t msi_cap;
  80.  
  81.     /* PCI Express */
  82.     PCIExpressDevice exp;
  83.  
  84.     /* SHPC */
  85.     SHPCDevice *shpc;
  86.  
  87.     /* Location of option rom */
  88.     char *romfile;
  89.     uint32_t romsize;
  90.     bool has_rom;
  91.     MemoryRegion rom;
  92.     uint32_t rom_bar;
  93.  
  94.     /* INTx routing notifier */
  95.     PCIINTxRoutingNotifier intx_routing_notifier;
  96.  
  97.     /* MSI-X notifiers */
  98.     MSIVectorUseNotifier msix_vector_use_notifier;
  99.     MSIVectorReleaseNotifier msix_vector_release_notifier;
  100.     MSIVectorPollNotifier msix_vector_poll_notifier;
  101.  
  102.     /* ID of standby device in net_failover pair */
  103.     char *failover_pair_id;
  104.     uint32_t acpi_index;
  105. };

同样关注第一个成员的类型：DeviceState结构。其与device_type_info对应，代码如下（hw/core/qdev.c）： 

  1. static const TypeInfo device_type_info = {
  2.     .name = TYPE_DEVICE,
  3.     .parent = TYPE_OBJECT,
  4.     .instance_size = sizeof(DeviceState),
  5.     .instance_init = device_initfn,
  6.     .instance_post_init = device_post_init,
  7.     .instance_finalize = device_finalize,
  8.     .class_base_init = device_class_base_init,
  9.     .class_init = device_class_init,
  10.     .abstract = true,
  11.     .class_size = sizeof(DeviceClass),
  12.     .interfaces = (InterfaceInfo[]) {
  13.         { TYPE_VMSTATE_IF },
  14.         { TYPE_RESETTABLE_INTERFACE },
  15.         { }
  16.     }
  17. };

struct DeviceState在include/hw/qdev-core.h中定义，代码如下： 

  1. /**
  2.  * DeviceState:
  3.  * @realized: Indicates whether the device has been fully constructed.
  4.  *            When accessed outside big qemu lock, must be accessed with
  5.  *            qatomic_load_acquire()
  6.  * @reset: ResettableState for the device; handled by Resettable interface.
  7.  *
  8.  * This structure should not be accessed directly.  We declare it here
  9.  * so that it can be embedded in individual device state structures.
  10.  */
  11. struct DeviceState {
  12.     /*< private >*/
  13.     Object parent_obj;
  14.     /*< public >*/
  15.  
  16.     char *id;
  17.     char *canonical_path;
  18.     bool realized;
  19.     bool pending_deleted_event;
  20.     int64_t pending_deleted_expires_ms;
  21.     QDict *opts;
  22.     int hotplugged;
  23.     bool allow_unplug_during_migration;
  24.     BusState *parent_bus;
  25.     QLIST_HEAD(, NamedGPIOList) gpios;
  26.     QLIST_HEAD(, NamedClockList) clocks;
  27.     QLIST_HEAD(, BusState) child_bus;
  28.     int num_child_bus;
  29.     int instance_id_alias;
  30.     int alias_required_for_version;
  31.     ResettableState reset;
  32.     GSList *unplug_blockers;
  33. };

通过以上edu_info、pci_device_type_info、device_type_info和与之对应的EduState、PCIDevice、DeviceState的定义可以看出，对象之间其实也是有一种父对象与子对象的关系存在。与类型一样，QOM中的对象也可以使用宏，将一个指向Object对象的指针转换成一个指向子类对象的指针，转换过程与类型ObjectClass类似，在此不在赘述。

这里可以看出，不同于类型信息和类型，object是根据需要创建的，只有在命令行指定了设备或者是热插拔一个设备之后才会有object的创建。类型和对象之间是通过Object的Class域联系在一起的。这是在object_initialize_with_type函数中通过obj->class = type->class实现的。对应代码再次贴出（qom/object.c中）： 

  1. static void object_initialize_with_type(Object *obj, size_t size, TypeImpl *type)
  2. {
  3.     type_initialize(type);
  4.  
  5.     g_assert(type->instance_size >= sizeof(Object));
  6.     g_assert(type->abstract == false);
  7.     g_assert(size >= type->instance_size);
  8.  
  9.     memset(obj, 0, type->instance_size);
  10.     obj->class = type->class;
  11.     object_ref(obj);
  12.     object_class_property_init_all(obj);
  13.     obj->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
  14.                                             NULL, object_property_free);
  15.     object_init_with_type(obj, type);
  16.     object_post_init_with_type(obj, type);
  17. }

综合前文（从QEMU源码全解析 —— QOM介绍（1）开始），可以把QOM的对象构造成三部分：第一部分是类型的构造，通过TypeInfo构造一个TypeImpl的哈希表，这是在主函数main之前完成的；第二部分是类型的初始化，这两部分都是全局的，即只要编译进去的QOM对象都会被调用；第三部分是类对象的构造，这是构造具体的对象实例，只有在命令行指定了对应的设备时，才会创建对象。

类比Java中的反射机制：在Java中，对于一个类，首先，在编写代码的时候要写一个class xxx的定义，编译好就放在.class文件中，这是处于纸面的状态。此部分对应上边第一部分 —— 类型的构造；然后，Java会有一个Class对象，用于读取和表示这个纸面上的class xxx。此部分对应上边的第二部分 —— 类型的初始化；最终，Java生成真正的对象。此部分对应上边的第三部分 —— 对象的构造。

再结合实际流程解释一下：class_init函数会生成XXXClass，就相当于Java里边的Class对象；TypeImpl还会有一个instance_init函数，相当于构造函数，用于根据XXXClass生成Object，这就相当于Java反射中最终创建的对象。

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

举报

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

取消

确定