Linux内核双向链表详解

Linux中双向链表是指将双向链表节点嵌套在其它的结构体中；在遍历链表的时候，根据双链表节点的指针获取”它所在结构体的指针”，从而再获取数据。下面为大家详细讲解一下Linux内核数据双链表的相关知识。

 

首先让我们看一下在 include/linux/types.h 里的主结构体：

 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;
 };

让我们看几个例子来理解一下在内核里是如何使用 list_head 的。

如上所述，在内核里有很多很多不同的地方都用到了链表。我们来看一个在杂项字符驱动里面的使用的例子。在 drivers/char/misc.c 的杂项字符驱动 API 被用来编写处理小型硬件或虚拟设备的小驱动。这些驱动共享相同的主设备号：

 #define MISC_MAJOR 10

但是都有各自不同的次设备号。

比如：

 ls -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 vhci

现在让我们看看它是如何使用链表的。首先看一下结构体 miscdevice：

 struct 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;
 };

可以看到结构体miscdevice的第四个变量list 是所有注册过的设备的链表。

在源代码文件的开始可以看到这个链表的定义：

 static LIST_HEAD(misc_list);

它实际上是对用list_head 类型定义的变量的扩展。

 #define LIST_HEAD(name) \
 struct list_head name = LIST_HEAD_INIT(name)

然后使用宏 LIST_HEAD_INIT 进行初始化，

这会使用变量name 的地址来填充prev和next 结构体的两个变量。

 #define LIST_HEAD_INIT(name) { &(name), &(name) }

现在来看看注册杂项设备的函数misc_register。

它在一开始就用函数 INIT_LIST_HEAD 初始化了miscdevice->list。

 INIT_LIST_HEAD(&misc->list);

作用和宏LIST_HEAD_INIT一样。

 static inline void INIT_LIST_HEAD(struct list_head *list)
 {
 list->next = list;
 list->prev = list;
 }

接下来，在函数device_create 创建了设备后，

我们就用下面的语句将设备添加到设备链表：

 list_add(&misc->list, &misc_list);

内核文件list.h 提供了向链表添加新项的 API 接口。

我们来看看它的实现：

 static inline void list_add(struct list_head *new, struct list_head *head)
 {
 __list_add(new, head, head->next);
 }

实际上就是使用3个指定的参数来调用了内部函数__list_add：  

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;
 }

这里，我们在prev和next 之间添加了一个新项。

所以我们开始时用宏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 
 int main() {
 int i = 0;
 printf("i = %d\n", ({++i; ++i;}));
 return 0;
 }

最终会打印出2。

下一点就是typeof,它也很简单。

就如你从名字所理解的，它仅仅返回了给定变量的类型。当我第一次看到宏container_of的实现时，让我觉得最奇怪的就是表达式((type *)0)中的0。实际上这个指针巧妙的计算了从结构体特定变量的偏移，这里的0刚好就是位宽里的零偏移。

比如：

 #include 
 struct s {
 int field1;
 char field2;
 char field3;
 };
 int main() {
 printf("%p\n", &((struct s*)0)->field3);
 return 0;
 }

结果显示0x5。

下一个宏offsetof会计算从结构体起始地址到某个给定结构字段的偏移。

它的实现和上面类似： #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) 现在我们来总结一下宏container_of。只需给定结构体中list_head类型 字段的地址、名字和结构体容器的类型，它就可以返回结构体的起始地址。在宏定义的第一行，声明了一个指向结构体成员变量ptr的指针mptr，并且把ptr 的地址赋给它。现在ptr 和mptr 指向了同一个地址。从技术上讲我们并不需要这一行，但是它可以方便地进行类型检查。第一行保证了特定的结构体（参数type）包含成员变量member。第二行代码会用宏offsetof计算成员变量相对于结构体起始地址的偏移，然后从结构体的地址减去这个偏移，最后就得到了结构体。

当然了list_add 和 list_entry不是

提供的唯一功能。双向链表的实现还提供了如下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。

以上就是良许教程网为各位朋友分享的Linux系统相关内容。想要了解更多Linux相关知识记得关注公众号“良许Linux”，或扫描下方二维码进行关注，更多干货等着你！