linux驱动中的链表操作

一、链表的基本概念

链表是一种物理存储单元上非连续的存储结构，数据单元的逻辑顺序是通过链表中的指针链接次序实现的。通常链表有单向链表和双向链表，如下图所示：

其中data表示数据域，用来存放正真的数据。next和prev表示指针域，用来存放节点的首地址。next指针指向下一个节点，而prev指针指向上一个节点。这样单链表能通过next指针单向遍历整个链表中节点，而双向链表则能通过next和prev指针双向地遍历整个链表。除了以上两种，还有单向循环链表和双向循环链表，区别就是在循环链表中最后一个节点的next指针指向了第一个节点，而第一个节点的prev指针则指向了最后一个节点。

二、链表在linux驱动中的应用（以pl330驱动为例）

链表在linux驱动及内核中的使用是非常普遍的，且在include/linux/list.h文件中封装了许多链表的通用操作函数。在驱动中可以直接使用这些函数来进行链表操作。以下以pl330.c驱动程序中链表的使用为例。

1、  几个相关的数据结构

在pl330.c中有如下三个结构体：

struct dma_pl330_desc{struct list_head node;...};struct pl330_dmac{struct list_head desc_pool;...};struct dma_pl330_chan{struct list_head work_list;...};

其中list_head结构体定义在include/linux/Types.h文件中：

struct list_head {struct list_head *next, *prev;};

pl330_dmac和dma_pl330_chan的desc_pool和work_list成员分别代表了两个链表的头结点。而dma_pl330_desc的node成员则会被添加到这两个链表中。比如现在有3个dma_pl330_desc结构体变量desc1,desc2,desc3，分别对应了3个node成员node1,node2,node3。将这三个node添加到desc_pool链表中后，将是如下组织结构(只是简单的示例)：

其中三个虚线框图代表desc1,desc2和desc3结构体变量。在node节点中没有包含数据域，数据实际上是存放在dma_pl330_desc结构体中的。根据图中的这种结构我们就可以通过desc_pool这个链表头节点来遍历到链表中的任何一个node节点，然后使用container_of函数来获取该node节点所在的dma_pl330_desc结构体变量的指针，从而访问到dma_pl330_desc结构体变量的数据。

2、  desc_pool链表的初始化

