Linux内核中的一个list实现的理解

于 2022-09-30 21:12:45 发布
阅读量452 收藏
点赞数
文章标签： 链表 c++ 指针 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mseaspring/article/details/127131021
版权

一 C中宏的应用

如果我们写个排序方法， 用c语言实现的话，由于没有通用的类型，也没有c++的模板，没有java的泛化，这样不同的数据类型，我们就要实现多个排序方法，比如实现个int的排序方法，实现double类型的排序方法，但是这样重复的代码很多，其实可以用宏来实现。

同样有个需求要我们写个list，如果里面保存的数据类型不同，就要实现多个，这种实现方法会有太多代码重复，用宏实现是个不错的思路，用宏来实现相关函数还可以提升性能， 当然宏也有明显的缺点，比如不利于调试，写不好也容易在展开的时候出错。

二 内核中的一个list的实现

这个list 可以看作是双向链表，具体的实现如下：

#ifndef B4EDBD16_2948_4595_9135_6BBBAF9B6341
#define B4EDBD16_2948_4595_9135_6BBBAF9B6341
/*
 * Tail queue definitions.
 */
#define _TAILQ_HEAD(name, type, qual)                   \
struct name {                               \
    qual type *tqh_first;       /* first element */     \
    qual type *qual *tqh_last;  /* addr of last next element */ \
}
#define TAILQ_HEAD(name, type)  _TAILQ_HEAD(name, struct type,)

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

#define _TAILQ_ENTRY(type, qual)                    \
struct {                                \
    qual type *tqe_next;        /* next element */      \
    qual type *qual *tqe_prev;  /* address of previous next element */\
}
#define TAILQ_ENTRY(type)   _TAILQ_ENTRY(struct type,)
#define TAILQ_END(head)         NULL
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)                  \
    for((var) = TAILQ_FIRST(head), \
        (tvar) = TAILQ_FIRST(head) ? TAILQ_NEXT(TAILQ_FIRST(head), field): NULL ; \
        (var) != TAILQ_END(head);                   \
        (var = tvar), (tvar) = var ? TAILQ_NEXT(var, field): NULL)
/*
 * Tail queue functions.
 */
#define TAILQ_INIT(head) do {                       \
    (head)->tqh_first = NULL;                   \
    (head)->tqh_last = &(head)->tqh_first;              \
} while (/*CONSTCOND*/0)

#define TAILQ_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 TAILQ_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 TAILQ_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 TAILQ_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 TAILQ_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 TAILQ_REPLACE(head, elm, elm2, field) do {          \
    if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)   \
        (elm2)->field.tqe_next->field.tqe_prev =        \
            &(elm2)->field.tqe_next;                \
    else                                \
        (head)->tqh_last = &(elm2)->field.tqe_next;     \
    (elm2)->field.tqe_prev = (elm)->field.tqe_prev;         \
    *(elm2)->field.tqe_prev = (elm2);               \
    _Q_INVALIDATE((elm)->field.tqe_prev);               \
    _Q_INVALIDATE((elm)->field.tqe_next);               \
} while (0)
#define TAILQ_FOREACH(var, head, field)                 \
    for ((var) = ((head)->tqh_first);               \
        (var);                          \
        (var) = ((var)->field.tqe_next))

#define TAILQ_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)))

#define TAILQ_CONCAT(head1, head2, field) do {              \
    if (!TAILQ_EMPTY(head2)) {                  \
        *(head1)->tqh_last = (head2)->tqh_first;        \
        (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
        (head1)->tqh_last = (head2)->tqh_last;          \
        TAILQ_INIT((head2));                    \
    }                               \
} while (/*CONSTCOND*/0)

/*
 * Tail queue access methods.
 */
#define TAILQ_EMPTY(head)       ((head)->tqh_first == NULL)
#define TAILQ_FIRST(head)       ((head)->tqh_first)
#define TAILQ_NEXT(elm, field)      ((elm)->field.tqe_next)

#define TAILQ_LAST(head, headname) \
    (*(((struct headname *)((head)->tqh_last))->tqh_last))
