QEMU源码全解析16 —— QOM介绍（5）

已于 2023-07-31 12:41:54 修改
阅读量379 收藏
点赞数
分类专栏： KVM QEMU/KVM 文章标签： QEMU KVM
于 2023-07-28 14:24:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/131965458
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益

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

本文内容参考：

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

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

特此致谢！

上一回讲完了QOM第一部分 —— 类型的注册。本回开始讲解第二部分 —— 类型的初始化。

2. 类型的初始化

在C++、Java等 面向对象编程 语言中，当程序中声明一个类型的时候，就已经知道了其类型的信息，如它的对象的大小。但是如果使用C语言来实现面向对象的这些特性，就需要特殊的处理了，要对类进行单独的初始化。在前文中，所有的类型信息TypeImpl已经保存在了一个哈希链表中，接下来，就需要对类进行初始化了。

类的初始化是通过type_initialize函数完成的，其在qom/object.c中，代码如下： 

  1. static void type_initialize(TypeImpl *ti)
  2. {
  3.     TypeImpl *parent;
  4.  
  5.     if (ti->class) {
  6.         return;
  7.     }
  8.  
  9.     ti->class_size = type_class_get_size(ti);
  10.     ti->instance_size = type_object_get_size(ti);
  11.     /* Any type with zero instance_size is implicitly abstract.
  12.      * This means interface types are all abstract.
  13.      */
  14.     if (ti->instance_size == 0) {
  15.         ti->abstract = true;
  16.     }
  17.     if (type_is_ancestor(ti, type_interface)) {
  18.         assert(ti->instance_size == 0);
  19.         assert(ti->abstract);
  20.         assert(!ti->instance_init);
  21.         assert(!ti->instance_post_init);
  22.         assert(!ti->instance_finalize);
  23.         assert(!ti->num_interfaces);
  24.     }
  25.     ti->class = g_malloc0(ti->class_size);
  26.  
  27.     parent = type_get_parent(ti);
  28.     if (parent) {
  29.         type_initialize(parent);
  30.         GSList *e;
  31.         int i;
  32.  
  33.         g_assert(parent->class_size <= ti->class_size);
  34.         g_assert(parent->instance_size <= ti->instance_size);
  35.         memcpy(ti->class, parent->class, parent->class_size);
  36.         ti->class->interfaces = NULL;
  37.  
  38.         for (e = parent->class->interfaces; e; e = e->next) {
  39.             InterfaceClass *iface = e->data;
  40.             ObjectClass *klass = OBJECT_CLASS(iface);
  41.  
  42.             type_initialize_interface(ti, iface->interface_type, klass->type);
  43.         }
  44.  
  45.         for (i = 0; i < ti->num_interfaces; i++) {
  46.             TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
  47.             if (!t) {
  48.                 error_report("missing interface '%s' for object '%s'",
  49.                              ti->interfaces[i].typename, parent->name);
  50.                 abort();
  51.             }
  52.             for (e = ti->class->interfaces; e; e = e->next) {
  53.                 TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
  54.  
  55.                 if (type_is_ancestor(target_type, t)) {
  56.                     break;
  57.                 }
  58.             }
  59.  
  60.             if (e) {
  61.                 continue;
  62.             }
  63.  
  64.             type_initialize_interface(ti, t, t);
  65.         }
  66.     }
  67.  
  68.     ti->class->properties = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
  69.                                                   object_property_free);
  70.  
  71.     ti->class->type = ti;
  72.  
  73.     while (parent) {
  74.         if (parent->class_base_init) {
  75.             parent->class_base_init(ti->class, ti->class_data);
  76.         }
  77.         parent = type_get_parent(parent);
  78.     }
  79.  
  80.     if (ti->class_init) {
  81.         ti->class_init(ti->class, ti->class_data);
  82.     }
  83. }

type_initialize函数比较长，分段进行解析。

函数的参数（入参）是表示类型信息的TypeImpl类型的对象ti的地址或指针。type_initialize函数首先判断ti->class是否存在，如果不为空，则说明这个类型已经初始化过了，直接返回。

后边主要做了三件事：

