Linux 内核里的数据结构——双向链表

简介:

Linux 内核里的数据结构——双向链表

Linux 内核中自己实现了双向链表,可以在 include/linux/list.h 找到定义。我们将会首先从双向链表数据结构开始介绍内核里的数据结构。为什么?因为它在内核里使用的很广泛,你只需要在 free-electrons.com 检索一下就知道了。

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


  
  
  1. struct list_head {
  2. struct list_head *next, *prev;
  3. };

你可能注意到这和你以前见过的双向链表的实现方法是不同的。举个例子来说,在 glib 库里是这样实现的:


  
  
  1. struct GList {
  2. gpointer data;
  3. GList *next;
  4. GList *prev;
  5. };

通常来说一个链表结构会包含一个指向某个项目的指针。但是 Linux 内核中的链表实现并没有这样做。所以问题来了:链表在哪里保存数据呢?。实际上,内核里实现的链表是侵入式链表(Intrusive list)。侵入式链表并不在节点内保存数据-它的节点仅仅包含指向前后节点的指针,以及指向链表节点数据部分的指针——数据就是这样附加在链表上的。这就使得这个数据结构是通用的,使用起来就不需要考虑节点数据的类型了。

比如:


  
  
  1. struct nmi_desc {
  2. spinlock_t lock;
  3. struct list_head head;
  4. };

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


  
  
  1. #define MISC_MAJOR 10

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


  
  
  1. ls -l /dev | grep 10
  2. crw------- 1 root root 10, 235 Mar 21 12:01 autofs
  3. drwxr-xr-x 10 root root 200 Mar 21 12:01 cpu
  4. crw------- 1 root root 10, 62 Mar 21 12:01 cpu_dma_latency
  5. crw------- 1 root root 10, 203 Mar 21 12:01 cuse
  6. drwxr-xr-x 2 root root 100 Mar 21 12:01 dri
  7. crw-rw-rw- 1 root root 10, 229 Mar 21 12:01 fuse
  8. crw------- 1 root root 10, 228 Mar 21 12:01 hpet
  9. crw------- 1 root root 10, 183 Mar 21 12:01 hwrng
  10. crw-rw----+ 1 root kvm 10, 232 Mar 21 12:01 kvm
  11. crw-rw---- 1 root disk 10, 237 Mar 21 12:01 loop-control
  12. crw------- 1 root root 10, 227 Mar 21 12:01 mcelog
  13. crw------- 1 root root 10, 59 Mar 21 12:01 memory_bandwidth
  14. crw------- 1 root root 10, 61 Mar 21 12:01 network_latency
  15. crw------- 1 root root 10, 60 Mar 21 12:01 network_throughput
  16. crw-r----- 1 root kmem 10, 144 Mar 21 12:01 nvram
  17. brw-rw---- 1 root disk 1, 10 Mar 21 12:01 ram10
  18. crw--w---- 1 root tty 4, 10 Mar 21 12:01 tty10
  19. crw-rw---- 1 root dialout 4, 74 Mar 21 12:01 ttyS10
  20. crw------- 1 root root 10, 63 Mar 21 12:01 vga_arbiter
  21. crw------- 1 root root 10, 137 Mar 21 12:01 vhci

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


  
  
  1. struct miscdevice
  2. {
  3. int minor;
  4. const char *name;
  5. const struct file_operations *fops;
  6. struct list_head list;
  7. struct device *parent;
  8. struct device *this_device;
  9. const char *nodename;
  10. mode_t mode;
  11. };

可以看到结构体miscdevice的第四个变量list 是所有注册过的设备的链表。在源代码文件的开始可以看到这个链表的定义:


  
  
  1. static LIST_HEAD(misc_list);

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


  
  
  1. #define LIST_HEAD(name) \
  2. struct list_head name = LIST_HEAD_INIT(name)

然后使用宏 LIST_HEAD_INIT 进行初始化,这会使用变量name 的地址来填充prevnext 结构体的两个变量。


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

现在来看看注册杂项设备的函数misc_register。它在一开始就用函数 INIT_LIST_HEAD 初始化了miscdevice->list


  
  
  1. INIT_LIST_HEAD(&misc->list);

作用和宏LIST_HEAD_INIT一样。


  
  
  1. static inline void INIT_LIST_HEAD(struct list_head *list)
  2. {
  3. list->next = list;
  4. list->prev = list;
  5. }

接下来,在函数device_create 创建了设备后,我们就用下面的语句将设备添加到设备链表:


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

内核文件list.h 提供了向链表添加新项的 API 接口。我们来看看它的实现:


  
  
  1. static inline void list_add(struct list_head *new, struct list_head *head)
  2. {
  3. __list_add(new, head, head->next);
  4. }

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

  • new - 新项。
  • head - 新项将会插在head的后面
  • head->next - 插入前,head 后面的项。

__list_add的实现非常简单:


  
  
  1. static inline void __list_add(struct list_head *new,
  2. struct list_head *prev,
  3. struct list_head *next)
  4. {
  5. next->prev = new;
  6. new->next = next;
  7. new->prev = prev;
  8. prev->next = new;
  9. }

这里,我们在prevnext 之间添加了一个新项。所以我们开始时用宏LIST_HEAD_INIT定义的misc 链表会包含指向miscdevice->list 的向前指针和向后指针。

