linux kernel list详解

因为很多的原因，我们在实际项目的代码中，很多地方都用到了源自linux kernel的list。也因为一些使用习惯、团队风格等问题，我们在移植的过程中对其进行了一定的改进。但基本框架和基本功能都没有做任何的改变。正好书中很多地方也是用到了linux kernel list，所以我们有必要对其进行系统而详细的介绍，正巧我也觉得这一章可以单独的拿出来，所以就有了这篇文章。

因为我们面面俱到的讲解了list，所以相对来说文章很长。希望大家能有耐心。

linux kernel list，linux内核的链表结构，它使用了最简洁的方式实现了一个几乎是万能的链表。

说起链表，一共有3种：单向链表、双向链表、循环链表。

单向链表是链表中最简单的一种形式，它只有一个后继指针（一般代码中是next）来维护结构。所以，单向链表只能沿着后继指针做向后操作，不能向前操作。单向链表也不能从中间插入或者删除一个元素，因为没有前向指针，所以无法获取前一个元素，从中间删除链表元素会引起断链。单向链表示意图如下：

双向链表：双向链表比单向链表复杂一些，它除了有一个后续指针next指向下一个元素之外还有一个前驱指针prev指向前一个元素。所以，双向链表不仅能向后遍历，还能向前遍历。同时，双向链表也能对链表中的任一元素进行操作，并且在任何位置都可以进行增加和删除操作，因为它不会断链。双向链表的示意图如下：

循环链表：循环链表是双向链表的升级版。相比双向链表，循环列表首尾相连。示意图如下：

本节所要讨论的kernel list是一个循环链表结构。我注意并且运用linux kernel list是从2.6内核开始的。linux内核的链表和我们一般定义的链表最大的差别有2个：

1. 结构定义。linux内核的链表定义非常简单明了，并且严格遵守了自定义结构不定义数据的规则。在list.h文件中定义如下：

   1. struct list_node  {
   2.     struct list_node  *prev;
   3.     struct list_node  *next;
   4. };

   在linux的kernel中结构体的名称是list_head，只是因为习惯问题，我们团队觉得list_head使用起来不太顺手，而list_node比较习惯，所以我们在移植的时候统一改了一下结构体的名称。list_node的定义相当清晰：前驱指针和后继指针。list_node的定义和我们通常对于链表结构的定义最大的不同是list_node链表结构没有数据域。通常我们要实现双向链表结构会将本身的链表关系结构和实体数据属性合并到一起。比如有一个学生结构体，属性为学号（id），姓名（name），年龄（age）。那么这样的一个链表定义如下：

   1. struct student {
   2.     int id;
   3.     char *name;
   4.     int age;
   5.     struct student *prev;
   6.     struct student *next;
   7. };

   这个结构体正确，并且可用，但是并不通用。

2. linux kernel list使用的时候需要一个表头。因为它的通用化设计和追求更简单的算法实现，list必须要一个简单而通用的方法通过自身来判断链表是否存在数据、链表是否已经遍历到最后等等。所以linux kernel list不能像我们通常的定义一样来区分，而是通过在使用链表之前置一个链表头来实现。链表头是在链表初始化的时候确定的，所以链表可以通过前驱和后继指针都指向自己来确定链表目前的状态是空的。

linux kernel list使用起来也很简单。当我们使用它来表示链表的时候，需要使用数据包含结构的方式而不是我们上面的结构和数据混合方式。比如同样的定义一个student结构，使用linux kernel list的代码如下：

1.     struct student {
2.         struct list_node chain;
3.         int id;
4.         char *name;
5.         int age;
6.   };

随后，在使用链表操作之前一定要先初始化链表头，再使用linux kernel list提供的API进行增加、删除、遍历等操作。

初始化

linux kernel list提供了3种初始化链表的方式，前面2种其实是一样的，属于创建型，API如下：

1. #define LIST_HEAD_INIT(name) { &(name), &(name) }
3. #define LIST_HEAD(name) \
4.     struct list_node  name = LIST_HEAD_INIT(name)

第3种是初始化模式，这对于结构体内嵌链表头比较适合，比如我们上面内存池中的slot_chain、larger_chain和cleanup_chain。

1.     static inline void INIT_LIST_HEAD(struct list_node  *list) {
2.         list->next = list;
3.         list->prev = list;
4.    }

不管是那个API初始化链表，初始化的时候始终只在做一件事情：就是把head的prev指针和next指针都指向head本身。初始化后的链表结构如下图：

添加链表项