#define TAILQ_PREV(elm, headname, field) \
    (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
#endif /* B4EDBD16_2948_4595_9135_6BBBAF9B6341 */

利用这个宏实现的小例子：

typedef struct _stu {
 char name[54];
 int age;
        // 在链表成员中的使用
 TAILQ_ENTRY(_stu) next;
} stu;

typedef struct _sch {
        // 链表
 TAILQ_HEAD(_stu_head, _stu) stu_list;
} sch;


int main(int argc, char **argv)
{
 sch *psch = (sch *)calloc(1, sizeof(sch));
         // 链表初始化
 TAILQ_INIT(& (psch->stu_list));

 stu s1 = {.name = "s1", .age = 1};
 stu s2 = {.name = "s2", .age = 2};
 stu s3 = {.name = "s3", .age = 3};
 stu s4 = {.name = "s4", .age = 4};
 stu s5 = {.name = "s5", .age = 5};
 stu s6 = {.name = "s6", .age = 6};

         // 在list前面插入
 TAILQ_INSERT_HEAD(&(psch->stu_list), &s1, next);
 TAILQ_INSERT_HEAD(&(psch->stu_list), &s2, next);

        // 在list的队尾插入
 TAILQ_INSERT_TAIL(&(psch->stu_list), &s3, next);
 TAILQ_INSERT_TAIL(&(psch->stu_list), &s5, next);

        // 在特定元素前面插入
 TAILQ_INSERT_BEFORE(&s5, &s4, next);
 TAILQ_INSERT_TAIL(&(psch->stu_list), &s6, next);
  printf("queue_head:%p, first:%p, last:%p\n", (void*)&(psch->stu_list), (void*)(psch->stu_list).tqh_first, (void*)(psch->stu_list).tqh_last);

 stu *p = NULL;
         // 正向遍历
 TAILQ_FOREACH(p, &(psch->stu_list), next) {
    printf("item:%p, next:%p, &next:%p, prev:%p, *prev:%p\n", p,p->next.tqe_next, &p->next.tqe_next,p->next.tqe_prev,& p->next.tqe_prev);
  printf("name:%s\t age:%d\n", p->name, p->age);
 }
 printf("---------------------------------\n");

       // 反向遍历
 TAILQ_FOREACH_REVERSE(p, &(psch->stu_list), _stu_head, next) {
  printf("name:%s\t age:%d\n", p->name, p->age);
 } 
        free(psch);
 return 0;
}

三 示意图说明

3.1 获取链表的最后一个元素

上述链表的示意图如下：f858d1607a8734b495834fabe8b0160b.png

注意这个链表和我们一般自己在初学c语言的链表不一样，这个里面的tqe_prev指向的不是前一个元素，而是指向前一个元素的tqe_next, 注意这个tqe_next是在stu里面的next的成员里面的。

这个宏有个比较难以理解的地方，就是得到最后一个元素和得到前一个元素：

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

我们拿一个来解释TAILQ_LAST，如下图展示： 假如有如下的list：e8d0056196b709fb2ae0bb55e83eb562.png获取最后一个元素的示意图如下：0e18772023272d1a8f92190100aa5ec1.png

TAILQ_LAST分为两步：

1. 获取tqh_last 指针，即指到最后一个元素的tqe_next;
2. 通过最后一个元素的tqe_next 获取到指向最后一个元素即绿色的stu的地址。

第一步很容易理解，通过(head)->tqh_last 获取到最后一个元素的tqe_next. 第二步很难理解，因为它把这个地址强制转成队列，成员怎么转成队列那，那是因为两个都是指针，指针的大小都是一样的，而且都是两个指针变量，所以可以互转，转了之后可以看到如上图的对应关系,tqe_next 变成了队列的tqh_first 了、同样tqe_prev也就变成了tqh_last,而tqh_last 即tqe_prev指向黄色元素的tqe_next了，然后通过* 取值即变成了绿色的stu的地址，即最后一个元素的地址了。

3.2 插入元素

#define TAILQ_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)

再画个插入的示意图：1f9c12d29b1628bf6ec23ad9a4ba538a.png

插入一个元素：1c65cda56e6844697ef7ae5efeb06703.png线条上的数字即插入的顺序。

再次插入一个元素：fb4c4742ce146aabff499d38ec14f49a.png

最终形成的链表：672d1c1fb776800827eed67a2312f5a6.png

3.3 宏调试相关

宏在调试之前，我们可以先通过gcc命令进行展开,可以获取到展开宏的源码。

gcc -E -P main.c > main.expand.c

在gdb调试的时候，可以通过：

gdb) macro expand 宏

gcc编译的时候、添加-g3 便于调试宏

gcc -g3

四 参考

