linux內核之鏈表操作解析

原創 脱水的a鱼 2020-06-14 22:27

耐心品味本文章對於Linux內核中list的使用會有很深入的瞭解，獲益良多

本文只是對linux內核中的鏈表進行分析。內核版本是linux-2.6.32.63。文件在：linux內核/linux-2.6.32.63/include/linux/list.h。本文對list.h文件進行簡要分析，有必要的地方還會以圖進行說明。

代碼分析

本文只是對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))
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

ARM linux hard soft irq

今天在ChinaUnix論壇內核源碼版上與linuxfellow網友討論到hardirq和softirq的問題，雖 然在《深入Linux設備驅動程序內核機制》(以下簡稱“ILDD”)第5章“中斷處理”對此已有詳細的解讀，但是我覺得還是

dianhuiren 2020-06-29 06:02:21

mtd Nand驅動

大約用了兩個禮拜不到的時間爲公司的IPcamera系統寫了基於MTD的NAND驅動(linux-2.6.22.10內核)，目前已可以在該驅動的支持下跑cramfs和jffs2文件系統，另外，該驅動也可以同時支持small page(每頁

dianhuiren 2020-06-29 06:02:21

Linux內核的抽象結構

          圖1.2  Linux內核子系統及其之間的關係     1.進程調度(SCHED)控制着進程對CPU的訪問。當需要選擇下一個進程運行時，由調度程序選擇最值得運行的進程。可運行進程實際是僅等待 CPU 資源的進程

zhongyhc 2020-06-28 19:12:12

Linux 內核開發-筆記

操作系統課程作業要求，針對linux 2.6的內核（kernel）進行開發，詳細的要求和材料可以參照課程連接： CS3 OPERATING SYSTEMS, PRACTICAL EXERCISE PHASE 1 PHASE 2 主要爲如

raymond_kwan 2020-06-27 01:33:04

[Windows驅動開發]（三）基礎知識——驅動例程

一、NT式驅動的基本例程 1. 驅動入口函數——DriverEntry // 驅動程序的一般性定義 NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_

baggiowangyu 2020-06-16 16:13:56

Windows文件系統過濾驅動中打開文件時如何避免重入

調用下面的函數可以避免在打開回調中打開新的文件的時候引起重入 NTSTATUS IoCreateFileSpecifyDeviceObjectHint( __out PHANDLE FileHandle, __in

baggiowangyu 2020-06-16 16:13:56

Linux GPIO驅動 - 硬件及硬件抽象層

在很多的SOC芯片裏，GPIO硬件接口都是和其它硬件接口共用Pin腳，然後通過特定的寄存器去設置Pin使用時的類型。比如目前手上的項目使用的是Mar

脱水的a鱼 2020-06-14 22:27:13

linux gpio接口

一.相關結構體 1.gpio_chip代表一個芯片的一個gpio bank [cpp] view plain copy struct gpio_chip {  //gpio bank      const char  *labe

脱水的a鱼 2020-06-14 22:27:13

AT&T asm

dai_weitao 2020-02-23 05:06:20

中斷和異常

dai_weitao 2020-02-23 05:06:20

內核調試

dianhuiren 2020-02-22 07:30:00

2.6的系統調用

dianhuiren 2020-02-22 07:30:00

內核同步機制

dianhuiren 2020-02-22 07:30:00

Linux內核調試技術指南

dianhuiren 2020-02-22 07:30:00

總線設備驅動模型

dianhuiren 2020-02-22 07:30:00