linux list.h文件,list.h头文件分析

structlist_head

{

struct list_head *next, *prev;

};

这个就是那个链表的头！是不觉得很奇怪？怎么只有两个指针域，没有数据域呢？其实我现在也纠结这这个问题着呢！没事，咱们先往下看。说不定什么时候，咱就明白了这是怎么一回事情呢。

#define LIST_HEAD_INIT(name)

{ &(name), &(name)

}

#defineLIST_HEAD(name)

\

struct list_head name = LIST_HEAD_INIT(name)

这俩是宏没错吧！来看看这个俩到底是个什么意思。

先来看看这个LIST_HEAD_INIT(name)，当程序当中出现了这个东西的时候，他立马就会替换成后面的东西，例如出现了：

LIST_HEAD_INIT(headnode)；

他立马就会替换成{&(headnode),&(headnode)}，有人会问这个到底是什么意思；呵呵不要着急！下面详细的说明：

假设有这么一段C代码

……….

struct list_head headnode

;//定义了一个headnode节点

headnode = LIST_HEAD_INIT(headnode);

……….

那么他是不应该再编译阶段就立马的被替换成这样呢？

……….

struct list_head headnode

;//定义了一个headnode节点

headnode = { &(headnode), &(headnode) };

……….

注意：这里面对标准的C进行了拓展叫：GNU

C，这个意思呢就是说，对headnode的两个成员赋值。这赋值之后成了什么样子了呢？看下图：

是不是自己指向了自己？至于为什么可以这么赋值，不是本文讨论的重点，详细的可以www.baidu.com或者www.google.com.hk

其实这里的LIST_HEAD_INIT(name)宏是用来初始化的；

而LIST_HEAD(name)宏则是用来定义+初始化。你看LIST_HEAD(name)宏是不比LIST_HEAD_INIT(name)宏多了这句

struct list_head

name

？

记住：LIST_HEAD_INIT(name)宏是用来初始化的；LIST_HEAD(name)宏则是用来定义+初始化。

OK，我们接着往下看：

static inline void

INIT_LIST_HEAD(struct list_head

*list)

{

list->next = list;

list->prev = list;

}

奇怪这里怎么好像又是在初始化，而且还和上面的功能一样。我觉得，他们这样做有如下考虑：1、有些人习惯于调用函数进行初始化，而有的人喜欢代码简洁而直接使用宏来进行初始化，但是不论是那种方式，都达到了一样的功能-----初始化。

在往下看，有关链表添加的

#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前面可是两个下划线”_”；这个就是说，这个函数是linux内核的东西，你再使用的时候，你就得注意了。一看名字就知道是增加链表节点；其实我们再学习双向链表的时候，那么多的指针操作，能把人绕死，而且到最后也搞得不清楚，你看看人家linux源代码是咋实现的：是不觉得有差距？？大致格局如下图：自己用纸画画，我这里弄个图片很不容易的。

红色的是节点名字，黑色的是指针域。

在往下看：

static inline

void list_add(struct

list_head *new, struct list_head

*head)

{

__list_add(new,

head, head->next);

}

刚才不说了么，前头哟俩下划线的让你谨慎的使用么，这不？人家有给你弄了一个函数，可以调用这个函数来进行链表的添加。实际上，还是调用的是刚才的那个有两个下划线的函数。这里体现了像个思想：1、封装，其实这个概念是C++等一类程序设计语言的OOP思想，用在了这里。2、重用，很多时候，代码其实都是可以不用自己写的，有一些现成的东西你可以去调用，这样可以很好的提高生产效率，而且linux源代码使用的是GPL许可证，没有什么版权啊乱七八糟的东西，有这么好的东西干嘛不用呢？其实下来的这个你会体会的更深：

static inline

void list_add_tail(struct

list_head *new, struct list_head

*head)

{

__list_add(new,

head->prev, head);

}

看名字，看看list_add_tail这个名字。是不是“尾插法”？还是调用了前头的那个有两个下划线的函数吧？而且，人家仅仅只是调换了一下参数的次序。高明吧！

好！再接着往下看：

static inline

void __list_del(struct list_head * prev, struct list_head *

next)

{

next->prev = prev;

prev->next = next;

}

#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

这里是删除一节点，这里再一次的体现了封装和重用的思想。不过这里注意：

在讲entry这个节点删除之后你得将它指向一个正确的错误区域！什么意思呢，就是说，你的将它放在一个大家公认的错误的地方，因为所有的人都不会去碰那个错误的地方，所以：你这个entry就不会引起各种不必要的麻烦。其实这里有一个问题：放你free了某个节点之后，其实，我们还是可以使用这个节点的，这个在我同学的一篇博文里讲述的很清楚：

http://blog.sina.com.cn/s/blog_6e9342530100yaef.html

其实这里，LIST_POISON1= 0x00100100.

LIST_POISON2=0x00200200。为什么，我不知道。

下来接着看这个替换函数。将链表当中某个节点用新的节点替换掉。

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;

}

下面在给出图例：

大家可以根据图例来理解。

下来这个函数就是将某个链表里头的节点删除，然后添加到另外一个链表当中。你会发现代码很简单

static inline

void list_move(struct

list_head *list, struct list_head

*head)

{

__list_del(list->prev,

list->next);

list_add(list,

head);

}

呵呵，是不是出乎你的意料了？？确实，这里在一次的体现了代码的重用思想。不愧是linux内核源代码，就是这样简洁高效！！

下面这两个函数，一个用来判断是否为链表的最后一个节点，一个用来判断该链表是否为空。

static inline

int list_is_last(const

struct list_head

*list,

const struct list_head

*head)

{

return list->next ==

head;

}

static inline

int list_empty(const

struct list_head

*head)

{

return head->next ==

head;

}

详细情况如下图：

然而实际上，我们用这种方式来判断链表是否为空是不太精确的。它同时判断头指针的next和prev，仅当两者都指向自己时才返回真。这主要是为了应付另一个cpu正在处理同一个链表而造成next、prev不一致的情况。但代码注释也承认，这一安全保障能力有限：除非其他cpu的链表操作只有list_del_init()，否则仍然不能保证安全，也就是说，还是需要加锁保护。

两个链表合并：

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;

}

static inline

void list_splice(const

struct list_head

*list,

struct list_head

*head)

{

if (!list_empty(list))

__list_splice(list,

head, head->next);

}

假设当前有两个链表，表头分别是list1和list2(都是struct

list_head变量)，当调用list_splice(&list1,&list2)时，只要list1非空，list1链表的内容将被挂接在list2链表上，位于list2和list2.next(原list2表的第一个节点)之间。新list2链表将以原list1表的第一个节点为首节点，而尾节点不变。如图(虚箭头为next指针)：如下图所示：

目前函数分析就到这里；由于篇幅限制，下篇博文，将详细介绍list.h当中的一些重要的宏！！