linux kernel 中双向链表详解(一)

已于 2022-04-01 22:53:31 修改
阅读量2.9k 收藏 14
点赞数 1
分类专栏： linuxKernelBase 文章标签： linux c语言 数据结构
于 2022-03-23 23:28:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014787262/article/details/123699525
版权

1.概览

  list_head 在kernel代码中非常的常见，其本身则是一个双向链表，在使用时只需要将其嵌入到任意结构体中，就可以实现栈/队列的数据结构。并且删除，添加的操作时间复杂度都是O(1)。

2.list_head之栈实现

 前面提到过，嵌入list_head可以实现的栈(stack)数据结构。下面的代码实现很简单，其功能则是在驱动的初始化函数中将数据入栈并显示当前栈信息，在驱动的卸载函数中出栈数据并释放内存。随意定义个苹果数据结构，并将head_list嵌入其中，定义如下

struct apple {
	struct list_head list;
	int id;
};

  id则是唯一的，代表一个苹果的编号。

2.1 初始化链表头–LIST_HEAD

  为了让队列显的有序，我们单独定义一个head_list作为链表头。
  kernel 中代码如下

static LIST_HEAD(apple_top);

  使用kernel的帮助宏申明一个名为 apple_top 的 list_head，添加static修饰为了限制其作用域为本文件内。对于 LIST_HEAD 的实现如下

//file:kernel/include/linux/list.h
#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
	struct list_head name = LIST_HEAD_INIT(name)
        || 展开如下
        \/
struct list_head name = { &name/* next */, &name /* prev */}

  从上可知，使用LIST_HEAD申明的head_list为指向自己的空链表，示意图如下
在这里插入图片描述

2.2 入栈–list_add

 栈的主要特性就是先入后出，使用list_add添加的项则是符合这种特性的，下面是其实现

//file:kernel/include/linux/list.h
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;
	WRITE_ONCE(prev->next, new);
}

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

  list_add的实现依赖于__list_add，而对于__list_add的功能描述在kernel中如下

Insert a new entry between two known consecutive entries.

  从实现和内核描述可知，__list_add的功能就是将 new 项添加到项preve和next之间，结合list_add的代码可知其含义为将new添加到 head和head->next之间，图示如下
在这里插入图片描述

  使用list_add添加两项项后的示例图则如下
在这里插入图片描述

  使用list_add添加多项后的示例图则如下
在这里插入图片描述

2.3 出栈

  出栈的功能则分为两个部分，其一是定位栈顶此处使用list_first_entry，其二是删除栈顶项此处使用list_del。

2.3.1 栈的遍历–list_first_entry
//file:kernel/include/linux/list.h
#define list_first_entry(ptr, type, member) \
	list_entry((ptr)->next, type, member)
        container_of(ptr, type, member)

  ptr:
    则是链表头的指针，此处对应 &apple_top
  type:
    则是链表中具体项所对应的结构体，此处对应 struct apple
  member:
    则是head_list内嵌于具体项的名字，此处对应由struct apple可知为list
  实现上也比较简单，最终使用container_of来返回链表头的next项的。
  下面是list_first_entry的使用示例，用于返回栈顶项指针

struct apple *it = list_first_entry(&apple_top, struct apple, list);
2.3.1 删除一项–list_del

  list_del实现也非常简单，就是去头去尾，接头尾的操作。下面给出简单的调用流程

//file:kernel/include/linux/list.h
list_del(struct list_head *entry)
	__list_del_entry(entry);
        __list_del(entry->prev, entry->next)
            next->prev = prev;
            WRITE_ONCE(prev->next, next);
	entry->next = LIST_POISON1;
	entry->prev = LIST_POISON2;

  配合上面提到的list_first_entry，也就实现了出栈的功能，代码如下

struct apple *it = list_first_entry(&apple_top, struct apple, list);
list_del(&it->list);

2.4 代码实现

2.4.1 基本代码实现

struct apple {
	struct list_head list;
	int id;
};
static LIST_HEAD(apple_top);
static int __init list_test_drv_init()
{
	struct apple *tmp_apple = NULL;
	int count = 0;

	for( count = 0 ; count < APPLE_STACK_MAX; ++count) {

		tmp_apple = kzalloc(sizeof(struct apple), GFP_KERNEL);
		if(tmp_apple != NULL) {
			tmp_apple->id = count;
			list_add(&tmp_apple->list, &apple_top);
			LIST_TEST_INFO("push:apple->id:%d", tmp_apple->id);
			tmp_apple = NULL;
		}
	}
	return 0;
}

