前言

   在 Linux 内核中使用最多的数据结构就是链表了，其中就包含了许多高级思想。 比如面向对象、类似C++模板的实现、堆和栈的实现。

   嵌入式驱动学习专栏将详细记录博主学习驱动的详细过程，未来预计四个月将高强度更新本专栏，喜欢的可以关注本博主并订阅本专栏，一起讨论一起学习。现在关注就是老粉啦！

1. 链表简介

   链表作为常用的数据结构，是使用指针将一系列数据连成一条链，是一种线性表，通常链表数据结构至少应包括两个域，数据域和指针域。数据域用于存储数据，指针域用于建立与下一个节点的联系。相信其特性也不需要过多介绍了，大部分人应该都知道的，这部分就简单过一遍

1.1 单链表

   单链表，其仅有一个指针域指向后继节点，对单链表只能从头到顺序访问

1.2 双链表

   双链表多了一个指针域，又后继和前驱，既能从头到尾，又能从尾到头访问

1.3 循环链表

   循环链表是在单链表与双链表的基础上，让最后一个节点的指针域指向最开始的节点，双链表的话第一个节点的前驱也要指向最后一个节点。好处是可以从任意一个节点开始访问完全部的节点。

2. 内核链表

   在Linux内核中使用了大量的链表结构来组织数据，包括设备列表以及各种功能模块中的数据组织。这些链表大多采用在include/linux/list.h实现的一个相当精彩的链表数据结构。事实上，内核链表就是采用双循环链表机制，支持FIFO（先进先出）和LIFO（后进先出）操作。

   通过使用循环链表，内核开发者可以在保持代码量最小的情况下实现多种数据结构和算法，提高了内核的性能和可维护性。此外，循环双链表还具有高效地插入和删除节点的优点，在内核开发中很重要，因为内核需要频繁地对数据结构进行修改和操作。

   内核链表有别于传统链表就在节点本身不包含数据域，只包含指针域。故而可以很灵活的拓展数据结构。

2.1 list_head

   这个结构自身意义不大，但是在内核链表中，起着衔接的作用，可以说是内核链表的核心

struct list_head {struct list_head *next, *prev;
};

2.2 链表初始化

   初始化分为宏初始化和借口初始化

   宏初始化主要有LIST_HEAD_HEAD_INIT和LIST_HEAD。

LIST_HEAD_HEAD_INIT 宏，对于任意给定的结构指针，将【前驱】和【后继】指针都指向自己，作为链表头指针
LIST_HEAD 本质就是赋予了 name有list_head属性，是基于LIST_HEAD_HEAD_INIT 宏的视线

#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \struct list_head name = LIST_HEAD_INIT(name)

   接口初始化比较直白，INIT_LIST_HEAD和宏实现意图相同，直接将链表头指针的前驱和后继都指向自己，定义如下：

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

   要使用list_head的话，就需要创建一个宿主结构，让其包含list_head。

typedef struct my_list {int val;struct list_head list;
} My_List;

   然后我们根据这个结构体创建一个节点：

