内核链表操作解析

最新推荐文章于 2024-08-18 17:39:39 发布
最新推荐文章于 2024-08-18 17:39:39 发布
阅读量314 收藏
点赞数
分类专栏： 数据结构与算法

linux内核之链表操作解析

本文只是对linux内核中的链表进行分析。内核版本是linux-2.6.32.63。文件在：linux内核/linux-2.6.32.63/include/linux/list.h。本文对list.h文件进行简要分析，有必要的地方还会以图进行说明。

代码分析

链表结构体：

有前驱和后继，说明是双链表

struct list_head {  
    struct list_head *next, *prev;  
};
链表头节点相关操作：

为head初始化，把head的next和prev都赋值为head的地址
因为定义的是宏，所以可以直接把后面的语句替换前面的宏直接看，
struct list_head name = {&(name),&(name)};，这样会更容易理解

#define LIST_HEAD_INIT(name) { &(name), &(name) }  
  
#define LIST_HEAD(name) \  
struct list_head name = LIST_HEAD_INIT(name)

上面是使用宏进行的head初始化(静态初始化，因为宏会在程序预编译时期进行宏名替换)
下面这个是在运行时，内嵌到调用函数中。（因为这个是内联函数，调用时直接用函数体内嵌到被调函数中）

static inline void INIT_LIST_HEAD(struct list_head *list)  
{  
    list->next = list;  
    list->prev = list;  
}
链表节点插入操作：

这是一个增加插入的公用函数函数实现的是：
prev <<=>> new <<=>> next，new是要新增的节点，pre和next是相邻的节点
A <<=>> B 表示A的后继指向B，B的前驱指向A， 后面调用时，根据这个关系就更好理解了。
也可以直接看后面的list_add()函数，把结构体带入函数中也会好理解些
在内核中有很多这种函数类型：前面带有两个_的（即：__记住是两杠），一般来说这种类型的
函数都是不能直接调用的，一定要先通过包装这个函数，然后才能调用。这是个原始函数

#ifndef CONFIG_DEBUG_LIST  
static inline void __list_add(struct list_head *new,  
     struct list_head *prev,  
     struct list_head *next)  
{  
    next->prev = new;  
    new->next = next;  
    new->prev = prev;  
    prev->next = new;  
}  
#else  
extern void __list_add(struct list_head *new,  
     struct list_head *prev,  
     struct list_head *next);  
#endif  
   
// 从链表头部插入节点   
// 下面函数就是包装了函数：__list_add()，实现从头节点到头结点的next之间插入元素  
// head <<=>> new <<=>> head->next  
static inline void list_add(struct list_head *new, struct list_head *head)  
{  
    __list_add(new, head, head->next);  
}  
  
// 从链表尾部插入节点  
// 包装了函数：__list_add()，实现从头节点的prev和头结点之间插入元素  
// head-prev <<=>> new <<=>> head  
static inline void list_add_tail(struct list_head *new, struct list_head *head)  
{  
    __list_add(new, head->prev, head);  
}
链表节点删除操作：
// 这是个删除的通用函数，实现得： prev <<=>> next  
// 这是让prev和next建立起链接来。可以联系list_del()函数来分析  
// 和上面分析一样该函数前缀为__所以一般是用来被包装的原始函数  
// 其实这个函数并没有删除这个节点，而是把这个节点从链表上卸下来而已  
static inline void __list_del(struct list_head * prev, struct list_head * next)  
{  
    next->prev = prev;  
    prev->next = next;  
}  
  
// 这是个删除的函数，参数则是将要删除的节点。  
// 调用_list_del() 函数来让entry节点从链表中卸下来，并且让它的前后节点建立连接，  
// 然后entry前后指针设置为个特殊的值，设置了这个值后的元素被访问时会引起页故障。  
#ifndef CONFIG_DEBUG_LIST  
static inline void list_del(struct list_head *entry)  
{  
    __list_del(entry->prev, entry->next);  
    entry->next = LIST_POISON1;  
    entry->prev = LIST_POISON2;  
}  
#else  
extern void list_del(struct list_head *entry);  
#endif  
  
