QEMU代码中的QLIST

最新推荐文章于 2024-08-07 20:45:18 发布
最新推荐文章于 2024-08-07 20:45:18 发布
阅读量3.6k 收藏 3
点赞数
分类专栏： KVM/QEMU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majieyue/article/details/40249859
版权

下面会陆续写一些KVM、QEMU相关的学习笔记，个人觉得KVM相比Xen而言真的简单很多，当然前提是你对Linux内核得非常熟悉，我也建议虚拟化的初学者不要去碰Xen，直接学习KVM就好。而QEMU则是另一个大头，无论Xen还是KVM都绕不开这个苦主，而无论是Xen还是KVM都离不开Qemu，而且在Qemu领域融合的也越来越好，最新upstream的Qemu已经可以同时支持Xen/KVM了，真心赞一下redhat

本文先分析下Qemu里用到的工具类QLIST，代码在include/qemu/queue.h中，主要是从netbsd系统里port过来的

QLIST是类似linux hlist类型的double linked list结构体，其结构体定义如下

#define QLIST_HEAD(name, type)                                          \
struct name {                                                           \
        struct type *lh_first;  /* first element */                     \
}

#define QLIST_HEAD_INITIALIZER(head)                                    \
        { NULL }

#define QLIST_ENTRY(type)                                               \
struct {                                                                \
        struct type *le_next;   /* next element */                      \
        struct type **le_prev;  /* address of previous next element */  \
}
几个操作宏如下 
#define QLIST_INSERT_AFTER(listelm, elm, field) do {                    \
        if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)  \
                (listelm)->field.le_next->field.le_prev =               \
                    &(elm)->field.le_next;                              \
        (listelm)->field.le_next = (elm);                               \
        (elm)->field.le_prev = &(listelm)->field.le_next;               \
} while (/*CONSTCOND*/0)

#define QLIST_INSERT_BEFORE(listelm, elm, field) do {                   \
        (elm)->field.le_prev = (listelm)->field.le_prev;                \
        (elm)->field.le_next = (listelm);                               \
        *(listelm)->field.le_prev = (elm);                              \
        (listelm)->field.le_prev = &(elm)->field.le_next;               \
} while (/*CONSTCOND*/0)

#define QLIST_INSERT_HEAD(head, elm, field) do {                        \
        if (((elm)->field.le_next = (head)->lh_first) != NULL)          \
                (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
        (head)->lh_first = (elm);                                       \
        (elm)->field.le_prev = &(head)->lh_first;                       \
} while (/*CONSTCOND*/0)

#define QLIST_INSERT_HEAD_RCU(head, elm, field) do {                    \
        (elm)->field.le_prev = &(head)->lh_first;                       \
        (elm)->field.le_next = (head)->lh_first;                        \
        smp_wmb(); /* fill elm before linking it */                     \
        if ((head)->lh_first != NULL)  {                                \
            (head)->lh_first->field.le_prev = &(elm)->field.le_next;    \
        }                                                               \
        (head)->lh_first = (elm);                                       \
        smp_wmb();                                                      \
} while (/* CONSTCOND*/0)

#define QLIST_REMOVE(elm, field) do {                                   \
        if ((elm)->field.le_next != NULL)                               \
                (elm)->field.le_next->field.le_prev =                   \
                    (elm)->field.le_prev;                               \
        *(elm)->field.le_prev = (elm)->field.le_next;                   \
} while (/*CONSTCOND*/0)

#define QLIST_FOREACH(var, head, field)                                 \
        for ((var) = ((head)->lh_first);                                \
                (var);                                                  \
                (var) = ((var)->field.le_next))

#define QLIST_FOREACH_SAFE(var, head, field, next_var)                  \
        for ((var) = ((head)->lh_first);                                \
                (var) && ((next_var) = ((var)->field.le_next), 1);      \
                (var) = (next_var))
这些操作宏，可以对比内核里的hlist_xxxx的相同操作，两者完全一致

QSLIST 指的是one-way的list结构体，比较简单本文就不分析了

QTAILQ的数据结构其实和QLIST差不多，只是head里面多了一个指向最后一个元素的指针的地址，其定义如下

#define Q_TAILQ_HEAD(name, type, qual)                                  \
struct name {                                                           \
        qual type *tqh_first;           /* first element */             \
        qual type *qual *tqh_last;      /* addr of last next element */ \
}
#define QTAILQ_HEAD(name, type)  Q_TAILQ_HEAD(name, struct type,)