static void __exit list_test_drv_exit()
{
	struct apple *it = NULL;

	while(!list_empty(&apple_top)) {
		it = list_first_entry(&apple_top, struct apple, list);
		if(it == NULL){
			LIST_TEST_INFO("it is NULL");
			continue;
		}
		LIST_TEST_INFO("pop:apple->id:%d", it->id);
		list_del(&it->list);
		kzfree(it);
		it = NULL;
	}
}
module_init(list_test_drv_init);
module_exit(list_test_drv_exit);

  代码实现基本逻辑，在模块加载的时候会申请APPLE_STACK_MAX个apple，并压入栈中。
在模块推出后，则循环出栈直到队列为空。

2.4.1 完整源码

https://gitee.com/solo-king/linux-kernel-base-usage/blob/master/flagstaff/listStackTest.c

2.5 执行结果

2.5.1 入栈信息

board:/ # insmod /data/listStackTest.ko
[20749.835310] listTest:list_test_drv_init,54:push:apple->id:1
[20749.835317] listTest:list_test_drv_init,54:push:apple->id:2
[20749.835324] listTest:list_test_drv_init,54:push:apple->id:3
[20749.835331] listTest:list_test_drv_init,54:push:apple->id:4
[20749.835337] listTest:list_test_drv_init,54:push:apple->id:5
[20749.835344] listTest:list_test_drv_init,54:push:apple->id:6
[20749.835351] listTest:list_test_drv_init,54:push:apple->id:7
[20749.835357] listTest:list_test_drv_init,54:push:apple->id:8
[20749.835367] listTest:list_test_drv_init,54:push:apple->id:9

  从log能看出，栈顶的apple id为9，栈低为0。

2.5.1 出栈信息

board:/ # rmmod listStackTest
[20773.041927] listTest:list_test_drv_exit,73:pop:apple->id:9
[20773.041957] listTest:list_test_drv_exit,73:pop:apple->id:8
[20773.041966] listTest:list_test_drv_exit,73:pop:apple->id:7
[20773.041978] listTest:list_test_drv_exit,73:pop:apple->id:6
[20773.041986] listTest:list_test_drv_exit,73:pop:apple->id:5
[20773.041994] listTest:list_test_drv_exit,73:pop:apple->id:4
[20773.042003] listTest:list_test_drv_exit,73:pop:apple->id:3
[20773.042012] listTest:list_test_drv_exit,73:pop:apple->id:2
[20773.042022] listTest:list_test_drv_exit,73:pop:apple->id:1
[20773.042030] listTest:list_test_drv_exit,73:pop:apple->id:0

  从log也是能看出，是符合栈数据结构的特性–先入后出的。

3.list_head之队列实现

  队列的实现和栈的实现，在list_head双向链表实现中唯一的不同就是入列使用 list_add_tail，压栈使用 list_add 仅此而已。那么只要分析下 list_add_tail和 list_add实现的不同点即可，下面是对应代码

//file:kernel/include/linux/list.h
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
	__list_add(new, head->prev, head);
}

  可见，list_add_tail则是将new放置在链表头的前一个项和链表头之间，和list_add的实现正好相反。

3.1 入列第一项

  下图是入列了第一个项目后链表的示意图
在这里插入图片描述

3.2 入列第二项

  下图是入列了第二个项目后链表的示意图
在这里插入图片描述

3.3 入列多项

  下图是入列了多项目后链表的示意图
在这里插入图片描述

  所以配合上 list_first_entry接口，每次返回的都是head_list.next项目，所以其访问序列和队列的特性是符合的，即先进先出。

3.4 执行结果