// 这个函数首先调用__list_del() 来让entry节点从链表中卸下来，并且让它的前后节点建立连接，  
// 然后调用INIT_LIST_HEAD() 函数使得entry节点变成空节点。  
static inline void list_del_init(struct list_head *entry)  
{  
    __list_del(entry->prev, entry->next);  
    INIT_LIST_HEAD(entry);  
}
链表节点移动操作：
// 这个函数首先调用__list_del()函数让list从链表上卸下了，并且让它的前后节点建立连接  
// 然后调用list_add()函数 往头部插入该节点。函数的总体意思是：把某个位置上的节点移动到头节点后插入。  
 static inline void list_move(struct list_head *list, struct list_head *head)  
{  
    __list_del(list->prev, list->next);// 把节点从链表中卸下来  
    list_add(list, head);// 把卸下来的链表插入打到头节点后面  
}  
  
// 这个函数和上个功能一样，这是插入的位置是在头节点的尾部  
static inline void list_move_tail(struct list_head *list,  
 struct list_head *head)  
{  
    __list_del(list->prev, list->next); // 把节点从链表上卸下来  
    list_add_tail(list, head);// 把卸下来的节点插入到链表头节点的尾部  
}
链表节点替换操作：
// 这是个替换的通用函数。就是让new节点替换old节点，但  
// old指针的前驱和后继都没有改变，就是old节点还是挂在链表上的  
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;  
}  
  
// 这个函数首先调用list_replace() 函数用new替换了old的指针关系。  
// 然后调用INIT_LIST_HEAD() 函数让old节点变成空节点  
static inline void list_replace_init(struct list_head *old,  
        struct list_head *new)  
{  
    list_replace(old, new);  
    INIT_LIST_HEAD(old);  
}
链表判空操作和判断是否唯一节点操作：
// 判断list节点是否是该链表中最后的一个节点。  
// 因为是环链表，所以若是最后一个节点。则该节点的后继为头节点：list->next = head  
static inline int list_is_last(const struct list_head *list,  
        const struct list_head *head)  
{  
    return list->next == head;  
}  
  
// 判断该链表是否是空链表，只有一个head节点  
static inline int list_empty(const struct list_head *head)  
{  
    return head->next == head;  
}  
  
 // 这个函数和上面的一样，是个判空函数。唯一不同的是这个函数可以防止该该链表  
 // 同时正在被另外一个cpu操作，以导致head的前驱和后续不一样。其实换个角度来看  
 // 该函数也可以用来判断该链表是否还在被其他CPU操作  
static inline int list_empty_careful(const struct list_head *head)  
{  
    struct list_head *next = head->next;  
    return (next == head) && (next == head->prev);  
}  
  
 // 这个函数是用来判断该链表中是否只有一个节点。  
static inline int list_is_singular(const struct list_head *head)  
{  
    return !list_empty(head) && (head->next == head->prev);  
}
链表分割操作：
// 单看这个函数是比较难看出怎么分割的。这有个前提是head 和 entry 是在同一个链表上的节点  
//  第一步：....<<=>> head <<=>>......<<=>> entry <<=>>.....  
//  第二步：设head的next为head_next，entry的next为entry_next    
//  第三步：....<<=>> head <<=>> head_next <<=>>.....<<=>> entry <<=>> entry_next <<=>>....  
//  第四步：经过函数分割后得两条链表：...<<=>> head <<=>> entry_next <<=>> .....     
//  和  ....<<=>> entry <<=>> list <<=>> head_next <<=>> ....  
// 函数功能：函数把head....entry这个链表分割成两条链表（这是个分割的原始函数）  
static inline void __list_cut_position(struct list_head *list,  
        struct list_head *head, struct list_head *entry)  
{  
    struct list_head *new_first = entry->next;  
    list->next = head->next;  
    list->next->prev = list;  
    list->prev = entry;  
    entry->next = list;  
    head->next = new_first;  
    new_first->prev = head;  
}  
  