（1）设置相关的field，如class_size和instance_size，并使用ti->class_size分配一个ObjectClass。代码片段如下： 

  1.     ti->class_size = type_class_get_size(ti);
  2.     ti->instance_size = type_object_get_size(ti);
  3.     /* Any type with zero instance_size is implicitly abstract.
  4.      * This means interface types are all abstract.
  5.      */
  6.     if (ti->instance_size == 0) {
  7.         ti->abstract = true;
  8.     }
  9.     if (type_is_ancestor(ti, type_interface)) {
  10.         assert(ti->instance_size == 0);
  11.         assert(ti->abstract);
  12.         assert(!ti->instance_init);
  13.         assert(!ti->instance_post_init);
  14.         assert(!ti->instance_finalize);
  15.         assert(!ti->num_interfaces);
  16.     }
  17.     ti->class = g_malloc0(ti->class_size);

为便于理解，再贴一下TypeImpl结构的定义（在qom/object.c中）： 

  1. truct TypeImpl
  2. {
  3.     const char *name;
  4.  
  5.     size_t class_size;
  6.  
  7.     size_t instance_size;
  8.     size_t instance_align;
  9.  
  10.     void (*class_init)(ObjectClass *klass, void *data);
  11.     void (*class_base_init)(ObjectClass *klass, void *data);
  12.  
  13.     void *class_data;
  14.  
  15.     void (*instance_init)(Object *obj);
  16.     void (*instance_post_init)(Object *obj);
  17.     void (*instance_finalize)(Object *obj);
  18.  
  19.     bool abstract;
  20.  
  21.     const char *parent;
  22.     TypeImpl *parent_type;
  23.  
  24.     ObjectClass *class;
  25.  
  26.     int num_interfaces;
  27.     InterfaceImpl interfaces[MAX_INTERFACES];
  28. };

（2）（递归）初始化所有父类型，不仅包括实际的类型，还包括接口这种抽象类型。代码片段如下： 

  1.     parent = type_get_parent(ti);
  2.     if (parent) {
  3.         type_initialize(parent);
  4.         GSList *e;
  5.         int i;
  6.  
  7.         g_assert(parent->class_size <= ti->class_size);
  8.         g_assert(parent->instance_size <= ti->instance_size);
  9.         memcpy(ti->class, parent->class, parent->class_size);
  10.         ti->class->interfaces = NULL;
  11.  
  12.         for (e = parent->class->interfaces; e; e = e->next) {
  13.             InterfaceClass *iface = e->data;
  14.             ObjectClass *klass = OBJECT_CLASS(iface);
  15.  
  16.             type_initialize_interface(ti, iface->interface_type, klass->type);
  17.         }
  18.  
  19.         for (i = 0; i < ti->num_interfaces; i++) {
  20.             TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
  21.             if (!t) {
  22.                 error_report("missing interface '%s' for object '%s'",
  23.                              ti->interfaces[i].typename, parent->name);
  24.                 abort();
  25.             }
  26.             for (e = ti->class->interfaces; e; e = e->next) {
  27.                 TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
  28.  
  29.                 if (type_is_ancestor(target_type, t)) {
  30.                     break;
  31.                 }
  32.             }
  33.  
  34.             if (e) {
  35.                 continue;
  36.             }
  37.  
  38.             type_initialize_interface(ti, t, t);
  39.         }
  40.     }
  41.  
  42.     ti->class->properties = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
  43.                                                   object_property_free);
  44.  
  45.     ti->class->type = ti;

（3）依次调用所有父类的class_base_init以及自己的class_init函数。这也和C++类似，在初始化一个对象的时候会依次调用所有父类的构造函数。 

  1.     while (parent) {
  2.         if (parent->class_base_init) {
  3.             parent->class_base_init(ti->class, ti->class_data);
  4.         }
  5.         parent = type_get_parent(parent);
  6.     }
  7.  
  8.     if (ti->class_init) {
  9.         ti->class_init(ti->class, ti->class_data);
  10.     }

实际上，type_initialize函数可以在很多地方调用，不过，只有在第一次调用的时候会进行初始化，之后的调用会由于ti->class不为空，在函数开始处就直接返回了。

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

举报

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

取消

确定