3.4.1 入列信息
board:/ # insmod  /data/listQueueTest.ko
[29592.571532] listTest:list_test_drv_init,39:enqueue:apple->id:0
[29592.571539] listTest:list_test_drv_init,39:enqueue:apple->id:1
[29592.571543] listTest:list_test_drv_init,39:enqueue:apple->id:2
[29592.571549] listTest:list_test_drv_init,39:enqueue:apple->id:3
[29592.571555] listTest:list_test_drv_init,39:enqueue:apple->id:4
[29592.571560] listTest:list_test_drv_init,39:enqueue:apple->id:5
[29592.571564] listTest:list_test_drv_init,39:enqueue:apple->id:6
[29592.571570] listTest:list_test_drv_init,39:enqueue:apple->id:7
[29592.571575] listTest:list_test_drv_init,39:enqueue:apple->id:8
[29592.571579] listTest:list_test_drv_init,39:enqueue:apple->id:9
3.4.2 出列信息
board:/ # rmmod listQueueTest
[29598.406872] listTest:list_test_drv_exit,56:dequeue:apple->id:0
[29598.406898] listTest:list_test_drv_exit,56:dequeue:apple->id:1
[29598.406907] listTest:list_test_drv_exit,56:dequeue:apple->id:2
[29598.406915] listTest:list_test_drv_exit,56:dequeue:apple->id:3
[29598.406925] listTest:list_test_drv_exit,56:dequeue:apple->id:4
[29598.406934] listTest:list_test_drv_exit,56:dequeue:apple->id:5
[29598.406943] listTest:list_test_drv_exit,56:dequeue:apple->id:6
[29598.406952] listTest:list_test_drv_exit,56:dequeue:apple->id:7
[29598.406959] listTest:list_test_drv_exit,56:dequeue:apple->id:8
[29598.406967] listTest:list_test_drv_exit,56:dequeue:apple->id:9

3.5 完整源码