这儿还有一个问题:如何得到列表的内容呢?这里有一个特殊的宏:


  
  
  1. #define list_entry(ptr, type, member) \
  2. container_of(ptr, type, member)

使用了三个参数:

  • ptr - 指向结构 list_head 的指针;
  • type - 结构体类型;
  • member - 在结构体内类型为list_head 的变量的名字;

比如说:


  
  
  1. const struct miscdevice *p = list_entry(v, struct miscdevice, list)

然后我们就可以使用p->minor 或者 p->name来访问miscdevice。让我们来看看list_entry 的实现:


  
  
  1. #define list_entry(ptr, type, member) \
  2. container_of(ptr, type, member)

如我们所见,它仅仅使用相同的参数调用了宏container_of。初看这个宏挺奇怪的:


  
  
  1. #define container_of(ptr, type, member) ({ \
  2. const typeof( ((type *)0)->member ) *__mptr = (ptr); \
  3. (type *)( (char *)__mptr - offsetof(type,member) );})

首先你可以注意到花括号内包含两个表达式。编译器会执行花括号内的全部语句,然后返回最后的表达式的值。

举个例子来说:


  
  
  1. #include <stdio.h>
  2. int main() {
  3. int i = 0;
  4. printf("i = %d\n", ({++i; ++i;}));
  5. return 0;
  6. }

最终会打印出2

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


  
  
  1. #include <stdio.h>
  2. struct s {
  3. int field1;
  4. char field2;
  5. char field3;
  6. };
  7. int main() {
  8. printf("%p\n", &((struct s*)0)->field3);
  9. return 0;
  10. }

结果显示0x5

下一个宏offsetof会计算从结构体起始地址到某个给定结构字段的偏移。它的实现和上面类似:


  
  
  1. #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不是<linux/list.h>提供的唯一功能。双向链表的实现还提供了如下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中国”,原文发布时间为:2013-04-02.

相关文章
|
11月前
|
存储 算法 Perl
数据结构实验之链表
本实验旨在掌握线性表中元素的前驱、后续概念及链表的建立、插入、删除等算法,并分析时间复杂度,理解链表特点。实验内容包括循环链表应用(约瑟夫回环问题)、删除单链表中重复节点及双向循环链表的设计与实现。通过编程实践,加深对链表数据结构的理解和应用能力。
174 4
|
8月前
|
存储 机器学习/深度学习 算法
C 408—《数据结构》算法题基础篇—链表(下)
408考研——《数据结构》算法题基础篇之链表(下)。
203 30
|
8月前
|
存储 算法 C语言
C 408—《数据结构》算法题基础篇—链表(上)
408考研——《数据结构》算法题基础篇之链表(上)。
318 25
|
9月前
|
机器学习/深度学习 存储 C++
【C++数据结构——线性表】单链表的基本运算(头歌实践教学平台习题)【合集】
本内容介绍了单链表的基本运算任务,涵盖线性表的基本概念、初始化、销毁、判定是否为空表、求长度、输出、求元素值、按元素值查找、插入和删除数据元素等操作。通过C++代码示例详细解释了顺序表和链表的实现方法,并提供了测试说明、通 - **任务描述**:实现单链表的基本运算。 - **相关知识**:包括线性表的概念、初始化、销毁、判断空表、求长度、输出、求元素值、查找、插入和删除等操作。 - **测试说明**:平台会对你编写的代码进行测试,提供测试输入和预期输出。 - **通关代码**:给出了完整的C++代码实现。 - **测试结果**:展示了测试通过后的预期输出结果。 开始你的任务吧,祝你成功!
347 5
|
10月前
|
数据库
数据结构中二叉树,哈希表,顺序表,链表的比较补充
二叉搜索树,哈希表,顺序表,链表的特点的比较
数据结构中二叉树,哈希表,顺序表,链表的比较补充
|
11月前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
289 5
|
11月前
|
存储
系统调用处理程序在内核栈中保存了哪些上下文信息?
【10月更文挑战第29天】系统调用处理程序在内核栈中保存的这些上下文信息对于保证系统调用的正确执行和用户程序的正常恢复至关重要。通过准确地保存和恢复这些信息,操作系统能够实现用户模式和内核模式之间的无缝切换,为用户程序提供稳定、可靠的系统服务。
227 4
|
11月前
|
存储 C语言
【数据结构】手把手教你单链表(c语言)(附源码)
本文介绍了单链表的基本概念、结构定义及其实现方法。单链表是一种内存地址不连续但逻辑顺序连续的数据结构,每个节点包含数据域和指针域。文章详细讲解了单链表的常见操作,如头插、尾插、头删、尾删、查找、指定位置插入和删除等,并提供了完整的C语言代码示例。通过学习单链表,可以更好地理解数据结构的底层逻辑,提高编程能力。
832 4
|
11月前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习之单双链表精题详解(9)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
11月前
|
存储 Web App开发 算法
2024重生之回溯数据结构与算法系列学习之单双链表【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构之单双链表按位、值查找;[前后]插入;删除指定节点;求表长、静态链表等代码及具体思路详解步骤;举例说明、注意点及常见报错问题所对应的解决方法