My_List first_node = {.val = 10,.list = LIST_HEAD_INIT(first_node.list);	// 将first_node.list的前驱和后继均指向自己

   即如下所示：

   此处list_node高能的地方又来了，我们知道container_of宏可以根据成员查找到结构体，那么通过结合container_of宏就可以通过list_node成员访问到结构体，然后再根据结构体访问其中的数值。

   container_of文章地址：嵌入式驱动学习第三周——container_of()宏

2.3 增删改查

2.3.1 添加节点

   添加节点使用的是list_add函数，其是头部插入，即总是在链表的头部插入，链表是向左生长的。其底层调用的是__list_add函数。

/* * @description: 添加内核链表节点，头插法* @param-new  : 要添加的新节点* @param-head : 要加入链表的头节点* @return     : 无*/
static inline void list_add(struct list_head *new, struct list_head *head)
{__list_add(new, head, head->next);
}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(listHead);

   然后用2.2中的方法创建第一个节点

struct my_data_list first_data =
{ .val = 1,.list = LIST_HEAD_INIT(first_data.list),
};

   创建完毕后用list_add函数将其加入到头结点中

list_add(&frist_data.list, &listHead);

   然后创建第二个节点并添加进去，注意看第二个节点添加的位置，是在定义的头结点之后，即头部插入

struct my_data_list second_data =
{ .val = 2,/* 也可以调用接口 初始化*/.list = LIST_HEAD_INIT(second_data.list),
};list_add(&second_data.list, &listHead);

   另一种是使用尾插法，即在节点尾部添加节点，函数为list_add_tail函数，其也是调用的__list_add函数，但是调用的时候二三两个参数位置反了一下：

/* * @description: 添加内核链表节点，尾插法* @param-new  : 要添加的新节点* @param-head : 要加入链表的头节点* @return     : 无*/
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{__list_add(new, head->next, head);
}

   前面操作一样，来看插入第二个节点时的操作，注意看第二个节点插入的位置，是在第一个节点之后。

struct my_data_list second_data =
{ .val = 2,/* 也可以调用接口 初始化*/.list = LIST_HEAD_INIT(second_data.list),
};list_add_tail(&second_data.list, &listHead);

2.3.2 删除节点

   删除节点采用list_del函数或list_del_init函数

/* * @description: 删除指定节点，并将节点指向特定位置* @param-entry: 要删除的节点* @return     : 无*/
static inline void list_del(struct list_head *entry)

/* * @description: 删除指定节点，删除后将节点置为空链状态，即前驱和后继均指向自己* @param-entry: 要删除的节点* @return     : 无*/
static inline void list_del_init(struct list_head *entry)

2.3.3 遍历操作

   遍历也是一个相当重要也是相当常用的操作，首先需要介绍一下list_entry宏，list_entry宏本质是container_of宏：

#define list_entry(ptr, type, member) \container_of(ptr, type, member)

   其使用方法和container_of是一致的：

list_entry(&my_list_data.list, typeof(&my_list_data), list)

   既然是双向链表，那肯定就可以正向遍历，也可以反向遍历。

   list_for_each 它实际上是一个for循环，利用传入的pos作为循环变量，从表头head开始，逐项向后（next方向）移动pos，直至又回到head

/* * @description: 正向遍历双向链表* @param-pos  : 一个list_node指针，作为遍历指针* @param-head : 要遍历链表的头结点* @return     : 无*/
#define list_for_each(pos, head) \for (pos = (head)->next; pos != (head); pos = pos->next)

   其使用方法如下：

struct my_data_list* p;
struct list_head *pos; //pos指向每一个大结构体中的小结构体
list_for_each(pos, &(Head->list)) //循环遍历
{//以上循环只提供小结构体指针的遍历，但是遍历找的是大结构体的数据域，根据每个pos得到大结构体地址p = list_entry(pos, Node, list);printk(p->data);  //打印 
}

   list_for_each_entry 是遍历每一个list，然后获取宿主的结构地址：

/* * @description : 正向遍历双向链表并获取宿主的结构地址* @param-pos   : 一个自己定义结构的指针，循环体内可以直接调用自己的成员变量* @param-head  : 要遍历链表的头结点* @param-member: 自己结构体中list_head的名称* @return      : 无*/
#define list_for_each_entry(pos, head, member)    \for (pos = list_entry((head)->next, typeof(*pos), member); \&pos->member != (head);  \pos = list_entry(pos->member.next, typeof(*pos), member))

   使用案例：

struct my_data_list* p;
list_for_each_entry(p, &(Head->list), list) //循环遍历，最后一个参数是list是因为我结构体中list_head成员名字叫list
{printk(pos->val);  //打印
}

   list_for_each_prev是反向遍历，用法同list_for_each

/* * @description: 反向遍历双向链表* @param-pos  : 一个list_node指针，作为遍历指针* @param-head : 要遍历链表的头结点* @return     : 无*/
#define list_for_each_prev(pos, head) \for (pos = (head)->prev; pos != (head); pos = pos->prev)

   list_for_each_entry_reverse是反向遍历，用法同list_for_each_entry

/* * @description : 正向遍历双向链表并获取宿主的结构地址* @param-pos   : 一个自己定义结构的指针，循环体内可以直接调用自己的成员变量* @param-head  : 要遍历链表的头结点* @param-member: 自己结构体中list_head的名称* @return      : 无*/
#define list_for_each_entry_reverse(pos, head, member)   \for (pos = list_entry((head)->prev, typeof(*pos), member); \&pos->member != (head);  \pos = list_entry(pos->member.prev, typeof(*pos), member))

2.4 搬移

   内核提供了将原本属于一个链表的节点移动到另一个链表的操作，并根据插入到新链表的位置分为两类：头部搬移和尾部搬移。搬移的本质就是删除加插入。

/* * @description: 从一个链表删除并添加到另一个链表中，头插法添加* @param-list : 要移动的节点* @param-head : 要添加进的链表的头结点* @return     : 无*/
static inline void list_move(struct list_head *list, struct list_head *head)

/* * @description: 从一个链表删除并添加到另一个链表中，尾插法添加* @param-list : 要移动的节点* @param-head : 要添加进的链表的头结点* @return     : 无*/
static inline void list_move_tail(struct list_head *list, struct list_head *head)

2.5 其他

   还有其他操作比如合并，替换等，详情可见参考资料[1]。

3. 实际案例

3.1 定义自己的结构体

   定义一个工程师类，然后定义一个公司类，把工程师放进去，然后最外层定义一个node，数据域就是公司，指针域就是list_head变量。

// 一个公司类
typedef struct company_Struct {char name[100];int company_val;int employee_count;     // 员工人数
} Company;typedef struct my_node {// 数据域Company company;// 指针域struct list_head list;
}Node, *pNode;

3.2 初始化链表

   之后初始化一个链表，即构建一个头节点。

// 链表初始化，构建一个头节点
pNode List_Init(void) {pNode Head = (pNode)malloc(sizeof(Node));if (Head == NULL) {perror("malloc failed!");return NULL;}INIT_LIST_HEAD(&Head->list);return Head;
}

3.3 增删改查函数定义

   之后写一些增加节点，删除节点，遍历节点的函数。

   增加节点，首先先创建一个节点，然后再添加进去。

// 增加节点函数
int Node_Insert(pNode head, Company elem)
{pNode newNode = (pNode)malloc(sizeof(Node));if (newNode == NULL) {perror("malloc failed!");return -1;}newNode->company = elem;list_add(&(newNode->list), &(head->list));return 0;
}

   删除节点，在调用list_del函数后，要用free释放节点

// 删除节点
void Node_Delete(Company elem) {pNode delNode = list_entry(&elem, Node, company);list_del(&(delNode->list));free(delNode);
}

   遍历函数

// 遍历节点
void List_Traversal(pNode head) {pNode p;struct list_head *pos;list_for_each(pos, &(head->list)) {p = list_entry(pos, Node, list);printk("%s\t%d\t%d\r\n", p->company.name, p->company.company_val, p->company.employee_count);}
}

3.4 调用

Company com1 = {"aaaa", 100, 10};
Company com2 = {"bbbb", 200, 8};
Company com3 = {"cccc", 300, 40};pNode head = List_Init();        // 初始化一个列表
Node_Insert(head, com1);
Node_Insert(head, com2);
Node_Insert(head, com3);printk("+++++++所有的节点+++++++");
List_Traversal(head);Node_Delete(com2);
printk("+++++++删除部分节点+++++++");
List_Traversal(head);

3.5 完整代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/of_device.h>
#include <linux/list.h>
#include <stdlib.h>#define chrdevTest_CNT      1
#define chrdevTest_NAME     "chrdevTest"// 一个公司类
typedef struct company_Struct {char name[100];int company_val;int employee_count;     // 员工人数
} Company;typedef struct my_node {// 数据域Company company;// 指针域struct list_head list;
}Node, *pNode;// 设备结构体
struct chrdevTest_dev {dev_t devid;struct cdev cdev;struct class *class;struct device *device;int major;int minor;struct device_node *nd;
};struct chrdevTest_dev chrdevTest;   // 字符设备// 链表初始化，构建一个头节点
pNode List_Init(void) {pNode Head = (pNode)malloc(sizeof(Node));if (Head == NULL) {printk("malloc failed!");return NULL;}INIT_LIST_HEAD(&Head->list);return Head;
}// 增加节点函数
int Node_Insert(pNode head, Company elem)
{pNode newNode = (pNode)malloc(sizeof(Node));if (newNode == NULL) {printk("malloc failed!");return -1;}newNode->company = elem;list_add(&(newNode->list), &(head->list));return 0;
}// 删除节点
void Node_Delete(Company elem) {pNode delNode = list_entry(&elem, Node, company);list_del(&(delNode->list));free(delNode);
}// 遍历节点
void List_Traversal(pNode head) {pNode p;struct list_head *pos;list_for_each(pos, &(head->list)) {p = list_entry(pos, Node, list);printk("%s\t%d\t%d\r\n", p->company.name, p->company.company_val, p->company.employee_count);}
}static int chrdevTest_open(struct inode *inode, struct file *filp) {filp->private_data = &chrdevTest;return 0;
}static ssize_t chrdevTest_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {return 0;
}static ssize_t chrdevTest_write(struct file *filp, const char __user* buf, size_t cnt, loff_t* offt) {return 0;
}static ssize_t chrdevTest_release(struct inode* inode, struct file* filp) {return 0;
}static struct file_operations chrdevTest_fops = {.owner = THIS_MODULE,.open = chrdevTest_open,.read = chrdevTest_read,.write = chrdevTest_write,.release = chrdevTest_release,
};// 入口函数
static int __init containerTest_init(void)
{Company com1 = {"aaaa", 100, 10};Company com2 = {"bbbb", 200, 8};Company com3 = {"cccc", 300, 40};pNode head = List_Init();        // 初始化一个列表Node_Insert(head, com1);Node_Insert(head, com2);Node_Insert(head, com3);printk("+++++++所有的节点+++++++");List_Traversal(head);Node_Delete(com2);printk("+++++++删除部分节点+++++++");List_Traversal(head);if (chrdevTest.major) {chrdevTest.devid = MKDEV(chrdevTest.major, 0);register_chrdev_region(chrdevTest.devid, chrdevTest_CNT, chrdevTest_NAME);} else {alloc_chrdev_region(&chrdevTest.devid, 0, chrdevTest_CNT, chrdevTest_NAME);     // 申请设备号chrdevTest.major = MAJOR(chrdevTest.devid);     // 获取主设备号chrdevTest.minor = MINOR(chrdevTest.devid);     // 获取次设备号}printk("chrdevTest major=%d, minor=%d\r\n", chrdevTest.major, chrdevTest.minor);// cdevchrdevTest.cdev.owner = THIS_MODULE;cdev_init(&chrdevTest.cdev, &chrdevTest_fops);// 添加cdevcdev_add(&chrdevTest.cdev, chrdevTest.devid, chrdevTest_CNT);// 创建类chrdevTest.class = class_create(THIS_MODULE, chrdevTest_NAME);if (IS_ERR(chrdevTest.class)) {return PTR_ERR(chrdevTest.class);}// 创建设备chrdevTest.device = device_create(chrdevTest.class, NULL, chrdevTest.devid, NULL, chrdevTest_NAME);if (IS_ERR(chrdevTest.device)) {return PTR_ERR(chrdevTest.device);}return 0;
}// 出口函数
static void __exit containerTest_exit(void)
{printk("this is exit function\r\n");cdev_del(&chrdevTest.cdev);unregister_chrdev_region(chrdevTest.devid, chrdevTest_CNT);device_destroy(chrdevTest.class, chrdevTest.devid);class_destroy(chrdevTest.class);
}module_init(containerTest_init);
module_exit(containerTest_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wp");

参考资料

[1] 一文搞懂 Linux 内核链表（深度分析）
[2] 【内核链表】数据结构——深入理解内核链表的概念和操作&笔记