#define QTAILQ_HEAD_INITIALIZER(head)                                   \
        { NULL, &(head).tqh_first }

#define Q_TAILQ_ENTRY(type, qual)                                       \
struct {                                                                \
        qual type *tqe_next;            /* next element */              \
        qual type *qual *tqe_prev;      /* address of previous next element */\
}
#define QTAILQ_ENTRY(type)       Q_TAILQ_ENTRY(struct type,)
上述代码写得还是蛮坑人的，至少我第一次看的时候，就对这个qual百思不得其解，后来才发现其实真正用的时候，根本就没有定义qual，所以其实可以简化为这个 

#define Q_TAILQ_HEAD(name, type)                                  \
struct name {                                                           \
        type *tqh_first;           /* first element */             \
        type **tqh_last;      /* addr of last next element */ \
}
#define QTAILQ_HEAD(name, type)  Q_TAILQ_HEAD(name, struct type,)

#define QTAILQ_HEAD_INITIALIZER(head)                                   \
        { NULL, &(head).tqh_first }

#define Q_TAILQ_ENTRY(type)                                       \
struct {                                                                \
        type *tqe_next;            /* next element */              \
        type **tqe_prev;      /* address of previous next element */\
}
#define QTAILQ_ENTRY(type)       Q_TAILQ_ENTRY(struct type)
注意，这里的tqh_last指针，指的是tailq最后一个元素的tqe_next指针本身的&地址，具体可以看下面的QTAILQ相关操作函数 

#define QTAILQ_INIT(head) do {                                          \
        (head)->tqh_first = NULL;                                       \
        (head)->tqh_last = &(head)->tqh_first;                          \
} while (/*CONSTCOND*/0)

#define QTAILQ_INSERT_HEAD(head, elm, field) do {                       \
        if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)        \
                (head)->tqh_first->field.tqe_prev =                     \
                    &(elm)->field.tqe_next;                             \
        else                                                            \
                (head)->tqh_last = &(elm)->field.tqe_next;              \
        (head)->tqh_first = (elm);                                      \
        (elm)->field.tqe_prev = &(head)->tqh_first;                     \
} while (/*CONSTCOND*/0)

#define QTAILQ_INSERT_TAIL(head, elm, field) do {                       \
        (elm)->field.tqe_next = NULL;                                   \
        (elm)->field.tqe_prev = (head)->tqh_last;                       \
        *(head)->tqh_last = (elm);                                      \
        (head)->tqh_last = &(elm)->field.tqe_next;                      \
} while (/*CONSTCOND*/0)

#define QTAILQ_INSERT_AFTER(head, listelm, elm, field) do {             \
        if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
                (elm)->field.tqe_next->field.tqe_prev =                 \
                    &(elm)->field.tqe_next;                             \
        else                                                            \
                (head)->tqh_last = &(elm)->field.tqe_next;              \
        (listelm)->field.tqe_next = (elm);                              \
        (elm)->field.tqe_prev = &(listelm)->field.tqe_next;             \
} while (/*CONSTCOND*/0)

#define QTAILQ_INSERT_BEFORE(listelm, elm, field) do {                  \
        (elm)->field.tqe_prev = (listelm)->field.tqe_prev;              \
        (elm)->field.tqe_next = (listelm);                              \
        *(listelm)->field.tqe_prev = (elm);                             \
        (listelm)->field.tqe_prev = &(elm)->field.tqe_next;             \
} while (/*CONSTCOND*/0)

#define QTAILQ_REMOVE(head, elm, field) do {                            \
        if (((elm)->field.tqe_next) != NULL)                            \
                (elm)->field.tqe_next->field.tqe_prev =                 \
                    (elm)->field.tqe_prev;                              \
        else                                                            \
                (head)->tqh_last = (elm)->field.tqe_prev;               \
        *(elm)->field.tqe_prev = (elm)->field.tqe_next;                 \
} while (/*CONSTCOND*/0)

#define QTAILQ_FOREACH(var, head, field)                                \
        for ((var) = ((head)->tqh_first);                               \
                (var);                                                  \
                (var) = ((var)->field.tqe_next))

#define QTAILQ_FOREACH_SAFE(var, head, field, next_var)                 \
        for ((var) = ((head)->tqh_first);                               \
                (var) && ((next_var) = ((var)->field.tqe_next), 1);     \
                (var) = (next_var))
