linux內核之鏈表操做解析

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類型的指針。

鏈表節點的遍歷操做：

參數相關釋義：

/**
 * @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))