您的位置: 首页  >  文章  >  【Linux内核数据结构】最为经典的链表list

【Linux内核数据结构】最为经典的链表list

分类: 文章 • 2023-12-16 08:36:40

From : https://blog.****.net/wenqian1991/article/details/44515713

很久之前研读过Linux的内核源码，看到其中的内核数据结构，对链表的实现叹为观止，是迄今为止我见过的最为经典的链表实现（不是数据内嵌到链表中，而是把链表内嵌到数据对象中）。现在再来回顾这个经典的数据结构。

链表代码在头文件<linux/list.h>中声明（推荐Source Insight，源码版本：Linux-2.6.32.61，早期版本并没有引进这个list），其数据结构很简单有木有，直接就一个前后链表指针，前篇STL中list也有这么个结构

1、链表的初始化

[cpp] view plain copy
  1. struct list_head {  
  2.     struct list_head *next, *prev;  
  3. };  
初始化是一个双向链表，还是环状的，这和stl中的list是一样的。下面是形成一个空链表，list作为头指针（不是头节点）
[cpp] view plain copy
  1. static inline void INIT_LIST_HEAD(struct list_head *list)  
  2. {  
  3.     list->next = list;  
  4.     list->prev = list;  
  5. }  
看看下面的宏生成一个头指针name
[cpp] view plain copy
  1. #define LIST_HEAD_INIT(name) { &(name), &(name) }  
  2.   
  3. #define LIST_HEAD(name) \  
  4.     struct list_head name = LIST_HEAD_INIT(name)  
两者合一实际就是下面这个样子
[cpp] view plain copy
  1. struct list_head name = { &(name), &(name) }  

2、访问数据

这恐怕就是Linux内核数据结构链表的最难理解的地方了吧，前面说了，内核链表不同于普通链表的是，它是内嵌到数据对象中，这么说来，就是同类型的对象内部都嵌有这个链表，并且是通过这个链表穿针引线在一起，我们关心的是对象中的数据内容，那么究竟是如何通过对象内部的链表来访问其中的数据内容的呢？

[cpp] view plain copy
  1. #define list_entry(ptr, type, member) \  
  2.     container_of(ptr, type, member)  
宏定义转到：

[cpp] view plain copy
  1. #define container_of(ptr, type, member) ({          \  
  2.     const typeof(((type *)0)->member)*__mptr = (ptr);    \  
  3.     (type *)((char *)__mptr - offsetof(type, member));})  
咋呼了一下，还有个：

[cpp] view plain copy
  1. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)  
这一大串的指针操作，别急，从后往前一步步分析：
[cpp] view plain copy
  1. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)  
将0x0地址强制转换为TYPE*类型，然后取TYPE中的成员MEMBER地址，因为起始地址为0，得到的MEMBER的地址就直接是该成员相对于TYPE对象的偏移地址了。

所以该语句的功能是：得到TYPE类型对象中MEMBER成员的地址偏移量。

[cpp] view plain copy
  1. #define container_of(ptr, type, member) ({          \  
  2.     const typeof(((type *)0)->member)*__mptr = (ptr);    \  
  3.     (type *)((char *)__mptr - offsetof(type, member));})  
这个‘怪物’，先看第一条：const typeof(((type *)0)->member)*__mptr = (ptr); 首先将0x0转换为TYPE类型的指针变量，再引用member成员，typeof(x)返回的是x的数据类型，所以typeof(((type *)0)->member)返回的就是member成员的数据类型，该语句就是将__mptr强制转换为member成员的数据类型，然后再将ptr赋给它。ptr本来就是指向member的指针；
说白了，就是定义一个member成员类型的指针变量，然后将ptr赋给它。

好，来看下一条语句：
先将__mptr强制转换为char*类型（因为char* 类型进行加减的话，加减量为sizeof(char)*offset，char占一个字节空间，这样指针加减的步长就是1个字节，实现加一减一。）实现地址的精确定位，如果不这样的话，假如原始数据类型是int，那么这减去offset，实际上就是减去sizeof(int *)*offset 的大小了。
所以整体意思就是：得到指向type的指针，已知成员的地址，然后减去这个成员相对于整个结构对象的地址偏移量，不就得到这个数据对象的地址么

最后看

[cpp] view plain copy
  1. #define list_entry(ptr, type, member) \  
  2.     container_of(ptr, type, member)  
有了前面的剖析，好理解了，该宏定义作为右值，返回type类型对象的地址。

type->member，表明member是type中的成员，所以可以得知member是内嵌的链表，type则是对象指针，那么ptr是链表类型指针，并且是属于那个穿针引线的链表中的某一个链表节点，所有的对象结构都挂在ptr所在的链表上。

该宏定义可以返回ptr对应链表节点的对象的地址。关键是对应，找到的对象的地址是ptr这个链表所对应的那个对象的地址。ptr和member之间的关系就是，ptr是member类型的指针。

其实上面就是地址的强制转换，然后得到偏移量之类的，就是指针，而且上面有个特点，那就是跟结构体中的内存对齐无关。

这里额外补充一个关于指针方面的：

[cpp] view plain copy
  1. (*(void(*)())0)();  
对于这类，从里往外分析，谁叫人家优先级高呢。

先看最里面void(*)()，定义一个函数指针，无参无返回值，

(void(*)())0，将0强制转换为函数指针，这样0成了一个地址，而且是函数地址，就是说有个函数存在首地址为0 的一段区域内。

(*(void(*)())0)，取0地址开始的一段内存里面的内容，其内容就是保存在该区域内的函数。

(*(void(*)())0)(); 调用该函数。