// 这是个分割函数，与上面这个函数不同的是，  
// 这个函数考虑到了空链表和一个节点的链表情况  
static inline void list_cut_position(struct list_head *list,  
        struct list_head *head, struct list_head *entry)  
{  
    if (list_empty(head))  
        return;  
    if (list_is_singular(head) &&  
        (head->next != entry && head != entry))  
        return;  
    if (entry == head)  
        INIT_LIST_HEAD(list);  
    else  
        __list_cut_position(list, head, entry);  
}

上面的原始链表拆分函数单看代码是比较难理解的，下面画了图，看图方便理解下：

链表整合操作：
// 这个函数的实现有点不好解释，如果要想理解这个函数的意思最好是根据后面的list_splice()函数来。  
// 先说下前提：list是个单独的链表；prev和next是个链表中相邻的2个节点  
// 而这个函数实现的是把list和prev这个链表相整合成一个链表。prev和next中断开连接list前后2个节点  
// 但list节点前驱和后继还是没有修改。这也是个原始整合函数，需要包装才能使用  
static inline void __list_splice(const struct list_head *list,  
        struct list_head *prev,  
        struct list_head *next)  
{  
    struct list_head *first = list->next;  
    struct list_head *last = list->prev;  
  
    first->prev = prev;  
    prev->next = first;  
  
    last->next = next;  
    next->prev = last;  
}

原始链表整合操作图：

 // 这个函数是先考虑list是否为空表，然后调用上面的整合函数，从头部整合进去。  
 // 但这个list的前驱和后继都没有更改  
static inline void list_splice(const struct list_head *list,  
        struct list_head *head)  
{  
    if (!list_empty(list))  
        __list_splice(list, head, head->next);  
}  
  
 // 同上个函数，只是从尾部整合进去  
static inline void list_splice_tail(struct list_head *list,  
        struct list_head *head)  
{  
    if (!list_empty(list))  
        __list_splice(list, head->prev, head);  
}  
 
 // 这是解决 list_splice()函数中list的前驱和后继没有修改的问题。  
 // 该函数调用INIT_LIST_HEAD(list)来是list为空节点  
static inline void list_splice_init(struct list_head *list,  
        struct list_head *head)  
{  
    if (!list_empty(list)) {  
        __list_splice(list, head, head->next);  
        INIT_LIST_HEAD(list);  
    }  
}  
  
// 这个函数和list_splice_tail()这个函数功能是一样的，只是这个函数对list进行了处理。  
// 让list变成了空节点。其实有点不理解的是list_splice_tail()函数为什么不对list进行处理  
static inline void list_splice_tail_init(struct list_head *list,  
struct list_head *head)  
{  
    if (!list_empty(list)) {  
    __list_splice(list, head->prev, head);  
    INIT_LIST_HEAD(list);  
    }  
}
链表节点访问数据项操作：
// 这个宏是list链表中一个精髓，访问包含节点的结构体中其他数据项  
// 后面会详细的分析这个宏的具体使用
//container_of宏用来根据成员的地址来获取结构体的地址。
/**
 * list_entry - get the struct for this entry
 * @ptr:    the &struct list_head pointer.
 * @type:   the type of the struct this is embedded in.
 * @member: the name of the list_struct within the struct.
 */
#define list_entry(ptr, type, member) \  
container_of(ptr, type, member)  
  
#define list_first_entry(ptr, type, member) \  
list_entry((ptr)->next, type, member)

list_entry的理解

我们来看一下container_of的宏定义：

#define container_of(ptr, type, member)                   \
({                                                        \
    const typeof(((type *)0)->member) * __mptr = (ptr);   \
    (type *)((char *)__mptr - offsetof(type, member));    \
})

其次，offsetof的宏定义：

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

TYPE是结构体类型，例如：

struct TYPE
{
    //...
    struct list_head member;
    //...
};

其次，MEMBER就是TYPE中的list_head变量member

那么：
(TYPE *)0是将0强制转换成TYPE型指针，则该指针一定指向0地址(数据段基址)。
&((TYPE *)0)->MEMBER这句话其实是&(((TYPE *)0)->MEMBER),通过该指针访问TYPE的MEMBER成员并得到其地址。
相对于结构体的起始地址0，那么&((TYPE *)0)->MEMBER就是相对于起始地址之间的偏移量，这个偏移量对于所有的TYPE型变量都是成立的。
offsetof(TYPE, MEMBER)就表示这个偏移量。