上述代码还是比较直观的，和linux内核中的hlist_xxxx宏也大同小异，除了我之前提到过的head->tqh_last指针，里面的地址实际上是队列最后一个元素的&elem->tqh_next的指针本身地址。下面来看QTAILQ中比较难理解的部分： 

#define QTAILQ_LAST(head, headname) \
        (*(((struct headname *)((head)->tqh_last))->tqh_last))
#define QTAILQ_PREV(elm, headname, field) \
        (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

#define QTAILQ_FOREACH_REVERSE(var, head, headname, field)              \
        for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));    \
                (var);                                                  \
                (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))

QTAILQ_LAST作用是拿到队列最后一个元素的指针，但由于没有container_of宏，加之无法确定QTAILQ_ENTRY在元素结构体中的位置，所以代码变得非常晦涩

head首先是QTAILQ_ENTRY结构体的指针，这个QTAILQ_ENTRY结构体做为field成员存在于element结构体中，所以首先，head->tgh_last指向了最后一个元素&elm->field.tgh_next指针所在的地址。这里我们并不关心tgh_next指针的内容，只关心tgh_next本身的地址，因为要通过tgh_next拿到下一个指针地址，所以首先做一次转化，即

(struct headname *)((head)->tgh_last)，这个转换之后返回的地址，可以认为是最后一个元素QTAILQ_ENTRY部分（field成员）的开头地址，但注意这里是通过struct headname *来进行指针转化的，因此只能通过tgh_last来拿到tge_prev（这里要绕一下，因为tgh_last和tge_prev其实是同一个位置，所以这样做是没问题的）

最后，由于tgh_prev指向的是元素地址的指针，所以最后通过*拿到真正最后一个元素的地址，是一个struct type* 的指针，指向了最后一个元素

理解了这个，QTAILQ_PREV也不难理解了，这个宏用来拿到队列之前一个元素的指针，但为了拿到这个指针，又去找之前的之前的元素，e.g. 假设队列是 A <-- B <-- C 的样子，通过C拿到B的话，最终还得通过A才行，这里就不详细说了，代码里啥都有

这两篇文章也分析了QTAILQ_PREV, QTAILQ_LAST，可以对比参考下

http://www.blogjava.net/bacoo/archive/2010/08/08/328235.html

http://www.cnblogs.com/UnGeek/archive/2013/03/29/2989325.html