https://gitee.com/solo-king/linux-kernel-base-usage/blob/master/flagstaff/listQueueTest.c
flagstaffChen
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux内核中的链表
weixin_30763397的博客
06-03 317
1.内核中的链表 linux内核链表与众不同，他不是把将数据结构塞入链表，而是将链表节点塞入数据，在2.1内核中引入了官方链表，从此内核中所有的链表使用都采用此链表，千万不要在重复造车轮子了！链表实现定义在<linux/list.h>,使用内核链表时，包含此文件。 1.1.传统的双向链表和内核中的双向链表的区别 有个单独的头结点(head) 每个节点(node)除了包含必要的数据之外...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
linux内核数据结构之链表
weixin_33832340的博客
12-15 141
1、前言 　　 最近写代码需用到链表结构，正好公共库有关于链表的。第一眼看时，觉得有点新鲜，和我之前见到的链表结构不一样，只有前驱和后继指针，而没有数据域。后来看代码注释发现该代码来自linux内核，在linux源代码下include/Lish.h下。这个链表具备通用性，使用非常方便。只需要在结构定义一个链表结构就可以使用。 2、链表介绍 　　链表是非常基本的数据结构，根据链个数分为单链表、...
C-数据结构-双向链表（linux内核 ）
aqiangdeba的博客
05-24 666
的作用是定义并初始化一个链表头节点head，表示一个空的双向链表。这个链表头节点的prev和next指针都指向自身。通过这种方式，可以方便地使用头节点来管理和操作双向链表中的所有节点。
linux 双向链表详解
酷小川的博客
12-20 1863
一、LIST_HEAD 创建一个链表头header。 1.LIST_HEAD(header)； 创建一个实际节点，将其加在header后面。 2.list_add(&first_node.list, &header); 再创建一个节点，将其加在header后面。 3.list_add(&second_node.list, &header); 参考：https://blog.csdn.net/wanshilun/article/details/79747710 ..
linux 内核链表详解
kakaka666的博客
11-13 613
linux 内核链表详解
linux内核链表,内核链表详解，内核链表封装
qq_45698138的博客
05-18 1064
常规链表的缺陷 ​ 传统的双向循环链表概念简单，操作方便，但存在有致命的缺陷，用一句话来概括就是： 每一条链表都是特殊的，不具有通用性。换句话说，对于每一种不同的数据，所构建出来的 传统链表都是跟这些数据相关的，所有的链表操作函数也都是数据相关的，换一种数据节点， 则所有的操作函数都需要一一重写编写，这种缺陷对于一个具有成千上万种数据节点的工程 来说是灾难性的，是不可接受的 Linux内核链表的原理 （1）把传统链表中的“链”抽象出来，使之成为一条只包含前后指针的纯粹的双循环链表，这样的链表由于不含
linux进程单循环链表,详解Linux内核之双向循环链表
weixin_39722196的博客
05-02 188
【摘要】本文详解了内核中面向对象的list结构的原理，以及如何以list为内嵌对象来构造自己的链表结构，如何从内嵌list对象获得自定义的对象指针；探讨了各种宏或者函数的详细使用方法及怎样以通用list结构来操作自定义对象。【关键字】双向循环链表，list，list_entry，typeof，containerof，list_for_each, list_for_each_entry1、双循环链表...
Linux内核中的list_head双向链表详解
jinking01的专栏
10-09 1864
做内核驱动开发经常会使用linux内核最经典的双向链表 list_head， 以及它的拓展接口(或者宏定义)： list_add , list_add_tail, list_del , list_entry ,list_for_each , list_for_each_entry ...... 每次看到这些接口，感觉都很像，今天专门研究了一下内核，对它们做一些总结，希望为后续开发提供方便。 首先找到list_head 结构体定义，kernel/inclue...
linux内核链表最细讲解
yzw_yy的博客
04-12 1092
由于知道了大小结构体之间的偏移量我们又将小结构体转变成（char*）类型使其一个字节一个字节移动故（char*）_mptr-（（size_t）&（（TYPE*）0）->MEMBER）是将我们小结构体的地址减去其偏移量得到大结构体变量的首地址，（type*）（char*）_mptr-（（size_t）&（（TYPE*）0）->MEMBER）之后在将其强转为大结构体指针类型。同理我们第一步将list节点截切出来，即用删除操作令其掉出链表，之后我们将list节点插在head的前面完成了对list节点的移动。
linux进程单循环链表,【数据结构】详解Linux内核之双向循环链表
weixin_36372579的博客
05-02 167
【摘要】: 本文详解了内核中面向对象的list结构的原理，以及如何以list为内嵌对象来构造自己的链表结构，如何从内嵌list对象获得自定义的对象指针；探讨了各种宏或者函数的详细使用方法及怎样以通用list结构来操作自定义对象。【关键字】:双向循环链表，list，list_entry，typeof，containerof，list_for_each,list_for_each_entry1、双循环...
Java中双向链表详解及实例
08-30
在Java编程中，双向链表（Double-Linked List）是一种数据结构，它允许在列表中的任何位置进行插入和删除操作，因为每个节点不仅包含数据，还包含指向前后节点的引用。这种特性使得双向链表在某些场景下比单链表更...
Linux中的内核链表实例详解
09-15
在Linux系统中，内核链表是一种非常重要的数据结构，广泛应用于各种内核级的数据管理。内核链表设计为高效、灵活，并且适合在内存管理、任务调度等场景下使用。下面我们将深入探讨内核链表的初始化、插入、删除、...
C语言之双向链表详解及实例代码
12-31
所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 2，例子要求： 完成双向链表的插入、删除以及查找，将学生管理系统使用的数组，以双向链表的方式...
Linux手动编译方式安装httpd及配置系统服务（含不同安装方式简介）
shyuu的博客
08-04 843
Linux手动编译方式安装httpd及配置系统服务。包括几种软件安装方式的优缺点。手动编译安装方式相较其他方式有灵活性高、版本控制自由、依赖管理可控的优点等。
Linux下部署python记录
最新发布
龙井茶的Sky
08-06 783
在本地实现了一个python写的webapi，现在要部署到一个外网服务器测试，奈何服务器资源不是我的，而且配置很低。之前我是搞过直接Linux下docker部署python，但是服务器配置很低可能没法搞docker，只能直接在Linux服务器部署python。不过实际上，Linux直接部署、Linux下docker部署，差别不大的。最终，我还是采用了直接运行代码的方式。使用打包部署的方式一直没成功，主要问题在于，同一个服务器，直接运行代码没问题，但是打包部署运行，就提示缺包或找不到包的情况。
Linux地址空间详解
m0_74830524的博客
08-02 866
本篇通过对物理内存和页表详细的讲解，对 Linux 系统下的地址空间做了深度的剖析。
CanFestival在Linux下的使用
爱就是是恒久忍耐的专栏
08-02 782
Linux下使用CanFestival
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值