对于container_of中，

const typeof(((type *)0)->member) * __mptr = (ptr);

由于下面我们要对指针进行强制类型转换，所以这里我们又申请一个指针，指向和ptr相同的位置。
这里的ptr指的是实际list_head member的地址。

(char *)__mptr

由于offsetof()函数求得的是偏移字节数，所以这里(char *)__mptr使得指针的加减操作步长为1Byte，然后二者相减便可以得到TYPE变量的起始地址，最后通过(type *)类型转换，将该地址转换为TYPE类型的指针。

链表节点的遍历操作：

参数相关释义：
cpp /** * @ptr: the &struct list_head pointer. * @type: the type of the struct this is embedded in. * @member: the name of the list_struct within the struct. */

// 这是个遍历宏,从头往后遍历，算是个比较简单的函数。  
// prefetch()是个预取值指令，目的是提高运行效率  
#define list_for_each(pos, head) \  
for (pos = (head)->next; prefetch(pos->next), pos != (head); \  
        pos = pos->next)  
// 这个函数功能同上，只是没有prefetch()  
#define __list_for_each(pos, head) \  
for (pos = (head)->next; pos != (head); pos = pos->next)  
// 这是个遍历宏,从尾往头遍历，算是个比较简单的函数。  
// prefetch()是个预取值指令，目的是提高运行效率  
#define list_for_each_prev(pos, head) \  
for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \  
        pos = pos->prev)  
// 这是个设计比较巧妙的函数，同样也是遍历函数，只是这个函数考虑到了pos在遍历过程中有可能被删除掉  
// 如果还是和上面的遍历函数一样，那假若pos被删除了，则整个程序就会出错停止运行。而现在用个临时变量n  
// 可以把数据存放在n中，若pos被删除掉了，那pos = n 又会让pos有效。所以程序不会出错。  
#define list_for_each_safe(pos, n, head) \  
for (pos = (head)->next, n = pos->next; pos != (head); \  
pos = n, n = pos->next)  
// 函数功能同上面那个，只是遍历是从head->prev(尾部)那端开始  
#define list_for_each_prev_safe(pos, n, head) \  
for (pos = (head)->prev, n = pos->prev; \  
    prefetch(pos->prev), pos != (head); \  
    pos = n, n = pos->prev)  
// 这是个有数据项的遍历，  
//  typedef struct pos{  
//         type date;  
//     struct head_list member;  
//         }pos;  
//  list_entry(&ptr,typeof(pos),ptr);这是个由结构体变量中的某个成员而获取到  
//  整个结构体变量的地址指针方法。typeof(pos)是获取到pos的类型  
//  这里应该是在创建第一个节点时,让head = &pos->member  
#define list_for_each_entry(pos, head, member) \  
for (pos = list_entry((head)->next, typeof(*pos), member);\  
    prefetch(pos->member.next), &pos->member != (head);\  
    pos = list_entry(pos->member.next, typeof(*pos), member))  
// 函数功能同上，只是从member.prev(尾部)开始遍历  
#define list_for_each_entry_reverse(pos, head, member)\  
for (pos = list_entry((head)->prev, typeof(*pos), member);\  
    prefetch(pos->member.prev), &pos->member != (head);\  
    pos = list_entry(pos->member.prev, typeof(*pos), member))  
// 这是问号表达式，当问号后一个选项为空时，则不做任何操作。  
// 所以这是个判空宏，若pos存在，则不做操作，不存在则通过head来虚拟个pos节点  
#define list_prepare_entry(pos, head, member) \  
((pos) ? : list_entry(head, typeof(*pos), member))  
// 这也是遍历数据项的函数，和前面的函数不同的是，这个函数不是从head开始遍历，  
// 而是从任意的节点处遍历，直到到达头节点  
#define list_for_each_entry_continue(pos, head, member) \  
for (pos = list_entry(pos->member.next, typeof(*pos), member);\  
    prefetch(pos->member.next), &pos->member != (head);\  
    pos = list_entry(pos->member.next, typeof(*pos), member))  
