linux内核之链表操做解析

时间  2019-11-20
标签 linux 内核 链表 解析 栏目 Linux 繁體版
原文   原文链接

linux内核之链表操做解析

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

代码分析

链表结构体：

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

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

链表头节点相关操做：

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

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

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

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

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

链表整合操做：

// 这个函数的实现有点很差解释，若是要想理解这个函数的意思最好是根据后面的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;  
}

原始链表整合操做图：
imagecode

// 这个函数是先考虑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的理解blog

咱们来看一下container_of的宏定义：get

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

其次，offsetof的宏定义：it

#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类型的指针。

链表节点的遍历操做：

参数相关释义：

/**
 * @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))
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程