【Linux】内核链表阅读笔记
目的
一直有想法读一读内核的代码，了解其 数据结构设计的 奥秘。
我取内核代码中把list.h提取了出来，并且把涉及到的一些宏和函数定义整再了一起读~
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H
#include 链表结构本身
struct list_head {
struct list_head *next, *prev;
};
包含指向之前元素和之后元素的字段，一个双向链表的基础结构 ~
链表结构初始化
/// 初始化 一个 链表结构，就是把next和prev指向自己
链表结构的头插入
static void __list_add(struct list_head* new_list,
struct list_head* prev,
struct list_head* next)
{
next->prev = new_list;
new_list->next = next;
new_list->prev = prev;
prev->next = new_list;
}
static inline void list_add(struct list_head* new_list, struct list_head* head)
{
__list_add(new_list, head, head->next);
}
我画了个示意图说明每一步的效果
从初始化开始，头插一个，再头插一个~
链表结构的尾插入
static void __list_add(struct list_head* new_list,
struct list_head* prev,
struct list_head* next)
{
next->prev = new_list;
new_list->next = next;
new_list->prev = prev;
prev->next = new_list;
}
static inline void list_add_tail(struct list_head* new_list, struct list_head* head)
{
__list_add(new_list, head->prev, head);
}
和头插入类似，只是传入的变量有一点不同
从初始化开始，尾插一个，再尾插一个~
删除链表中的某一个元素
/*
* Delete a list entry by making the prev/next entries
* point to each other.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
prev->next=next;
}
/**
* list_del - deletes entry from list.
* @entry: the element to delete from the list.
* Note: list_empty() on entry does not return true after this, the entry is
* in an undefined state.
*/
static inline void __list_del_entry(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
}
///删除节点
static inline void list_del(struct list_head *entry)
{
__list_del_entry(entry);
entry->next = 0;
entry->prev = 0;
}
删除就是把指定元素的next和prev指向某个值(这里我按0)，然后把前后元素的连接恢复好
替换链表中的某个元素
注意，这里的旧元素的prev和next连接没有修改，需要执行删除，好心的内核设计者为我们 准备了list_replace_init
/**
* list_replace - replace old entry by new one
* @old : the element to be replaced
* @new : the new element to insert
* 替换元素
* If @old was empty, it will be overwritten.
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
new->next->prev = new;
new->prev = old->prev;
new->prev->next = new;
}
/// 替换并重初始化
static inline void list_replace_init(struct list_head *old,
struct list_head *new)
{
list_replace(old, new);
INIT_LIST_HEAD(old);
}
链表的移动
/**
* list_move - delete from one list and add as another's head
* @list: the entry to move
* @head: the head that will precede our entry
* 链表移动，头插
*/
static inline void list_move(struct list_head *list, struct list_head *head)
{
__list_del_entry(list);//删除list指针所处的元素
list_add(list, head);//重新以头插法添加到另一个头节点中
}
/**
* list_move_tail - delete from one list and add as another's tail
* @list: the entry to move
* @head: the head that will follow our entry
* 链表移动，尾插
*/
static inline void list_move_tail(struct list_head *list,
struct list_head *head)
{
__list_del_entry(list);//删除list指针所处的元素
list_add_tail(list, head);//重新以尾插法添加到另一个头节点中
}
这个就是把指定的元素删除，然后加到另一个链表元素上。
链表的遍历
说到链表的遍历，就不得不说下container_of和offsetof，还有为啥要区分普通遍历和安全遍历
//前遍历
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
//后遍历
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
// 前遍历【安全】
#define list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
// 后遍历【安全】
#define list_for_each_prev_safe(pos, n, head) \
for (pos = (head)->prev, n = pos->prev; \
pos != (head); \
pos = n, n = pos->prev)
//已知结构体变量中的某个成员，返回结构体成员占用的内存大小
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
//已知结构体变量中的某个成员，返回结构体变量对应的首地址
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
//********链表轮询的宏*****************************************/
#define list_first_entry(ptr, type, member) \
list_entry((ptr)->next, type, member)
#define list_last_entry(ptr, type, member) \
list_entry((ptr)->prev, type, member)
/**
* list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_head within the struct.
*/
#define list_for_each_entry(pos, head, member) \
for (pos = list_first_entry(head, typeof(*pos), member); \
&pos->member != (head); \
pos = list_next_entry(pos, member))
#define list_for_each_entry_reverse(pos, head, member) \
for (pos = list_last_entry(head, typeof(*pos), member); \
&pos->member != (head); \
pos = list_prev_entry(pos, member))
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
#define list_next_entry(pos, member) \
list_entry((pos)->member.next, typeof(*(pos)), member)
#define list_prev_entry(pos, member) \
list_entry((pos)->member.prev, typeof(*(pos)), member)
/**
* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_head within the struct.
* 前遍历成员【安全】
*/
#define list_for_each_entry_safe(pos, n, head, member) \
for (pos = list_first_entry(head, typeof(*pos), member), \
n = list_next_entry(pos, member); \
&pos->member != (head); \
pos = n, n = list_next_entry(n, member))
/**
* list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_head within the struct.
*
* Iterate backwards over list of given type, safe against removal
* of list entry.
* 后遍历成员【安全】
*/
#define list_for_each_entry_safe_reverse(pos, n, head, member) \
for (pos = list_last_entry(head, typeof(*pos), member), \
n = list_prev_entry(pos, member); \
&pos->member != (head); \
pos = n, n = list_prev_entry(n, member))
/************************************************************/
container_of和offsetof
这个宏的作用是已知结构体变量中的某个成员，返回结构体变量对应的首地址
//已知结构体变量中的某个成员，返回结构体成员占用的内存大小
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
//已知结构体变量中的某个成员，返回结构体变量对应的首地址
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
这里我稍微参考了 下这篇文章的解读
offsetof我自己的理解就是
将0地址强制转换成指定类型的指针，然后访问指定的成员，返回其大小
typeof是 GCC编译器的特殊关键字，可以返回变量的类型
container_of我自己的理解就是
通过指定结构体中指定成员再内存中的地址，减去它在内存中占用的大小，这样就可以得到结构体变量的首地址了。
另外，内核设计者通过第一句的赋值语句，可以变相的实现对传入指针和类型的匹配检查，如果不匹配，编译会出警告！！
在理解了这两个 宏之后，普通 遍历类的宏就能够理解了
安全遍历与普通遍历
为啥要区分呢
//前遍历
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
//后遍历
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
// 前遍历【安全】
#define list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
// 后遍历【安全】
#define list_for_each_prev_safe(pos, n, head) \
for (pos = (head)->prev, n = pos->prev; \
pos != (head); \
pos = n, n = pos->prev)
可以看到
安全遍历，弄了一个临时变量存储下一个元素指针，这样假如遍历时，用户调用删除接口删除了元素，那么即便删除了元素，遍历还可以继续下去，因为暂存了下一个元素的指针，而不会造成指针指向一个非法的位置
这里做了一个小实验，使用内核链表整了个自己的链表结构
struct MyElememt
{
struct list_head list;
int val;
};
void test2()
{
struct MyElememt * p;
struct MyElememt element_list;
INIT_LIST_HEAD(&element_list.list);
struct list_head * pos;
struct MyElememt * p11;
struct MyElememt * p12;
printf("Tail add 5 elements\r\n");
for(int i=0;i<5;i++)
{
p = (struct MyElememt *)malloc(sizeof(struct MyElememt));
p->val = i+1;
list_add_tail(&p->list,&element_list.list);
}
printf("Loop all elements\r\n");
list_for_each(pos,&element_list.list)
{
printf("Addr = 0x%x\n",&pos->next);
}
printf("Loop all elements vals\r\n");
//list_for_each_entry(p11,&element_list.list,list)//will panic!!!
list_for_each_entry_safe(p11,p12,&element_list.list,list)//will not panic!!!
{
printf("Val = %d\n",p11->val);
if(p11->val == 5)
{
list_del(&p11->list);
}
}
printf("Loop all elements vals\r\n");
list_for_each(pos,&element_list.list)
{
p = list_entry(pos,struct MyElememt,list);
printf("Val = %d\n",p->val);
}
}
注意看我注释中will panic!!!那行，如果使用 普通遍历，在遍历过程中删除了元素，那么程序崩溃，一定要用安全遍历才行!