// 函数功能和上面的相同，只是遍历放向是从尾部开始遍历的  
#define list_for_each_entry_continue_reverse(pos, head, member)\  
for (pos = list_entry(pos->member.prev, typeof(*pos), member);\  
    prefetch(pos->member.prev), &pos->member != (head);\  
    pos = list_entry(pos->member.prev, typeof(*pos), member))  
// 这个函数功能和list_for_each_entry_continue()和像，只是遍历的起点不一样。  
// list_for_each_entry_continue()是从该节点开始，这个函数则是从该节点的下个节点开始。  
#define list_for_each_entry_from(pos, head, member) \  
for (; prefetch(pos->member.next), &pos->member != (head);\  
    pos = list_entry(pos->member.next, typeof(*pos), member))  
// 这个和上个遍历删除节点的函数类似。多了个临时变量n，  
// 所以可以防止pos在遍历时，被删除出现的错误。  
#define list_for_each_entry_safe(pos, n, head, member)\  
for (pos = list_entry((head)->next, typeof(*pos), member),\  
n = list_entry(pos->member.next, typeof(*pos), member);\  
    &pos->member != (head); \  
    pos = n, n = list_entry(n->member.next, typeof(*n), member))  
// 函数功能同上面那个，只是遍历是从某个节点开始  
#define list_for_each_entry_safe_continue(pos, n, head, member) \  
for (pos = list_entry(pos->member.next, typeof(*pos), member),\  
n = list_entry(pos->member.next, typeof(*pos), member);\  
    &pos->member != (head);\  
    pos = n, n = list_entry(n->member.next, typeof(*n), member))  
// 函数功能同上面那个，只是遍历是从某个节点的下个节点开始  
#define list_for_each_entry_safe_from(pos, n, head, member) \  
for (n = list_entry(pos->member.next, typeof(*pos), member);\  
    &pos->member != (head);\  
    pos = n, n = list_entry(n->member.next, typeof(*n), member))  
// 同上个函数，只是从尾部开始  
#define list_for_each_entry_safe_reverse(pos, n, head, member)\  
for (pos = list_entry((head)->prev, typeof(*pos), member),\  
n = list_entry(pos->member.prev, typeof(*pos), member);\  
    &pos->member != (head); \  
    pos = n, n = list_entry(n->member.prev, typeof(*n), member))

