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