所以整个代码的意思就是：调用保存在0地址处的函数（初始化）。扯远了，论指针的重要性。
3、遍历链表（实际是得到指定链表节点对应的数据对象结构）
有了前面的定位某个结构地址，遍历就好办了。

得到第一个节点元素地址

[cpp] view plain copy
  1. #define list_first_entry(ptr, type, member) \  
  2.     list_entry((ptr)->next, type, member)  
上面传入的ptr是将各个type对象串起来的链表的头指针，ptr->next 就是该链表的第一个节点。上面返回值就是挂载在第一个节点上的对象地址。

对象结构就是像下面这样挂载在链表上：

【Linux内核数据结构】最为经典的链表list

访问第一个对象就是：

[cpp] view plain copy
  1. type *type_first_ptr = list_first_entry(type_list, type, list);  
  2. /* 
  3.     type_list为链表头指针，type为对象结构，list为type结构内的链表 
  4. */  
遍历所有数据对象就是：
[cpp] view plain copy
  1. #define list_for_each_entry(pos, head, member)              \  
  2. for (pos = list_entry((head)->next, typeof(*pos), member);   \  
  3.     prefetch(pos->member.next), &pos->member != (head);   \  
  4.     pos = list_entry(pos->member.next, typeof(*pos), member))  
  5. /* 
  6. 实际上就是一个for循环，循环内部由用户自己根据需要定义 
  7. 初始条件：pos = list_entry((head)->next, typeof(*pos), member); pos为第一个对象地址 
  8. 终止条件：&pos->member != (head);pos的链表成员不为头指针，环状指针的遍历终止判断 
  9. 递增状态：pos = list_entry(pos->member.next, typeof(*pos), member) pos为下一个对象地址 
  10. 所以pos就把挂载在链表上的所有对象都给遍历完了。至于访问对象内的数据成员，有多少个，用来干嘛用，则由用户 
  11. 根据自己需求来定义了。 
  12. */  
4、添加元素
[cpp] view plain copy
  1. static inline void __list_add(struct list_head *new,  
  2.                               struct list_head *prev,  
  3.                               struct list_head *next)  
  4. {  
  5.     next->prev = new;  
  6.     new->next = next;  
  7.     new->prev = prev;  
  8.     prev->next = new;  
  9. }  
new元素添加到prev的后面，next的前面。
[cpp] view plain copy
  1. //head是头指针  
  2. //头节点后添加元素，相当于添加头节点，可实现栈的添加元素  
  3. //new添加到head之后，head->next之前  
  4. static inline void list_add(struct list_head *new, struct list_head *head)  
  5. {  
  6.     __list_add(new, head, head->next);  
  7. }  
  8.   
  9. //头节点前添加元素，因为是环状链表所以相当于添加尾节点，可实现队列的添加元素  
  10. //new添加到head->prev之后，head之前  
  11. static inline void list_add_tail(struct list_head *new, struct list_head *head)  
  12. {  
  13.     __list_add(new, head->prev, head);  
  14. }  
5、删除元素
[cpp] view plain copy
  1. //prev和next两个链表指针构成双向链表关系  
  2. static inline void __list_del(struct list_head * prev, struct list_head * next)  
  3. {  
  4.     next->prev = prev;  
  5.     prev->next = next;  
  6. }  
  7.   
  8. //删除指定元素，这是一种安全删除方法，最后添加了初始化  
  9. static inline void list_del_init(struct list_head *entry)  
  10. {  
  11.     //删除entry节点  
  12.     __list_del(entry->prev, entry->next);  
  13.     //entry节点初始化，是该节点形成一个只有entry元素的双向链表  
  14.     INIT_LIST_HEAD(entry);  
  15. }  
6、替换元素
[cpp] view plain copy
  1. //调整指针，使new的前后指针指向old的前后，反过来old的前后指针也指向new  
  2. //就是双向链表的指针调整  
  3. static inline void list_replace(struct list_head *old,  
  4.                                 struct list_head *new)  
  5. {  
  6.     new->next = old->next;  
  7.     new->next->prev = new;  
  8.     new->prev = old->prev;  
  9.     new->prev->next = new;  
  10. }  
  11.   
  12. //替换元素，最后将old初始化一下，不然old还是指向原来的两个前后节点（虽然人家不指向他）  
  13. static inline void list_replace_init(struct list_head *old,  
  14.                                      struct list_head *new)  
  15. {  
  16.     list_replace(old, new);  
  17.     INIT_LIST_HEAD(old);  
  18. }  
7、移动元素
[cpp] view plain copy
  1. //移动指定元素list到链表的头部  
  2. static inline void list_move(struct list_head *list, struct list_head *head)  
  3. {  
  4.     __list_del(list->prev, list->next);//删除list元素  
  5.     list_add(list, head);//将list节点添加到head头节点  
  6. }  
  7.   
  8. /** 
  9. * list_move_tail - delete from one list and add as another's tail 
  10. * @list: the entry to move 
  11. * @head: the head that will follow our entry 
  12. */  
  13. //移动指定元素list到链表的尾部  
  14. static inline void list_move_tail(struct list_head *list,  
  15.                                   struct list_head *head)  
  16. {  
  17.     __list_del(list->prev, list->next);  
  18.     list_add_tail(list, head);  
  19. }  
在实际应用编程时，我们添加和删除链表操作，中间的待处理链表都是对象结构中的链表。举个小例子，使用内核数据结构list来编程的时候，添加元素应该是这样：
[cpp] view plain copy
  1. list_add(&(newobj.list), &(type_list.list));  
清楚前面那个对象结构挂载在链表上的那个图就好办了。

相关推荐