漫步者2011
关注
专栏目录
Linux内核链表测试
11-11
首先，我们需要了解Linux内核链表的基本结构和操作，然后讨论用户态移植的过程，最后，通过分析给定的文件`list.c`, `list.h`以及`student.h`来理解具体的实现。 **1. Linux内核链表基础** Linux内核链表是一个...
linux内核之链表操作解析
diansaopu0085的博客
05-25 148
linux内核之链表操作解析 本文只是对linux内核中的链表进行分析。内核版本是linux-2.6.32.63。文件在：linux内核/linux-2.6.32.63/include/linux/list.h。本文对list.h文件进行简要分析，有必要的地方还会以图进行说明。 代码分析 链表结构体： 有前驱和后继，说明是双链表 struct list_head { st...
Linux内核链表(宏)---两种方法实现遍历
JIE的博客
10-25 589
#define list_for_each(n,head)\ for(n=head->next; n!=head; n=n->next) ll #define list_for_each_entry(obj,head,mem)\ for(obj=node_to_obj(head->next,typeof(*obj),mem);\ &obj->mem!=head;\ obj=node_to_obj(obj->mem.next,typeof(*obj),mem
【Linux】详细解析Linux内核链表
最新发布
W__winter的博客
08-18 1270
LIST_POISON1 和 LIST_POISON2 是 Linux 内核用来标记已删除链表节点的特殊值。这是内核开发者采用的一种巧妙的防御性编程技术，有助于编写更安全、更健壮的内核代码。list_entry 利用了 C 语言的一个特性：结构体成员的偏移量是固定的。它计算出 struct list_head 成员在整个结构体中的偏移，然后从这个 list_head 指针反推出整个结构体的起始地址。在上面的函数原型中，有这两行代码，他们的含义是什么呢。
内核链表分析
Sprd_MTK_Man
01-30 351
  在Linux内核中使用了大量的链表结构来组织数据，包括设备列表以及各种功能模块的数据组织。这些链表大多采用在【include/linux/list.h】实现一个相当精彩的链表数据结构。 Linux2.6多了两种功能，链表的读拷贝更新(rcu)和HASH链表(hlist)。这两种功能都是基于list结构的。 1链表的定义 struct list_head { struct...
双向内核链表航班管理系统（嵌入式项目）
11-20
这篇文章将深入探讨这一主题，详细阐述如何运用双向内核链表来构建航班管理系统的各个功能，并解析其背后的编程思想。 双向内核链表是一种数据结构，它允许在链表的任一侧进行插入和删除操作，因为每个节点都有两个...
双向内核链表航班管理系统（嵌入式项目） .rar
07-05
这篇文章将深入探讨这一主题，详细阐述如何运用双向内核链表来构建航班管理系统的各个功能，并解析其背后的编程思想。 双向内核链表是一种数据结构，它允许在链表的任一侧进行插入和删除操作，因为每个节点都有两个...
双向内核链表航班管理系统（嵌入式项目） 1.rar
07-05
这篇文章将深入探讨这一主题，详细阐述如何运用双向内核链表来构建航班管理系统的各个功能，并解析其背后的编程思想。 双向内核链表是一种数据结构，它允许在链表的任一侧进行插入和删除操作，因为每个节点都有两个...
Linux链表的解析与认知
01-03
在Linux操作系统中，链表是一种基础且至关重要的数据结构，被广泛用于系统内核的实现，如内存管理、进程调度、文件系统等。本篇文章将深入解析Linux链表的特性和应用，以及它与结构体指针自引用的关系。 首先，我们...
深入分析Linux内核链表（超详细）
03-10
很详细，值得研究。学习嵌入式的应该看。另有一本书也不错《深入理解linux内核》
Linux内核链表中的宏
10-31 562
/* list_entry - get the struct for this entry 　　* @ptr: the &struct list_head pointer. 　　* @type: the type of the struct this is embedded in. 　　* @member: the name of the list_struct within t
【Linux内核数据结构】最为经典的链表list
热门推荐
wenqian 'blog
03-21 1万+
很久之前研读过Linux的内核源码（后来终止了，水太深，吾辈驾驭不了），看到其中的内核数据结构，对链表的实现叹为观止，是迄今为止我见过的最为经典的链表实现（不是数据内嵌到链表中，而是把链表内嵌到数据对象中）。现在再来回顾这个经典的数据结构。 链表代码在头文件中声明（推荐Source Insight，源码版本：Linux-2.6.32.61），其数据结构很简单有木有，直接就一个前后链表指针，前篇S
linux内核中的链表
weixin_30763397的博客
06-03 357
1.内核中的链表 linux内核链表与众不同，他不是把将数据结构塞入链表，而是将链表节点塞入数据，在2.1内核中引入了官方链表，从此内核中所有的链表使用都采用此链表，千万不要在重复造车轮子了！链表实现定义在<linux/list.h>,使用内核链表时，包含此文件。 1.1.传统的双向链表和内核中的双向链表的区别 有个单独的头结点(head) 每个节点(node)除了包含必要的数据之外...
linux内核链表讲解
菜头大大
07-29 321
链表中一般都要进行初始化、插入、删除、显示、释放链表，寻找节点这几个操作，下面我对这几个操作进行简单的介绍，因为我的能力不足，可能有些东西理解的不够深入，造成一定的错误，请各位博友指出。
Linux内核链表理解与使用
to_be_better_wen的博客
11-06 2123
Linux内核相关学习总结
linux 内核链表详解
kakaka666的博客
11-13 635
linux 内核链表详解
Linux内核链表操作：初始化、插入、删除解析
本文以实例的形式详细介绍了Linux内核链表的使用方法，主要涉及以下几个核心知识点： 1. **初始化链表**： Linux内核链表的初始化通过`INIT_LIST_HEAD(ptr)`宏来完成，该宏将链表头结点的`next`和`prev`指针都设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值