linux kernel list提供了2个添加链表项的API，分别是在链表的头部添加一个链表项和在链表的尾部添加一个列表项。因为linux kernel list定义链表结构的时候只定义了前向和后继两个指针，添加链表项也只是指针指向的变动；又因为从开始设计linux kernel list的时候就设定链表头是肯定存在的，所以也没有了链表是否为空之类的繁琐判断，整个代码显得非常的简洁。linux kernel list提供的代码如下：

1.     /*
2.     * 在两个已知连续的实体间插入一个新实体
3.     * 这个方法仅使用在我们知道实体的prev/ next指针的内部链表操作
4.    */
5.    static inline void __list_add(struct list_node  * new,
6.            struct list_node  *prev,
7.            struct list_node  * next) {
8.         next->prev = new;
9.         new-> next = next;
10.         new->prev = prev;
11.        prev-> next = new;
12.    }

注意：这是一个私有函数。在linux kernel list定义中，形如"__XXXX()"的函数，也就是双下划线开始的函数，被内定为内部函数，外部不许调用(下同，不在累述）。 在私有函数中，一般只会进行最简单的操作，而对于边界问题、特殊值等检查和校验都会在对外的接口函数中完成。

1.     /**
2.     * list_add - 添加一个实体
3.     * @new: 被添加的新实体
4.     * @head: 链表头部，新实体被添加在这个head后面
5.     *
6.     * 在指定的链表头部后面添加一个新实体。
7.     * 这有利于实现栈。
8.     */
9.     static inline void list_add(struct list_node  * new, struct list_node  *head) {
10.        __list_add( new, head, head->next);
11.    }

这是一个链表的添加函数，将实体添加到链表的head后面，也就是next指针处。比如初始化链表头后的示意图如上图所示，那么添加实体后的整个链表示意图如下所示：

1.     /**
2.     * list_add_tail - 添加一个新实体
3.     * @new: 被添加的新实体
4.     * @head: 链表头部，新实体加被添加在这个head之前
5.     *
6.     * 在指定的链表头部之前添加一个新实体。
7.     * 这对于实现队列有用。
8.     */
9.     static inline void list_add_tail(struct list_node  * new, struct list_node  *head) {
10.        __list_add( new, head->prev, head);
11.    }

这也是一个链表的添加函数，和上面的函数不同的是此函数将实体添加到链表的末尾，也就是head的prev指针指向处。如果在上图的基础上将实体添加到链表的末尾，添加后的链表示意图如下所示：

删除链表项

删除链表项和添加链表项如出一辙，也是简单的指针操作。相比添加链表项，因为双向链表中的项每个都有前向和后继两个指针，所以删除链表项只需要明确单个链表项即可，并不存在从头部删除或者是从尾部删除的区别。所以，linux kernel list的代码如下：

1.     /*
2.    * 通过实体的prev/next指针相互指向对方删除实体
3.     *
4.     * 这个方法仅使用在我们知道实体的prev/next指针的内部链表操作
5.    */
6.   static inline void __list_del( struct list_node  * prev, struct list_node  * next) {
7.        next->prev = prev;
8.        prev->next = next;
9.    }
11.     static inline void __list_del_entry( struct list_node  *entry) {
12.        __list_del(entry->prev, entry->next);
13.    }

同上，这2个函数是链表删除的真正操作，因为是"__"双下划线开头，故是一个私有函数。

1.     /**
2.     * list_del - 从链表中删除一个实体.
3.     * @entry: 从链表中欲删除的实体.
4.     * Note:  在entry上执行list_del操作后，对entry执行list_empty操作将不返回true。
5.     *              因为entry属于未定义状态。
6.     */
7.     static inline void list_del(struct list_node  *entry) {
8.        __list_del(entry->prev, entry->next);
9.        entry->next = NULL;
10.        entry->prev = NULL;
11.    }

上面的函数是删除链表项的对外API。如有原始链表如下图：

执行list_del操作，删除实体2后，链表图示如下：

对于这个函数，我们在移植的过程中进行了更改，原本的代码是这样的：

1.     static inline void list_del(struct list_head *entry) {
2.        __list_del(entry->prev, entry->next);
3.        entry->next = LIST_POISON1; //注意这里的不同
4.        entry->prev = LIST_POISON2;
5.    }

我们更改的是将prev和next指针指向了NULL，而linux kernel是指向了LIST_POISON1和LIST_POISON2两个宏。查看一下这两个宏定义：

1.     #define LIST_POISON1  ((void *) 0x00100100 + POISON_POINTER_DELTA)
2.     #define LIST_POISON2  ((void *) 0x00200200 + POISON_POINTER_DELTA)

有点莫名其妙的定义，在往下查，POISON_POINTER_DELTA的宏定义如下：

1.     #ifdef CONFIG_ILLEGAL_POINTER_VALUE
2.         #define POISON_POINTER_DELTA _AC(CONFIG_ILLEGAL_POINTER_VALUE, UL)
3.     #else
4.         #define POISON_POINTER_DELTA 0
5.     #endif

还是没看懂。没看懂也不重要，查了一下linux的官方解析，LIST_POISON是一段内核内的无效的地址区，当开发者误用这个地址时，会发出页错误。我们为了简单起见，将其改成了NULL，也无伤大雅。

linux还提供了一个删除链表项实体的API，如下：

1.       /**
2.     * list_del_init - 从链表中删除一个实体，并且重新将该实体初始化为另一链表的head.
3.     * @entry: 从链表中欲删除的实体.
4.     */
5.     static inline void list_del_init( struct list_node  *entry) {
6.        __list_del_entry(entry);
7.        INIT_LIST_HEAD(entry);
8.    }

这个API和上面的删除链表项API的不同是：会将被删除的实体初始化为另一个链表的head。同上一样删除实体2，本API会将实体2初始化为head。示意图如下：

替换操作

linux kernel list定义了2个替换API。第一个API操作仅仅只是替换而已，第二个API在替换的基础上还增加了初始化被替换实体的操作。linux kernel list代码如下：

1.     /**
2.     * list_replace - 将old实体替换成new实体
3.     * @old : 被替换掉的实体
4.     * @new : 替换的实体
5.     *
6.     * 如果old是一个空的（并不是NULL，空的是指prev/next都指向自己，比如head）,
7.     *  old将会被重写.
8.     */
9.     static inline void list_replace(struct list_node  *old,
10.            struct list_node  * new) {
11.         new->next = old->next;
12.         new->next->prev = new;
13.         new->prev = old->prev;
14.         new->prev->next = new;
15.    }

此API是直接将old的实体替换成了new，比如有一个new的实体，链表示意图如下：

将new替换成实体2后，链表示意图如下：

注意，这里有个问题：替换后的元素原来的prev和next指针指向并没有发生改变，还是保持原来的指向，所以这是一个bug的温床，大家要注意处理。最简单的办法就是把替换下来的元素prev、next指针都设置成NULL就可以了。

1.     /**
2.     * list_replace_init - 将old实体替换成new实体，并且重新将old初始化为另一链表的head
3.     * @old : 被替换掉的实体
4.     * @new : 替换的实体
5.     *
6.     * 如果old是一个空的（并不是NULL，空的是指prev/next都指向自己，比如head）,
7.     *  old将会被重写.
8.     */
9.     static inline void list_replace_init(struct list_node  *old,
10.             struct list_node  *new) {
11.        list_replace(old, new);
12.        INIT_LIST_HEAD(old);
13.    }

此API将会在替换掉old以后，将old初始化为另一个链表的head。和list_del_init异曲同工。替换后链表示意图如下：

对于替换操作，有一个特例是当链表为空的时候，也就是只有head一个元素的时候，示意图如下：

如果将head替换掉，将会形成如下的链表形式：

移动操作

linux kernel list定义了两个移动操作的API。移动操作是将原本属于链表A中的实体移动到链表B中，相当于将元素从链表A中删除再加入到链表B中。linux kernel list的代码如下：

1.     /**
2.     * list_move - 将list从一个链表移动到另一个链表中
3.     * @list: 欲移动的实体
4.     * @head: 欲加入的新链表的head
5.     */
6.     static inline void list_move(struct list_node  *list, struct list_node  *head) {
7.        __list_del_entry( list);
8.        list_add( list, head);
9.    }

有两个链表，如下图所示：

假设移动实体2，将实体2从左边的链表移动到右边的链表，即自行list_move(实体2，右边链表的head)，则两个链表的示意图如下所示：

从示意图中可以看出，list_move函数是将元素移植到链表的头部，其实不仅仅是头部，只要是list_node元素，都可以满足要求，确切来说，移动到参数head元素的next指针指向的位置才是正确的。

有移动到next位置，就会有移动到prev指针指向位置的，所以代码如下：

1.     /**
2.     * list_move_tail -  将list从一个链表移动到另一个链表尾部
3.     * @list: 欲移动的实体
4.     * @head:  欲加入的新链表的head
5.     */
6.     static inline void list_move_tail(struct list_node  *list,
7.            struct list_node  *head) {
8.        __list_del_entry( list);
9.        list_add_tail( list, head);
10.    }

同样的道理，将实体2移动到右边链表的tail位置，示意图如下：

和list_move函数一样，确切的意义是将元素移动到参数head的prev指针指向的位置。

1.     /**
2.     * list_rotate_left - 左向移动节点，把第一个元素移动到最后一个
3.     * @head: 链表的head节点
4.     */
5.     static inline void list_rotate_left(struct list_node  *head) {
6.         struct list_node  *first;
8.         if (!list_empty(head)) {
9.            first = head->next;
10.            list_move_tail(first, head);
11.        }
12.    }

该函数是将head元素的next指针指向的实体向后移动到head元素prev指针指向的位置。链表移动示意图如下所示：

如果这个函数执行多次，将会把整个链表的顺序正好做一个180度的翻转。

判断操作

linux kernel list为链表增加了判断特殊状态的API。判断链表的状态并没有特别大的难度，linux kernel list需要注意的地方就是：链表为empty的时候，链表并不是NULL，也不是一个元素没有。链表至少有一个元素，就是它本身的head元素。

1.     /**
2.     * list_is_last - 判断list节点是不是head链表的最后一个节点
3.     * @list: 欲测试的节点
4.     * @head: 链表的head节点
5.     */
6.     static inline int list_is_last(const struct list_node  *list,
7.             const struct list_node  *head) {
8.         return list->next == head;
9.    }
11.     /**
12.     * list_empty - 判断链表是否是空，即一个节点都不存在
13.     * @head: 欲测试的链表
14.     */
15.     static inline int list_empty(const struct list_node  *head) {
16.         return head->next == head;
17.    }
19.     /**
20.     * list_empty_careful - 测试链表是都为空且未被修改
21.     * @head: 欲测试的链表
22.     *
23.     *
24.     * 说明：
25.     * 测试链表是否为空的，并且检查没有另外的CPU正在更改成员（next或者是prev指针）
26.     *
27.     * 注意：如果在没有同步的情况下使用list_empty_careful函数，
28.     * 除非其他cpu的链表操作只有list_del_init()，否则仍然不能保证线程安全。
29.     *
30.     */
31.     static inline int list_empty_careful(const struct list_node  *head) {
32.         struct list_node  *next = head->next;
33.         return (next == head) && (next == head->prev);
34.    }
36.     /**
37.     * list_is_singular - 判断链表是否只有一个节点（除head节点外）
38.     * @head: 欲测试的链表.
39.     */
40.     static inline int list_is_singular(const struct list_node  *head) {
41.         return !list_empty(head) && (head->next == head->prev);
42.    }

切分

linux kernel list为链表定义了切分操作。切分操作发生在两个链表中，所以相对比较复杂，同时会修改两个链表的指针指向。linux kernel list的代码定义如下：

1.     /**
2.    *  __list_cut_position - 将一个列表切分成两个链表
3.    *           从head节点开始(不包括head）到entry节点结束（包括entry）的节点
4.    *           全部切割到list链表
5.    *  @list ： 一个新的链表，将切分的节点全部加入到这个链表
6.    *  @head ： 待切分链表的开始节点
7.    *  @entry ： 待切分链表的结束节点，必须和head在一个链表内
8.    *  注意：list必须是一个空链表，或者是无所谓丢失原有节点的链表，
9.    *           切分操作将会替换掉list链表原有的元素
10.    */
11.     static inline void __list_cut_position(struct list_node  * list,
12.            struct list_node  *head,
13.            struct list_node  *entry) {
14.        struct list_node  *new_first = entry->next;
15.         list->next = head->next;
16.         list->next->prev = list;
17.         list->prev = entry;
18.        entry->next = list;
19.        head->next = new_first;
20.        new_first->prev = head;
21.    }
23.     /**
24.     * list_cut_position - 将一个链表切分成2个
25.    *  @list ： 一个新的链表，将切分的节点全部加入到这个链表
26.    *  @head ： 待切分链表的开始节点
27.    *  @entry ： 待切分链表的结束节点，必须和head在一个链表内
28.    *
29.     */
30.     static inline void list_cut_position(struct list_node  * list,
31.            struct list_node  *head, struct list_node  *entry) {
32.         if (list_empty(head))
33.             return;
34.         if (list_is_singular(head) &&
35.                (head->next != entry && head != entry))
36.             return;
37.         if (entry == head)
38.            INIT_LIST_HEAD( list);
39.         else
40.            __list_cut_position( list, head, entry);
41.    }

严格按照linux kernel的规则书写代码，双下划綫开头的函数是内部函数，没有加任何的参数验证，而对外开放的API则增加了参数校验。切分链表的操作和list_move比较相像，也是从一个链表中将一堆元素删除，再加到另外一个链表中。和list_move的差别可能只是移动的元素数量不同了。
因为链表切分函数一次操作的元素变多了，所以形成了一个区间。对于参数head和entry来说，切分的区间在head上是开区间，切分的时候不会包含head自身；而在entry上是闭区间，切分的时候包含entry自身。

设有两个链表，如下图：

假设，我们需要将元素2-元素4区间的全部元素切分到另外一个链表中，执行list_cut_position后，链表的状态如下图所示：

注意：另外一个链表中的元素6和元素7已经被替换掉了。这种替换容易引起野指针，一定要引起注意和重视。

1.     /**
2.    * list_clear - 清除以head为头部的链表，将其所有元素挂载到list链表上
3.    * @head ： 欲清除节点的链表head节点
4.    *  @list ： 一个新的链表，原链表上的所有节点都将挂载到该链表上
5.    *  
6.    */
7.     static inline void  list_clear(struct list_node  *head,struct list_node  * list){
8.         if(list_empty(head)) return;
9.        list_cut_position( list,head,head->next);
10.    }

list_clear函数是list_cut_position函数的更彻底版本，它将一个完整的链表给切分到了另外一个链表中，同样是上图的两个链表初始图，经过调用list_clear函数后，两个链表将会总体调个个，图示如下：

合并

合并操作和上一节的切分操作很类似。两者的基本区分在于对于原有list的处理：如有list1和list2两个链表，如果是合并操作，将list1上的元素合并到list2的时候，并不会删除掉list2上原有的元素，而切分操作会将list2上的元素替换掉。

1.     /**
2.    * __list_splice - 合并链表，将list链表合并到prev和next指向的节点中间
3.    * @list ： 一个要被合并掉的链表
4.    * @prev ： 一个要合并其它链表的前驱指针
5.    * @next ： 一个要合并其它链表的后继指针
6.    */
7.     static inline void __list_splice( const struct list_node  * list,
8.            struct list_node  *prev,
9.            struct list_node  *next) {
10.        struct list_node  *first = list->next;
11.        struct list_node  *last = list->prev;
13.        first->prev = prev;
14.        prev->next = first;
16.        last->next = next;
17.        next->prev = last;
18.    }

私有的合并函数和list通常的私有函数一样没有参数校验，只是做了最基本的指针操作。

1.     /**
2.     * list_splice - 合并两个链表，将list合并到以head为头链表的前面，这是为了栈设计的
3.     * @list: 要被合并的list
4.     * @head:  添加到第一个链表中的位置
5.     */
6.     static inline void list_splice( const struct list_node  * list,
7.            struct list_node  *head) {
8.         if (!list_empty( list))
9.            __list_splice( list, head, head->next);
10.    }

这是合并两个list，假设我们又list1和list2，分别如下图：

执行list_splice函数，将list2合并到list1后，会将list2中的元素合并到list1的head指针后面，效果图如下：

1.     /**
2.     * list_splice_tail - 将list合并到head为头链表的尾部，这两个链表都是队列
3.     * @list: 要被合并的list
4.     * @head: 添加到一个列表中的位置.
5.     */
6.     static inline void list_splice_tail(struct list_node  * list,
7.            struct list_node  *head) {
8.         if (!list_empty( list))
9.            __list_splice( list, head->prev, head);
10.    }

此函数和上面的list_splice函数一样，只是合并的位置不同。将list2合并到了list1的尾部，也就是list1的head指针prev指向处。效果图如下：

上面两个API只是合并了链表，但是对于被合并的list2链表head元素的prev和next指针都没有进行处理，还是指向原来的元素。这样的操作可能会引起bug，所以linux kernel list增加了2个重置list2链表head的API，如下：

1.     /**
2.     * list_splice_init - 合并两个链表，并且重新初始化list为空链表
3.     * @list: 要被合并的list
4.     * @head:  添加到第一个链表中的位置
5.     *
6.    */
7.     static inline void list_splice_init(struct list_node  * list,
8.            struct list_node  *head) {
9.         if (!list_empty( list)) {
10.            __list_splice( list, head, head->next);
11.            INIT_LIST_HEAD( list);
12.        }
13.    }

同list_splice，只是会将list2链表head重新初始化。效果图如下：

1.     /**
2.     * list_splice_tail_init - 合并两个链表，并且重新初始化list为空链表
3.     * @list: 要被合并的list
4.     * @head: 添加到一个列表中的位置
5.     *
6.     */
7.     static inline void list_splice_tail_init(struct list_node  * list,
8.            struct list_node  *head) {
9.         if (!list_empty( list)) {
10.            __list_splice( list, head->prev, head);
11.            INIT_LIST_HEAD( list);
12.        }
13.    }

同list_splice_tail，只是会将list2链表head重新初始化。效果图如下：

宏定义

linux kernel list除了定义了一些函数API之外，还定义了一些宏。这些宏主要是为了方便链表的内部操作和给开发者更方便的使用链表。

指针位置计算

list_entry是linux kernel list提供的一个根据list_node元素在链表元素结构体类型中的指针和结构体自身来计算出该结构体实体的首地址。list_entry其实就是container_of的重定义。container_of在前面的章节已经有过介绍，如有不清楚的，可以参照前面的章节。

1.     /**
2.     * list_entry - 得到实体首地址
3.     * @ptr:    list_node在实体中的指针.
4.     * @type:    list_node所在的结构体类型
5.     * @member:    list_node类型的元素在结构体中的名称.
6.     */    
7.     #define list_entry(ptr, type, member)  container_of(ptr,type,member)

根据位置得到实体

linux kernel list为了自身和第三方开发者的方便，也定义了根据位置信息获取实体的API。linux kernel list的代码定义如下：

1.     /**
2.     * list_first_entry - 得到链表中的第一个实体，即head的next指针指向的实体
3.     * @ptr:    链表的head指针.
4.     * @type:    链表实体的结构体类型.
5.     * @member:    list_node的元素在结构体中的名称.
6.     *
7.     * 注意：链表不能为空。
8.     */
9.     #define list_first_entry(ptr, type, member) \
10.            list_entry((ptr)->next, type, member)
12.     /**
13.     * list_last_entry - 得到链表中最后一个实体，即head的prev指针指向的实体
14.     * @ptr:    链表的head指针.
15.     * @type:    链表实体的结构体类型.
16.     * @member:    list_node的元素在结构体中的名称.
17.     *
18.     * 注意：链表不能为空。
19.     */
20.     #define list_last_entry(ptr, type, member) \
21.            list_entry((ptr)->prev, type, member)
23.     /**
24.     * list_first_entry_or_null - 得到链表中的第一个实体，即head的next指针指向的实体
25.     *                                          如果链表为空，即返回空
26.    * @ptr:    链表的head指针.
27.     * @type:    链表实体的结构体类型.
28.     * @member:    list_node的元素在结构体中的名称    
29.     *
30.     * 注意：该API是list_first_entry的一个扩展
31.     */
32.     #define list_first_entry_or_null(ptr, type, member) \
33.            (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL)
35.     /**
36.     * list_next_entry - 得到当前链表中pos的下一个实体
37.     * @pos:    list_node所在结构体的实体指针
38.     * @member:    list_node在结构体中的名称
39.     *
40.    */
41.     #define list_next_entry(pos,type, member) \
42.            list_entry((pos)->member.next, type, member)
44.     /**
45.     * list_prev_entry - 得到当前链表中pos的前一个实体
46.     * @pos:    list_node所在结构体的实体指针
47.     * @member:    list_node在结构体中的名称
48.     */
49.     #define list_prev_entry(pos, type, member) \
50.            list_entry((pos)->member.prev, type, member)

遍历操作

对链表的操作，最常用的应该就是遍历了吧。每当需要对所有的元素做一些操作的时候，遍历是必不可少的。linux kernel list也不例外。linux kernel list定义的代码如下：

1.     /**
2.     * list_for_each    -    往后遍历链表
3.     * @pos:     list_node结构体的指针，用来作为遍历链表的游标.
4.     * @head:    链表的head指针.
5.     */
6.     #define list_for_each(pos, head) \
7.             for (pos = (head)->next; pos != (head); pos = pos->next)
9.     /**
10.     * list_for_each_prev - 前向遍历链表
11.     * @pos:     list_node结构体的指针，用来作为遍历链表的游标
12.     * @head:    链表的head指针.
13.     */
14.     #define list_for_each_prev(pos, head) \
15.             for (pos = (head)->prev; pos != (head); pos = pos->prev)
17.     /**
18.     * list_for_each_safe -  安全的后向遍历链表，适用于在遍历的过程中需要删除实体的情况
19.     * @pos:          list_node结构体的指针，用来作为遍历链表的游标
20.     * @n:           另外一个list_node结构体的指针，临时存储当前遍历的游标
21.     * @head:    链表的head指针.
22.     */
23.     #define list_for_each_safe(pos, n, head) \
24.             for (pos = (head)->next, n = pos->next; pos != (head); \
25.                    pos = n, n = pos->next)
27.     /**
28.     * list_for_each_prev_safe - 安全的前向遍历链表，适用于在遍历的过程中需要删除实体的情况    
29.     * @pos:          list_node结构体的指针，用来作为遍历链表的游标
30.     * @n:           另外一个list_node结构体的指针，临时存储当前遍历的游标
31.     * @head:    链表的head指针.
32.     */
33.     #define list_for_each_prev_safe(pos, n, head) \
34.             for (pos = (head)->prev, n = pos->prev; \
35.                    pos != (head); \
36.                    pos = n, n = pos->prev)
38.     /**
39.     * list_for_each_entry    -    顺序遍历链表中的实体元素
40.     * @pos:     链表中实体元素的指针.
41.     * @type ： 链表中实体元素的结构体类型
42.     * @head:    lise_node类型的链表头.
43.     * @member:    list_node元素在实体结构式类型中的名称.
44.     */
45.     #define list_for_each_entry(pos,type, head, member) \
46.             for (pos = list_first_entry(head, type, member) \
47.                    &pos->member != (head); \
48.                    pos = list_next_entry(pos, member))
50.     /**
51.     * list_for_each_entry_reverse - 倒序遍历链表中的实体元素.
52.     * @pos:     链表中实体元素的指针.
53.     * @type ： 链表中实体元素的结构体类型
54.     * @head:    lise_node类型的链表头.
55.     * @member:    list_node元素在实体结构式类型中的名称
56.     */
57.     #define list_for_each_entry_reverse(pos, type,head, member) \
58.             for (pos = list_last_entry(head, type, member); \
59.                    &pos->member != (head);  \
60.                    pos = list_prev_entry(pos, member))
62.     /**
63.     * list_prepare_entry - 准备一个实体指针，为list_for_each_entry_continue()中的pos
64.    * @pos:     链表中实体元素的指针.
65.     * @type ： 链表中实体元素的结构体类型
66.    * @member:    list_node元素在实体结构式类型中的名称.
67.     *
68.     * 准备一个实体指针来作为函数list_for_each_entry_continue()中的开始节点
69.     */
70.     #define list_prepare_entry(pos, type,head, member) \
71.            ((pos) ? : list_entry(head, type, member))
73.     /**
74.     * list_for_each_entry_continue - 以链表中的任何一个元素（不包括当前元素）作为起始点遍历链表
75.    * @pos:     链表中实体元素的指针，通常来自于list_prepare_entry.
76.     * @head:    lise_node类型的链表头.
77.     * @member:    list_node元素在实体结构式类型中的名称    
78.     *
79.     * 从当前pos所属的位置遍历链表
80.     */
81.     #define list_for_each_entry_continue(pos, head, member)  \
82.             for (pos = list_next_entry(pos, member); \
83.                    &pos->member != (head); \
84.                    pos = list_next_entry(pos, member))
86.     /**
87.     * list_for_each_entry_continue_reverse - 以链表中的任何一个元素（不包括当前元素）作为起始点反向遍历链表
88.    * @pos:     链表中实体元素的指针，通常来自于list_prepare_entry.
89.     * @head:    lise_node类型的链表头.
90.     * @member:    list_node元素在实体结构式类型中的名称
91.     *
92.     * 从当前pos所属的位置反向遍历链表.
93.     */
94.     #define list_for_each_entry_continue_reverse(pos, head, member) \
95.             for (pos = list_prev_entry(pos, member); \
96.                    &pos->member != (head); \
97.                    pos = list_prev_entry(pos, member))
99.     /**
100.     * list_for_each_entry_from - 以当前元素位置遍历链表，便利中包括当前元素
101.     * @pos:     链表中实体元素的指针
102.     * @head:    lise_node类型的链表头.
103.     * @member:    list_node元素在实体结构式类型中的名称
104.     *
105.     *
106.     */
107.     #define list_for_each_entry_from(pos, head, member)  \
108.             for (; &pos->member != (head); \
109.                    pos = list_next_entry(pos, member))
111.     /**
112.     * list_for_each_entry_safe - 安全的遍历链表中每一个元素，适用于在遍历的过程中需要删除实体的情况
113.     * @pos:     遍历链表过程中的实体指针.
114.     * @n:        遍历过程中临时存储下一个实体的指针
115.     * @head:    链表中list_node类型的head指针.
116.     * @member:    链表中list_node类型的原书名.
117.     */
118.     #define list_for_each_entry_safe(pos, n,type, head, member) \
119.             for (pos = list_first_entry(head, type, member), \
120.                    n = list_next_entry(pos, member); \
121.                    &pos->member != (head);  \
122.                    pos = n, n = list_next_entry(n, member))
124.     /**
125.     * list_for_each_entry_safe_continue - 安全的遍历链表中的每一个元素，不包括pos指向的当前元素，适用于在遍历的过程中需要删除实体的情况
126.     * @pos:       遍历链表过程中的实体指针.
127.     * @n:        遍历过程中临时存储下一个实体的指针
128.     * @head:    链表中list_node类型的head指针.
129.     * @member:    链表中list_node类型的原书名.
130.     *
131.     */
132.     #define list_for_each_entry_safe_continue(pos, n, head, member)  \
133.             for (pos = list_next_entry(pos, member),  \
134.                    n = list_next_entry(pos, member); \
135.                    &pos->member != (head); \
136.                    pos = n, n = list_next_entry(n, member))
138.     /**
139.     * list_for_each_entry_safe_from - 安全的遍历链表中的每一个元素，包括pos指向的当前元素，适用于在遍历的过程中需要删除实体的情况
140.     * @pos:       遍历链表过程中的实体指针.
141.     * @n:        遍历过程中临时存储下一个实体的指针
142.     * @head:    链表中list_node类型的head指针.
143.     * @member:    链表中list_node类型的原书名.
144.     *
145.     */
146.     #define list_for_each_entry_safe_from(pos, n, head, member)  \
147.             for (n = list_next_entry(pos, member); \
148.                    &pos->member != (head); \
149.                    pos = n, n = list_next_entry(n, member))
151.     /**
152.     * list_for_each_entry_safe_reverse - 安全的反向遍历链表中的每一个元素，适用于在遍历的过程中需要删除实体的情况
153.     * @pos:       遍历链表过程中的实体指针.
154.     * @n:        遍历过程中临时存储下一个实体的指针
155.     * @head:    链表中list_node类型的head指针.
156.     * @member:    链表中list_node类型的元素名.
157.     *
158.     */
159.     #define list_for_each_entry_safe_reverse(pos, n,type, head, member) \
160.             for (pos = list_last_entry(head, type, member),  \
161.                    n = list_prev_entry(pos, member);  \
162.                    &pos->member != (head);  \
163.                    pos = n, n = list_prev_entry(n, member))
165.     /**
166.     * list_safe_reset_next - 在list_for_each_entry_safe循环中重置next指针
167.     * @pos :       list_for_each_entry_safe遍历链表过程中的实体指针
168.     * @n:        遍历过程中临时存储下一个实体的指针
169.     * @member:    链表中list_node类型的元素名
170.     *
171.     * 通常情况下，连边会被同时的更改，所以list_safe_reset_next是线程不安全的
172.     * 例如：在循环体内锁被释放
173.     * 如果pos游标指向的实体被固定在链表中，并且list_safe_reset_next不在被锁的循环体内调用，则出现异常。
174.     * 调用list_safe_reset_next请一定要自行注意线程安全问题
175.    */
176.     #define list_safe_reset_next(pos, n, member) \
177.            n = list_next_entry(pos, member)

曾经看到过一句话，大概意思就是：最好的算法只维护结构，不操作实际数据。虽然已经忘记了看到的原话，也忘记了具体在哪里看到的。但唯一还能清楚的记起的就是这句话的意思。看到这句话的时候一直到很久远的以前，也就是在没有看到linux kernel list的实现之前，我一直不太明白这句话的含义，也不太明白到底应该怎么样才能优雅的去解决结构和数据之间的问题。诚然，那个时候是很小白的。但是自从看到了linux kernel list的设计和实现后，一切又豁然开朗了。从接触计算机开始，到大学的各种语言课程、数据结构课程、算法课程，双向列表几乎是必有的。但它们的实现却千篇一律而又统一，可以说，linux kernel list的设计和实现从某些程度上颠覆了很多人对于数据结构和算法的重新认知。

linux kernel list，确实是一个不可多得的简洁而又优雅的设计和实现。

原文地址： https://blog.csdn.net/Msy3TU4dFuUZ4/article/details/78930020