static int add_desc(struct pl330_dmac*pl330, gfp_t flg, int count){         struct dma_pl330_desc *desc;         unsigned long flags;         int i;          desc= kcalloc(count, sizeof(*desc), flg);         if(!desc)                   return 0;          spin_lock_irqsave(&pl330->pool_lock,flags);          for(i = 0; i < count; i++) {                   _init_desc(&desc[i]);//初始化描述符结构                   list_add_tail(&desc[i].node,&pl330->desc_pool); //将这个描述符结构添加到desc_pool链表中         }         spin_unlock_irqrestore(&pl330->pool_lock,flags);          return count;}

add_desc函数的功能就是先分配count个dma_pl330_desc结构体变量，初始化后将这些变量通过node节点添加到pl330_dmac的desc_pool链表中。node节点添加到desc_pool链表的动作是通过list_add_tail这个函数来完成。当然在这之前desc_pool这个节点首先会通过INIT_LIST_HEAD函数初始化，该函数为：

static inline void INIT_LIST_HEAD(struct list_head *list){list->next = list;list->prev = list;}

可知初始化后的desc_pool节点为：（即prev和next指针都指向了desc_pool节点本身）

假设add_desc函数传入的count为3，则for循环就为：

         for(i = 0; i < 3; i++) {                   _init_desc(&desc[i]);//初始化desc[i],并使INIT_LIST_HEAD初始化它的node节点                   list_add_tail(&desc[i].node,&pl330->desc_pool);         }

将desc[0].node添加到desc_pool后，链表形式为：

将desc[1].node添加到desc_pool后，链表形式为：

将desc[2].node添加到desc_pool后，链表形式为：

所以这里desc_pool链表实际上是一种双向循环链表。

3、  链表的一些操作

（1）检查链表是否为空

可用list_empty(&desc_pool)来检查desc_pool链表是否为空，如果为空则返回true。该函数为：

static inline int list_empty(const struct list_head *head){         return head->next == head;}

根据图3就能很容易理解这里。

（2）向desc_pool添加节点

通过list_add_tail(&desc[2].node, &pl330->desc_pool)就可以将desc[2]的node节点添加到desc_pool链表的末尾。该函数为：

static inline void list_add_tail(struct list_head *new, struct list_head *head){         __list_add(new,head->prev, head);}

而__list_add函数为：

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;}

根据图5~6就可以很容易理解这段代码。

（3）从desc_pool删除节点

可以使用list_del_init(&desc[2]->node)将desc[2]的node节点从desc_pool移除，并将该节点初始化为空。该函数为：

static inline void list_del_init(struct list_head *entry){         __list_del_entry(entry);         INIT_LIST_HEAD(entry);}

__list_del_entry的函数体为：

static inline void __list_del_entry(struct list_head *entry){         __list_del(entry->prev,entry->next);}

而__list_del为：

static inline void __list_del(struct list_head * prev, struct list_head * next){         next->prev= prev;         prev->next= next;}

该函数执行完后，desc_pool链表就会从图6变为图5。

 （4）将节点从一个链表移动到另一个链表

可以使用list_move_tail(&desc[2]->node, &work_list)将desc[2]的node节点从desc_pool移动到work_list链表中。该函数会先将desc[2]的node节点从desc_pool删除掉，然后再添加到work_list链表中。

static inline void list_move_tail(struct list_head *list,                                       struct list_head *head){         __list_del_entry(list);         list_add_tail(list,head);}

（5）遍历desc_pool链表

链表只是一种组织数据的方法，我们实际应用中真正关心的是数据本身。比如在这里我们想要获取的是dma_pl330_desc结构体数据，而不是node节点。那么我们怎么通过desc_pool链表头节点来获取dma_pl330_desc结构体数据desc[0]、desc[1]和desc[2]呢？如下所示我们可以通过list_for_each_entry来实现这个目标：

list_for_each_entry(desc, & desc_pool, node) //----A{···}

其中desc是dma_pl330_desc类型的指针，list_for_each_entry实际上是一个宏定义，代表了一个for循环，为：

</pre><pre>

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

所以可知代码段A等价于：

for(desc = list_first_entry(& desc_pool, typeof(*desc), node);           //-----B      & desc -> node!= (& desc_pool);                                    //-----C      desc = list_next_entry(desc, node))                                //-----D{   ````}

list_first_entry的定义为：

#define list_first_entry(ptr, type, member)\         list_entry((ptr)->next,type, member)

而list_entry定义为：

#define list_entry(ptr, type, member) \         container_of(ptr,type, member)

所以最终的调用为：container_of((& desc_pool)->next, dma_pl330_desc, node)

这一句代码会返回一个指向dma_pl330_desc结构体变量的指针，在该变量中包含了(& desc_pool)->next指针所指向的节点node。结合图6可知B段代码会返回结构体数据desc[0]的指针。

C段代码的作用是判断当前desc->node是否与desc_pool相同，如果是一样，说明当前的这个desc指针是无效的，退出循环。

D段代码中list_next_entry定义为：

#define list_next_entry(pos, member) \         list_entry((pos)->member.next,typeof(*(pos)), member)

所以最终也就是调用container_of(desc->node.next, dma_pl330_desc, node)，即获取下一个dma_pl330_desc变量。所以综上所述，list_for_each_entry(desc,& desc_pool, node)会顺序遍历desc_pool链表，并通过desc指针来返回desc[0] 、desc[1]和desc[2]的指针。

 注：如果在处理过程中涉及到了链表中节点的删除操作，则需要使用list_for_each_entry_safe(pos, n, head, member)来代替list_for_each_entry(pos,head, member)。

（6）将work_list链表添加到desc_pool链表

假设在work_list链表中链接了desc[3]和desc[4]如下所示：

那么可以使用list_splice_tail_init(&work_list,&desc_pool)将work_list中所有的节点移动到desc_pool链表中，并将work_list初始化为空。list_splice_tail_init函数定义为：

static inline void list_splice_tail_init(struct list_head *list,                                                struct list_head *head){         if(!list_empty(list)) {  //判断list链表是否为空。                   __list_splice(list,head->prev, head);                   INIT_LIST_HEAD(list);//初始化list链表为空         }}

其中节点的移动实际是通过__list_splice(&work_list, （&desc_pool）->prev, &desc_pool)来完成的，__list_splice函数定义为：

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;}

执行完后，work_list为空链表，而desc_pool链表如下所示。（结合图6、图7和图8就能很容易理解这里的代码）