共计 4402 个字符，预计需要花费 12 分钟才能阅读完成。
| 导读 | Linux 内核中自己实现了双向链表，可以在 include/linux/list.h 找到定义。我们将会首先从双向链表数据结构开始介绍内核里的数据结构。为什么？因为它在内核里使用的很广泛，你只需要在 free-electrons.com 检索一下就知道了。 |
struct list_head {struct list_head *next, *prev;};举个例子来说，在 glib 库里是这样实现的：
struct GList {
gpointer data;
GList *next;
GList *prev;
};但是 Linux 内核中的链表实现并没有这样做。所以问题来了：链表在哪里保存数据呢？实际上，内核里实现的链表是侵入式链表（Intrusive list）。侵入式链表并不在节点内保存数据 - 它的节点仅仅包含指向前后节点的指针，以及指向链表节点数据部分的指针——数据就是这样附加在链表上的。这就使得这个数据结构是通用的，使用起来就不需要考虑节点数据的类型了。
struct nmi_desc {
spinlock_t lock;
struct list_head head;
};如上所述，在内核里有很多很多不同的地方都用到了链表。我们来看一个在杂项字符驱动里面的使用的例子。在 drivers/char/misc.c 的杂项字符驱动 API 被用来编写处理小型硬件或虚拟设备的小驱动。这些驱动共享相同的主设备号：
#define MISC_MAJOR 10ls -l /dev | grep 10
crw------- 1 root root 10, 235 Mar 21 12:01 autofs
drwxr-xr-x 10 root root 200 Mar 21 12:01 cpu
crw------- 1 root root 10, 62 Mar 21 12:01 cpu_dma_latency
crw------- 1 root root 10, 203 Mar 21 12:01 cuse
drwxr-xr-x 2 root root 100 Mar 21 12:01 dri
crw-rw-rw- 1 root root 10, 229 Mar 21 12:01 fuse
crw------- 1 root root 10, 228 Mar 21 12:01 hpet
crw------- 1 root root 10, 183 Mar 21 12:01 hwrng
crw-rw----+ 1 root kvm 10, 232 Mar 21 12:01 kvm
crw-rw---- 1 root disk 10, 237 Mar 21 12:01 loop-control
crw------- 1 root root 10, 227 Mar 21 12:01 mcelog
crw------- 1 root root 10, 59 Mar 21 12:01 memory_bandwidth
crw------- 1 root root 10, 61 Mar 21 12:01 network_latency
crw------- 1 root root 10, 60 Mar 21 12:01 network_throughput
crw-r----- 1 root kmem 10, 144 Mar 21 12:01 nvram
brw-rw---- 1 root disk 1, 10 Mar 21 12:01 ram10
crw--w---- 1 root tty 4, 10 Mar 21 12:01 tty10
crw-rw---- 1 root dialout 4, 74 Mar 21 12:01 ttyS10
crw------- 1 root root 10, 63 Mar 21 12:01 vga_arbiter
crw------- 1 root root 10, 137 Mar 21 12:01 vhcistruct miscdevice
{
int minor;
const char *name;
const struct file_operations *fops;
struct list_head list;
struct device *parent;
struct device *this_device;
const char *nodename;
mode_t mode;
};在源代码文件的开始可以看到这个链表的定义：
static LIST_HEAD(misc_list);它实际上是对用 list_head 类型定义的变量的扩展。
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)这会使用变量 name 的地址来填充 prev 和 next 结构体的两个变量。
#define LIST_HEAD_INIT(name) {&(name), &(name) }它在一开始就用函数 INIT_LIST_HEAD 初始化了 miscdevice->list。
INIT_LIST_HEAD(&misc->list);static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
list->prev = list;
}我们就用下面的语句将设备添加到设备链表：
list_add(&misc->list, &misc_list);我们来看看它的实现：
static inline void list_add(struct list_head *new, struct list_head *head)
{__list_add(new, head, head->next);
}new – 新项。
head – 新项将会插在 head 的后面
head->next – 插入前，head 后面的项。
__list_add 的实现非常简单：
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;
}所以我们开始时用宏 LIST_HEAD_INIT 定义的 misc 链表会包含指向 miscdevice->list 的向前指针和向后指针。
这儿还有一个问题：如何得到列表的内容呢？这里有一个特殊的宏：
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)ptr – 指向结构 list_head 的指针；
type – 结构体类型;
member – 在结构体内类型为 list_head 的变量的名字；
const struct miscdevice *p = list_entry(v, struct miscdevice, list)然后我们就可以使用 p ->minor 或者 p->name 来访问 miscdevice。让我们来看看 list_entry 的实现：
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)如我们所见，它仅仅使用相同的参数调用了宏 container_of。初看这个宏挺奇怪的：
#define container_of(ptr, type, member) ({ \
const typeof(((type *)0)->member ) *__mptr = (ptr); \
(type *)((char *)__mptr - offsetof(type,member) );})编译器会执行花括号内的全部语句，然后返回最后的表达式的值。
#include <stdio.h>
int main() {
int i = 0;
printf("i = %d\n", ({++i; ++i;}));
return 0;
}最终会打印出 2。
就如你从名字所理解的，它仅仅返回了给定变量的类型。当我第一次看到宏 container_of 的实现时，让我觉得最奇怪的就是表达式 ((type *)0) 中的 0。实际上这个指针巧妙的计算了从结构体特定变量的偏移，这里的 0 刚好就是位宽里的零偏移。
#include <stdio.h>
struct s {
int field1;
char field2;
char field3;
};
int main() {printf("%p\n", &((struct s*)0)->field3);
return 0;
}结果显示 0x5。
它的实现和上面类似：
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
现在我们来总结一下宏 container_of。只需给定结构体中 list_head 类型 字段的地址、名字和结构体容器的类型，它就可以返回结构体的起始地址。在宏定义的第一行，声明了一个指向结构体成员变量 ptr 的指针__mptr，并且把 ptr 的地址赋给它。现在 ptr 和__mptr 指向了同一个地址。从技术上讲我们并不需要这一行，但是它可以方便地进行类型检查。第一行保证了特定的结构体（参数 type）包含成员变量 member。第二行代码会用宏 offsetof 计算成员变量相对于结构体起始地址的偏移，然后从结构体的地址减去这个偏移，最后就得到了结构体。
提供的唯一功能。双向链表的实现还提供了如下 API：
list_add
list_add_tail
list_del
list_replace
list_move
list_is_last
list_empty
list_cut_position
list_splice
list_for_each
list_for_each_entry等等很多其它 API。
