structname {
intnum;
...;
structname *next;
structname *prev;
}
但是linux内核中的实现确有点特殊他是通过独立定义一个链表结构,通过结构体中内嵌这个结构来完成的,这样就实现了链表的定义与结构体的分离。linux内核中广泛的应用了这种链表,可以这么说,如果没有linux list_head链表就不会有现在linux的强大。本来我就以为只有linux内核用这种链表,但是当我分析完lsusb的代码后,发现这个程序也是用内核链表来组织数据结构的,我想Kroah-Hartman不愧为内核的维护者,连应用程序都带着内核的影子。我就试着在应用程序中使用这种链表,发现他的非常的好用,只要包含list.h,然后在结构体重嵌入这种链表,就能方便的实现数据结构的线性链接。下面我就简单的介绍一下这种链表的实现原理。
list.h中首先定义了这样一个结构体,这个是链表的基本结构:
structlist_head {
structlist_head *next, *prev;
};
我们使用的时候,在自己的结构体中内嵌这个结构就行了,如下;
structmy_struct {
inta;
intb;
...
structlist_head list;
}
这个链表链接起来的不是结构体本身,而是list_head结构。需要一个链表头,这个链表头是list_head结构,不需要内嵌在任何结构中,在使用链表的时候要定义以及初始化这样一个结构。list.h中已经定义了宏用于定义与初始化链表头,如下:
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
structlist_head name = LIST_HEAD_INIT(name)
#define INIT_LIST_HEAD(ptr) do { \
(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while(0)
LIST_HEAD(name)宏用来定义一个链表头,使得他的两个指针都指向自己。我们可以直接在程序的变量声明处,直接调用LIST_HEAD(name)宏,来定义并初始化一个名为name的链表,也可以先声明一个链表,调用INIT_LIST_HEAD来初始化这个链表。从宏定义山看不能直接使用LIST_HEAD_INIT,它只适合声明初始化。
定义了一个链表后,最重要的操作是向链表添加元素,与删除元素以及遍历链表。下面先说添加元素的操作:
staticinlinevoid__list_add(structlist_head *new,
structlist_head *prev,
structlist_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
staticinlinevoidlist_add(structlist_head *new,structlist_head *head)
{
__list_add(new, head, head->next);
}
staticinlinevoidlist_add_tail(structlist_head *new,structlist_head *head)
{
__list_add(new, head->prev, head);
}
向链表添加元素只知道链表的头与新的元素地址就可以了,因为链表是双向循环链表,链表头的前一个元素就是这个链表的最后一个元素。list_add是将新元素添加到链表头的后面,而list_add_tail是将心元素添加到链表的尾部,这两个操作如下图所示:
图 1 list_add操作
图 2 list_add_tail操作
说完了添加元素,下面说一下如何删除链表元素,如下:
staticinlinevoid__list_del(structlist_head *prev,structlist_head *next)
{
next->prev = prev;
prev->next = next;
}
staticinlinevoidlist_del(structlist_head *entry)
{
__list_del(entry->prev, entry->next);
}
删除链表元素也非常简单,只需要找到前一个元素与后一个元素,将他们链接在一起就可以了。
list_head链表最重要的特点就是链表操作与结构体分离,用list_head链接的链表结构上如下图所示:
图 3 list_head链表特点
但是我们使用链表的目的不是链表本身,而是内嵌链表的结构体,我们可以方便的遍历list_head结构,如下:
for( mylist = mylist_head->next; mylist != mylist_head; mylist = mylist->next);
但是这样的程序没有什么作用,我们需要的是结构体。所以需要一种技术使得由list_head的地址找到内嵌他的结构提的地址,这个技术就是内核中顶顶大名的container_of宏,这个宏就是list_head链表的精髓,它的初衷是为了实现由结构体的元素的地址而找到结构体首地址。借鉴这种技术就可以实现我们的目的。如下:
#define list_entry(ptr, type, member) \
((type *)((char*)(ptr)-(unsignedlong)(&((type *)0)->member)))
这个宏实现非常的简单,但是往往伟大的思想就蕴藏在简单的代码中,我们来分析一下这个宏。首先他是一个带参数的宏,有三个参数第一个参数是一个地址,他是结构体中元素的地址,第二个参数是结构体类型,第三个参数是,元素在结构体中的名字。我们以list_head链表为例来说明。例如有如下结构:
structmy_struct {
inta;
charb;
...
strcut list_head list;
}
我们知道了里面的list_head元素的地址为plist,需要找到类型问struct my_struct结构变量的地址。就需要这样调用宏
struct my_struct *ptr = list_entry(plist, struct my_struct, list);
list_entry宏实现的非常巧妙,括号比较多,让我们将这个宏分解来看。
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
最外面的一层括号可以去掉,这是为了防止宏扩展的,去掉如下:
(type *) ((char *)(ptr)-(unsigned long)(&((type *)0)->member))
现在就比较清楚了,首先(type *)是C强制转换操作,就是将后面的的数据转化成type结构的指针。而后面的操作可以再分解
(char *)(ptr) - (unsigned long)(&((type *)0)->member)
这样就是一个减法的操作,前面是一个指针,我们传过去的结构体元素的指针,这里被转化成指向字符的。而后面是一个长整形,可以再分解
(unsigned long) (&((type *)0)->member)
显然这个长整形是一个指针转化的,而这个指针又可以再分解,
&((type *)0)->member
可以看出这个指针是一个变量取地址得到的,这个变量又是什么呢
((type *)0)->member
看起来有点奇怪,不过这个操作是整个宏中最精妙的,他将地址0转化成type类型,接下来又取得这个结构的member元素,member就是我们传进来的参数:元素在结构体中的命名。其实((type *)0)->member取的变量是内容是什么一点都不重要,重要的我们要取这个变量的地址。取完这个地址将它转换成unsigned long类型,这样这个数据就是((type *)0)->member相对与地址0的偏移。回到上面的那个减法,将结构体中元素的地址与他与结构体首地址的偏移相减,不就得到了结构体的地址了吗。整个操作如下图所示:
图 4 list_entry 宏
双向链表在Linux内核中的实现
Linux内核对双向循环链表的设计非常巧妙,链表的所有运算都基于只有两个指针域的list_head结构体来进行。
structlist_head {
structlist_head *next, *prev;
};
链表的运算(源代码都在linux-2.6.38.8/include/linux/list.h文件中定义,并且假定CONFIG_DEBUG_LIST未定义):
(1)、链表头结点的创建
2.1.1 静态创建
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
structlist_head name = LIST_HEAD_INIT(name)
通过LIST_HEAD宏创建一个list_head结构体变量name,并把name的所有成员(next和prev)都初始化为name的首地址。
2.1.2 动态创建
staticinlinevoidINIT_LIST_HEAD(structlist_head *list)
{
list->next = list;
list->prev = list;
}
把list_head结构体变量的首地址传递给INIT_LIST_HEAD函数来对其成员进行初始化。
(2)、结点的添加
list_add函数是把新结点new添加到head结点的后面,而list_add_tail函数是把新结点new插入到结点head的前面。
函数源代码如下:
staticinlinevoid__list_add(structlist_head *new,
structlist_head *prev,
structlist_head *next)
{
next->prev =new;
new->next = next;
new->prev = prev;
prev->next =new;
}
staticinlinevoidlist_add(structlist_head *new,structlist_head *head)
{
__list_add(new, head, head->next);
}
staticinlinevoidlist_add_tail(structlist_head *new,structlist_head *head)
{
__list_add(new, head->prev, head);
}
图示如下:
(3)、结点的删除
list_del函数的作用是将结点*entry从链表中移走,并把此结点的两个成员分别初始化为LIST_POISON1和LIST_POISON2。注意,这里的*entry结点所占用的内存并没有被释放。
list_del_init函数的作用也是将结点*entry从链表中移走,但它把此结点的两个成员初始化为entry。
staticinlinevoid__list_del(structlist_head * prev,structlist_head * next)
{
next->prev = prev;
prev->next = next;
}
staticinlinevoid__list_del_entry(structlist_head *entry)
{
__list_del(entry->prev, entry->next);
}
staticinlinevoidlist_del(structlist_head *entry)
{
__list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
staticinlinevoidlist_del_init(structlist_head *entry)
{
__list_del_entry(entry);
INIT_LIST_HEAD(entry);
}
LIST_POISON1和LIST_POISON2的值定义在linux-2.6.38.8/include/linux/poison.h文件中:
#define LIST_POISON1 ((void *) 0x00100100 + POISON_POINTER_DELTA)
#define LIST_POISON2 ((void *) 0x00200200 + POISON_POINTER_DELTA)
其中POISON_POINTER_DELTA的值在CONFIG_ILLEGAL_POINTER_VALUE未配置时为0。
(4)、结点的替换
list_replace函数的作用是用结点*new替换掉结点*old,list_replace_init函数的作用与list_replace相同,除了它还会把*old结点的两个成员初始化为old外。
staticinlinevoidlist_replace(structlist_head *old,
structlist_head *new)
{
new->next = old->next;
new->next->prev =new;
new->prev = old->prev;
new->prev->next =new;
}
staticinlinevoidlist_replace_init(structlist_head *old,
structlist_head *new)
{
list_replace(old,new);
INIT_LIST_HEAD(old);
}
(5)、结点的移动
list_move函数的作用是把*list结点从它所在的链表中移除,然后把它添加到*head结点的后面。list_move_tail函数的作用与list_move相同,但它把*list插入到*head结点的前面。
staticinlinevoidlist_move(structlist_head *list,structlist_head *head)
{
__list_del_entry(list);
list_add(list, head);
}
staticinlinevoidlist_move_tail(structlist_head *list,
structlist_head *head)
{
__list_del_entry(list);
list_add_tail(list, head);
}
(6)、判断*list是否是链表head的最后一个结点,是则返回1,否则返回0
staticinlineintlist_is_last(conststructlist_head *list,
conststructlist_head *head)
{
returnlist->next == head;
}
(7)、判断head是否为空表,是则返回1,否则返回0
staticinlineintlist_empty(conststructlist_head *head)
{
returnhead->next == head;
}
staticinlineintlist_empty_careful(conststructlist_head *head)
{
structlist_head *next = head->next;
return(next == head) && (next == head->prev);
}
(8)、翻转链表
staticinlinevoidlist_rotate_left(structlist_head *head)
{
structlist_head *first;
if(!list_empty(head)) {
first = head->next;
list_move_tail(first, head);
}
}
(9)、判断链表是否只有一个结点,是则返回1,否则返回0
staticinlineintlist_is_singular(conststructlist_head *head)
{
return!list_empty(head) && (head->next == head->prev);
}
(10)、切割链表
list_cut_position函数的功能是将链表head从头结点head(不包含)开始到entry(包含,并且它是链表head中的结点)结点结束之间的所有结点都切割下来,并添加到list上,以组成一个新的链表list。原来的head链表将组成一个新的小链表。
staticinlinevoid__list_cut_position(structlist_head *list,
structlist_head *head,structlist_head *entry)
{
structlist_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;
}
staticinlinevoidlist_cut_position(structlist_head *list,
structlist_head *head,structlist_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);
}
(11)、合并链表
list_splice函数的作用是将链表list(不包含结点*list)插入到链表head的head结点后,而list_splice_tail函数的作用是将链表list(不包含结点*list)插入到链表head的head结点前。
list_splice_init和list_splice_tail_init函数的作用与其相应的函数相同,除了它们都初始化*list结点为list。
staticinlinevoid__list_splice(conststructlist_head *list,
structlist_head *prev,
structlist_head *next)
{
structlist_head *first = list->next;
structlist_head *last = list->prev;
first->prev = prev;
prev->next = first;
last->next = next;
next->prev = last;
}
staticinlinevoidlist_splice(conststructlist_head *list,
structlist_head *head)
{
if(!list_empty(list))
__list_splice(list, head, head->next);
}
staticinlinevoidlist_splice_tail(structlist_head *list,
structlist_head *head)
{
if(!list_empty(list))
__list_splice(list, head->prev, head);
}
staticinlinevoidlist_splice_init(structlist_head *list,
structlist_head *head)
{
if(!list_empty(list)) {
__list_splice(list, head, head->next);
INIT_LIST_HEAD(list);
}
}
staticinlinevoidlist_splice_tail_init(structlist_head *list,
structlist_head *head)
{
if(!list_empty(list)) {
__list_splice(list, head->prev, head);
INIT_LIST_HEAD(list);
}
}
(12)、通过成员指针获得整个结构体的指针
链表操作如果仅仅针对list_head结构体就没有什么意义,所以必须要获得包含它的整个结构体的地址。它们只是对container_of宏的封装,关于container_of宏的使用方法请参考http://blog.csdn.net/npy_lp/article/details/7010752。
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
#define list_first_entry(ptr, type, member) \
list_entry((ptr)->next, type, member)
(13)、遍历链表
list_for_each函数是根据list_head的next成员来遍历整个链表,而list_for_each_prev函数是根据prev成员。其中参数head一般是链表的头结点。
#define list_for_each(pos, head) \
for(pos = (head)->next; prefetch(pos->next), pos != (head); \
pos = pos->next)
#define __list_for_each(pos, head) \
for(pos = (head)->next; pos != (head); pos = pos->next)
#define list_for_each_prev(pos, head) \
for(pos = (head)->prev; prefetch(pos->prev), pos != (head); \
pos = pos->prev)
list_for_each_safe和list_for_each_prev_safe函数使用list_head结构体变量n作为临时存储变量。
#define list_for_each_safe(pos, n, head) \
for(pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
#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)
list_for_each_entry和list_for_each_entry_reverse函数的作用是根据head的下一个或前一个结点来遍历整个head链表,并返回包含list_head结构体成员的大结构体指针,member是list_head结构体在大结构体中的成员名。
#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))
#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))
list_for_each_entry_continue和list_for_each_entry_continue_reverse函数是以pos的下一个或前一个结点开始遍历链表head。
#define list_prepare_entry(pos, head, member) \
((pos) ? : list_entry(head, typeof(*pos), member))
#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_from函数以当前结点pos开始遍历。
#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))
list_for_each_entry_safe、list_for_each_entry_safe_continue、list_for_each_entry_safe_from和list_for_each_entry_safe_reverse这四个函数中的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))
list_safe_reset_next函数的作用是根据结点pos获得n。
#define list_safe_reset_next(pos, n, member) \
n = list_entry(pos->member.next, typeof(*pos), member)