majieyue
关注
专栏目录
QEMU源码全解析23 —— QOM介绍（12）
phmatthaus的专栏
08-01 576
QEMU源码全解析23 —— QOM介绍（12）
QEMU源码全解析 —— virtio（8）
phmatthaus的专栏
12-15 688
QEMU源码全解析 —— virtio（8）
qemu QLIST数据结构
ayu_ag的专栏
10-20 1531
queue.h中是qemu使用到的一些基础的数据结构，比如QLIST，QSLIST，QSIMPLEQ，QTAILQ。 本文主要介绍QLIST的数据结构，其它几种数据结构与之类似。QLIST用得比较多，类似于内核的双向链表，嵌入在其他结构体中使用。 链表头 #define QLIST_HEAD(name, type)
【小结】QEMU中的LIST
简思
06-12 689
qemu list
Qt结构体里使用Qlist
mouze的博客
05-22 5133
QList作为结构体的一个成员，当使用该结构体定义一个变量时，会创建一个空白的QList。 struct Score { int mach; int chinese; }; struct Student { int age; QString name; QList<Score> score; //创建一个Student变量时将创建一个空白list }; //----- { QList<Student> students; /.
qlist 对结构体排序
sun
05-31 5297
写法一 QList&amp;lt;test&amp;gt; s; test aa; test bb; test cc; aa.num = &quot;14&quot;; bb.num = &quot;2&quot;; cc.num = &quot;3&quot;; s.append(aa); s.append(bb); s.append(cc);
QEMU介绍
热门推荐
u014288927的博客
09-11 2万+
一、QEMU简介 QEMU是一款开源的模拟器及虚拟机监管器(Virtual Machine Monitor, VMM)。QEMU主要提供两种功能给用户使用。一是作为用户态模拟器，利用动态代码翻译机制来执行不同于主机架构的代码。二是作为虚拟机监管器，模拟全系统，利用其他VMM(Xen, KVM, etc)来使用硬件提供的虚拟化支持，创建接近于主机性能的虚拟机。 用户可以通过不同Linux发行版所...
qemu-kvm 线程事件模型 【QEMU-KVM代码分析之三】
tycoon的专栏
04-17 3006
qemu-kvm 线程事件模型 1.主（父）线程。 主线程执行循环，主要做三件事情 1）.执行select操作，查询文件描述符有无读写操作 2）.执行定时器回调函数 3）.执行下半部（BH）回调函数。为什么要采用BH，资料说主要避免可重入性和调用栈溢出。 2.执行客户机代码的线程 只讨论kvm执行客户机代码情况（不考虑TCG，TCG采用动态翻译技术），如果有多个vcpu，就意味着
QEMU理解与分析系列（2）：QEMU参数相关
最新发布
swh547的博客
08-07 74
其所有的可用选项存储在vl.c维护的QEMUOption数组qemu_options中{ NULL },这就定义了DEF(…)而实际的DEF定义在qemu-options.def中，这个文件是makefile中的脚本根据qemu-options.hx解析出来的，所以在make后才会生成。用户的参数会放到一个三级列表中，即QemuOptsList(相同参数的组合列表，例如参数中由多个-device,则他们会被放在一个QemuOptsList。
双重qlist用法
04-26
当碰上需要QList套用QlList，即QList，结果往往无法预知，显示未知信息，但有时候就是想用双重list，如何做呢？本程序给出了示例。
Qt学习——QList + 结构体 注意事项
shawn06
11-29 7946
注意 Qlist 使用结构体时，不能使用foreach进行遍历，会报错“==”操作符重载有问题。但是可以使用for进行遍历
算法基础之基础数据结构
pwy1024的博客
11-14 423
算法与数据结构的关系是密不可分的。在很多复杂的算法实现过程中，我们都会先考虑如何设计它的数据结构使得算法实现变得简单，如何组织数据能够获得最佳的性能，所以这里准备写一些算法当中使用到的基础的数据结构，它们可以说是进一步学习算法的基石。   本文首先介绍一下线性数据结构，其余数据结构后续会继续进行补充     线性数据结构的存储方式分为顺序存储和链式存储，对于顺序存储一般对应的也就是程序
QList 存储自定义结构体对象情况下,如何在迭代中判断条件并删除?
ganggegel的博客
05-22 3008
网上的例子都是简单的整型或者字符串操作, 使用foreach,或者iterator,removeOne(value); 但是实际用自定义结构体时,循环迭代删除时报错: 没有 == ; 原因是removeOne();或者其它删除操作,括号中的值实际上要去list中去判等操作,自定义结构体没有重载 ==符号,只要重载即可. typedef struct box { QString test1; QString test2; int test; bool operator...
QT QList＜T＞介绍与应用、详解、使用说明、官方手册翻译
ken2232的博客
08-02 2838
QT QList＜T＞介绍与应用、详解、使用说明、官方手册翻译
list结构体根据某个成员进行排序
fujilove的专栏
03-19 1919
#include #include using namespace std; struct camerafoucs { int index; int value; bool operator<(camerafoucs b) { return value<b.value; } }; int main() { camerafoucs foucsva
QList添加自定义结构体
sinple123456的专栏
05-21 6474
QList中使用自定义结构体后，构建错误信息如下： 看内容是说需要重载==，遂进行重载，如下： 重新构建，不再提示错误。
list_for_each_safe()
听
10-25 1905
<br />如果在遍历过程中，包含有删除或移动当前链接节点的操作，由于这些操作会修改遍历指针，这样会导致遍历的中端。这种情况下，必须使用list_for_each_safe宏，在操作之前将遍历指针缓存下来。内核中解释的精华部分：<br />/*<br /> list_for_each_safe                 -iterate over a list safe against removal of list entry<br />*/<br />#define list_for_each_s
需要list_for_each_safe的原因
nomadcircle的专栏
12-22 2643
<br />#define list_for_each(pos, head) /<br />for (pos = (head)->next; prefetch(pos->next), pos != (head); /<br />pos = pos->next)<br />由定义可知，list_del(pos)(将pos的前后指针指向undefined state)panic，list_del_init(pos)(将pos前后指针指向自身)导致死循环。<br /><br />#define list_for_
QEMU的代码结构分析
05-18
QEMU是一款开源的虚拟化软件，其代码结构如下： 1. `hw`目录：该目录下包含所有硬件模拟器的实现，其中每个子目录对应不同的硬件设备，例如`arm`对应ARM架构的硬件设备模拟器，`net`对应网络设备模拟器等。 2. `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值