https://www.361shipin.com/blog/1534986025145729024
https://www.getdami.com/questions/wei-dui-lie-dai-ma-zhong-de-tailq_lastzen-yao-li-jie-89811/
mseaspring
关注
linux内核list
阎松的博客
07-24 492
linux list详解 1 链表结构定义 首先 看链表的定义，位于：include\linux\types.h truct list_head { struct list_head *next, *prev; }; 一般将该数据结构嵌入到其他的数据结构中，从而使得内核可以通过链表的方式管理新的数据结构，比如struct device中： struct device { struct device *parent; struct device_pr
linux内核中list的基本用法
最新发布
qq_45528033的博客
07-17 354
linux内核list基本用法
linux源码分析之list的实现
李白
09-11 661
linux内核中list的实现
Linux内核list_head学习（二）
weixin_33915554的博客
06-02 133
前一篇文章讨论了list_head 结构的基本结构和实现原理，本文主要介绍一下实例代码。 自己如果想在应用程序中使用list_head 的相应操作（当然应该没人使用了，C++ STL提供了list 用起来貌似更方便）， 在应用程序中需要包含自己的 "list.h" 头文件： /* 注：这个list.h 是为了配合示例程序而建的，内容来自：linux/include/linux/list....
Linux list实现
hyolin
02-06 417
#ifndef _LINUX_LIST_H#define _LINUX_LIST_H#include #include #include #include /* * Simple doubly linked list implementation. * * Some of the internal functions ("__xxx") are useful when * manipulating
linux内核中的list详解
小C的博客
12-07 615
linux内核中的list详解 原因: file_operation 结构中的open函数定义如下： int (*open)(struct inode *inode, struct file* filp); inode中含有i_cdev属性，它描述的是字符设备。在自己定义的字符设备中，一般会包含字符设备的指针，而open方法被调用时，通常需要获取特定的设备对象，这里
kernel_list_and_hash_table.tar.gz_Table_linux内核 list
09-20
通过阅读"kernel_list_and_hash_table.pdf"这份文档，你可以深入理解这两种数据结构在Linux内核中的实现细节和应用场景。这将有助于你更全面地了解内核的工作原理，以及如何利用这些数据结构优化系统性能。 总的来...
Linux内核设备驱动之内核中链表的使用笔记整理
09-15
内核提供了一系列操作链表的函数，例如`list_add`用于在指定节点后插入新节点，`list_add_tail`则在指定节点前插入，`list_del`用于删除节点，`list_move`将节点从一个链表移动到另一个链表，而`list_splice`则用于...
Linux内核中的链表——struct list_head
zsffzb的博客
06-12 1784
Linux内核中链表介绍_晴天_QQ的博客-CSDN博客_linux 链表链表是Linux内核中最简单、最普通的数据结构。链表是一种存放和操作可变数量元素(常称为节点)的数据结构。链表和静态数组的不同之处在于，它所包含的元素都是动态创建并插入链表的，在编译时不必知道具体需要创建多少个元素。另外也因为链表中每个元素的创建时间各不相同，所以它们在内存中无须占用连续内存区。正是因为元素不连续地存放，所以各元素需要通过某种方式被连接在一起。于是每个元素都包含一个指向下一个元素的...https://blog.csd
内核Linux链表的实现.zip
12-07
Linux内核中的链表是通过定义一个名为`list_head`的结构体来实现的。这个结构体包含三个成员：`next`、`prev`和`__align Pad`。`next`和`prev`指针分别指向链表中的下一个和上一个元素，而`__align Pad`是为了内存...
Linux内核之list_head
09-01
在Linux内核中，链表数据结构的实现主要集中在`include/linux/list.h`文件中。尽管本节以2.6内核为例，但2.4内核中的链表结构与其基本一致，仅有一些扩展，如链表的读拷贝更新(RCU)和HASH链表(hlist)等。 **基本...
Linux源码List.h文件详细分析(链表、队列、堆栈、哈希表等)
11-15
对Linux内核源码中list.h文件自己分析总结，主要是一些双向循环链表的操作及一些数据结构的实现，方便借鉴引用。
Linux内核list&hlist;解读
04-04
目录 1. 前言 2 2. 通用宏 2 2.1. typeof 2 2.1.1. 定义 3 2.1.2. 用途 3 2.1.3. 示例 3 2.2. offset_of 3 2.2.1. 定义 3 2.2.2. 作用 3 2.2.3. 原理 3 2.2.4. 示例 3 2.3. container_of 4 2.3.1. 定义 4 2.3.2. 作用 4 2.3.3. 示例 4 2.4. prefetch 4 2.4.1. 定义 4 2.4.2. 作用 4 3. list 5 3.1. list结构 5 3.1.1. 定义 5 3.1.2. 作用 5 3.1.3. 解读 5 3.1.4. 示例 5 3.2. 遍历方向 6 3.3. list_entry 6 3.3.1. 定义 6 3.3.2. 作用 7 3.4. list_for_each 7 3.4.1. 定义 7 3.4.2. 作用 7 3.4.3. 示例 7 3.5. __list_for_each 8 3.5.1. 定义 8 3.5.2. 作用 8 3.6. list_for_each_prev 8 3.6.1. 定义 8 3.6.2. 作用 8 3.7. list_for_each_safe 8 3.7.1. 定义 8 3.7.2. 作用 9 3.7.3. 区别 9 3.7.4. 示例 9 3.8. list_for_each_entry 9 3.8.1. 定义 9 3.8.2. 作用 10 3.8.3. 区别 10 3.8.4. 完整示例 10 3.9. list_for_each_entry_safe 12 3.9.1. 定义 12 3.9.2. 作用 13 3.10. list_for_each_entry_reverse 13 3.10.1. 定义 13 3.10.2. 作用 13 3.11. list_for_each_entry_continue 13 3.11.1. 定义 13 3.11.2. 作用 13 3.11.3. 区别 13 3.12. list_for_each_safe_rcu 14 4. hlist（hash list） 14 4.1. hlist（hash list）结构 14 4.1.1. 简述 14 4.1.2. 定义 14
【内核数据结构】 内核链表分析
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
04-03 3960
一、简介：        Linux中的链表使用两个指针，可以方便的构成双向链表，实际上，通常它都组织成双向循环链表，不同于数据结构书上的链表，这里的节点只有链表指针，没有链表的数据，下边我将对内核中使用的 include/linux/list.h 进行函数说明和生动的图形解释。二、函数：我们先来看看1. 链表数据结构 list_head 的定义：[cpp] view plain copy pri
linux内核list实现
字节跳动 内推找我
12-27 1097
看dahdi驱动的时候，频繁见到struct list_head的相关代码，不是很明白这个链表机制，搜索了一篇文章，叙述相当仔细，文章有点长，不过对链表的原理讲解的很仔细。 转载自：http://blog.chinaunix.net/uid-27122224-id-3277511.html 前言：在linux源代码中有个头文件为list.h.很多linux下的源代码都会使用这个头文
内核窥探|在kernel中的链表，其他的链表真的弱爆了
一口Linux的专栏
08-24 950
在Linux内核中，提供了一个用来创建双向循环链表的结构 list_head。虽然linux内核是用C语言写的，但是list_head的引入，使得内核数据结构也可以拥有面向对象的特性，通过使用操作list_head 的通用接口很容易实现代码的重用，有点类似于C++的继承机制（希望有机会写篇文章研究一下C语言的面向对象机制）。 首先找到list_head结构体定义，kernel/inclue/linux/types.h 如下： struct list_head { struct list_head *n
【数据结构】linux 内核的list
bandaoyu的note
06-09 692
前言 linux kernel里的很多数据结构都很经典, list链表就是其中之一,本文将从以下几方面介绍list链表：list的定义、list提供的操作方法、注意事项、使用实例 linux kernel里的很多数据结构都很经典, list链表就是其中之一 本篇要介绍的内容: list的定义 list提供的操作方法 注意事项 使用实例 list链表 1 List 所在文件 List的所有操作可以在include/linux/list.h找到; L...
Linux中链表（list.h）的实现原理
wzf1993的博客
10-08 719
原文地址：http://wuzufei.cn/linux_list.html 1 概述 通常情况下，我们使用C语言实现定义的链表节点形式如下： struct Node { int data; struct Node* next; }; 常规使用一个结构体定义节点，然后在每个节点中保存前驱/后继节点的首地址，通过遍历每个节点中的next成员访问下一个节点； 而在linux 的内核实现中，链表节点定义方式如下： struct list_head { struct
理解Linux内核：list_head双向链表解析
在Linux内核中，`list_head`是一个非常重要的数据结构，它用于实现双向链表。双向链表是一种数据结构，其中每个节点包含两个指针，一个指向下一个节点，另一个指向前一个节点，允许双向遍历。`list_head`结构本身并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值