list_head用法(一)

最新推荐文章于 2024-08-18 17:39:39 发布
最新推荐文章于 2024-08-18 17:39:39 发布
阅读量1.2k 收藏 3
点赞数 3
分类专栏： linux驱动学习




最近在准备“进攻”linux驱动的 学习，在内核代码里存在着大量的链表，其中list_head用法经常在Linux的kernel里使用。经过网上各位前人的学习笔记，转载一篇记录一下知识点
(1)list.h文件在include/linux/list.h

#ifndef _LIST_H
#define _LIST_H

#define _INLINE_ static inline

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

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

#define LIST_HEAD(name) \ //定义并初始化头结点head
    struct list_head name = LIST_HEAD_INIT(name)

#define INIT_LIST_HEAD(ptr) do {\             //初始化头结点ptr,因此需要首先定义ptr
    (ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

_INLINE_ void __list_add(struct list_head *add,
        struct list_head *prev,
        struct list_head *next)
{
    next->prev = add;
    add->next = next;
    add->prev = prev;
    prev->next = add;
}

_INLINE_ void list_add(struct list_head *add, struct list_head *head)//每次添加节点到head之后，始终都是添加到头结点之后
{
    __list_add(add, head, head->next);
}

_INLINE_ void list_add_tail(struct list_head *add, struct list_head *head)//每次添加节点都是头结点之前，由于是循环链表，就是说添加到链表尾部
{
    __list_add(add, head->prev, head);
}

_INLINE_ void __list_del(struct list_head *prev, struct list_head *next)
{
    next->prev = prev;
    prev->next = next;
}

_INLINE_ void list_del(struct list_head *entry)//删除节点
{
    __list_del(entry->prev, entry->next);
}

_INLINE_ void list_del_init(struct list_head *entry)
//删除节点，并初始化被删除的结点（也就是使被删除的结点的prev和next都指向自己）
{
    __list_del(entry->prev, entry->next);
    INIT_LIST_HEAD(entry);
}

_INLINE_ int list_empty(struct list_head *head)//判断链表是否为空
{
    return head->next == head;
}

_INLINE_ void list_splice(struct list_head *list, struct list_head *head)
//通过两个链表的head，进行连接
{
    struct list_head *first = list->next;

    if (first != list) {
        struct list_head *last = list->prev;
        struct list_head *at = head->next;

        first->prev = head;
        head->next = first;

        last->next = at;
        at->prev = last;
    }
}

#define list_entry(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))

#define list_for_each(pos, head) \                                        
//遍历链表，此时删除节点的操作可能会出错
    for (pos = (head)->next; pos != (head); pos = pos->next) //新代码中出现prefetch() 可以不考虑，用于预取以提高遍历速度

#define list_for_each_safe(pos, pnext, head) \      //遍历链表，可以同时有删除节点的操作
    for (pos = (head)->next, pnext = pos->next; pos != (head); \
            pos = pnext, pnext = pos->next)

#undef _INLINE_
#endif
(2)写一个测试程序,利用各个函数实现功能

点击(此处)折叠或打开
#include<stdio.h>
#include<stdlib.h>
#include "list.h"

struct int_node
{
    int val;
    struct list_head list;
};

int main()
{
    struct list_head head,*plist;
    struct int_node a,b,c;

    a.val = 1;
    b.val = 2;
    c.val = 3;

    INIT_LIST_HEAD(&head);            //初始化链表头
    list_add_tail(&a.list,&head);     //添加节点
    list_add_tail(&b.list,&head);
    list_add_tail(&c.list,&head);

    list_for_each(plist,&head)//遍历链表，打印结果
    {
        struct int_node *node = list_entry(plist,struct int_node,list);//然后取得数据项，因此一般来说和list_for_each配合使用
        printf("val = %d\n",node->val);
    }//print 1 2 3 

    printf("*******************************************\n");
    list_del_init(&b.list);            //删除节点b
    list_for_each(plist,&head)         //重新遍历链表，打印结果
    {
        struct int_node *node = list_entry(plist,struct int_node,list);
        printf("val = %d\n",node->val);
    }//print 1 3 

    printf("*******************************************\n");
    struct int_node d,e;
    struct list_head head1;
    d.val = 4;
    e.val = 5;
    INIT_LIST_HEAD(&head1);            //重新建立链表，表头为head1
    list_add_tail(&d.list,&head1);
    list_add_tail(&e.list,&head1);

    list_splice(&head1,&head);        //把两个链表进行连接
    list_for_each(plist,&head)
    {
        struct int_node *node = list_entry(plist,struct int_node,list);
        printf("val = %d\n",node->val);
    }//print 4 5 1 3

    printf("*******************************************\n");
    if(!list_empty(&head))          //判断链表是否为空
    {
        printf("the list is not empty!\n");

    }

    return 0;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157

(2)写一个测试程序,利用各个函数实现功能

#include<stdio.h>
#include<stdlib.h>
#include "list.h"

struct int_node
{
    int val;
    struct list_head list;
};

int main()
{
    struct list_head head,*plist;
    struct int_node a,b,c;

    a.val = 1;
    b.val = 2;
    c.val = 3;

    INIT_LIST_HEAD(&head);            //初始化链表头
    list_add_tail(&a.list,&head);     //添加节点
    list_add_tail(&b.list,&head);
    list_add_tail(&c.list,&head);

    list_for_each(plist,&head)//遍历链表，打印结果
    {
        struct int_node *node = list_entry(plist,struct int_node,list);//然后取得数据项，因此一般来说和list_for_each配合使用
        printf("val = %d\n",node->val);
    }//print 1 2 3 

    printf("*******************************************\n");
    list_del_init(&b.list);            //删除节点b
    list_for_each(plist,&head)         //重新遍历链表，打印结果
    {
        struct int_node *node = list_entry(plist,struct int_node,list);
        printf("val = %d\n",node->val);
    }//print 1 3 

    printf("*******************************************\n");
    struct int_node d,e;
    struct list_head head1;
    d.val = 4;
    e.val = 5;
    INIT_LIST_HEAD(&head1);            //重新建立链表，表头为head1
    list_add_tail(&d.list,&head1);
    list_add_tail(&e.list,&head1);

    list_splice(&head1,&head);        //把两个链表进行连接
    list_for_each(plist,&head)
    {
        struct int_node *node = list_entry(plist,struct int_node,list);
        printf("val = %d\n",node->val);
    }//print 4 5 1 3

    printf("*******************************************\n");
    if(!list_empty(&head))          //判断链表是否为空
    {
        printf("the list is not empty!\n");

    }

    return 0;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

输出结果如下：
val = 1
val = 2
val = 3

val = 1
val = 3

val = 4
val = 5
val = 1
val = 3

the list is not empty!

(3)list_for_each()与list_for_each_safe()

#define list_for_each(pos, head) \
for (pos = (head)->next; prefetch(pos->next), pos != (head); \
pos = pos->next)
 
 
  • 1
  • 2
  • 3

由定义可知，list_del(pos)(将pos的前后指针指向undefined state)panic，list_del_init(pos)(将pos前后指针指向自身)导致死循环。

#define list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
 
 
  • 1
  • 2
  • 3

由定义可知，safe函数首先将pos的后指针缓存到n，处理一个流程后再赋回pos，避免了这种情况的发生。
因此只遍历链表不删除节点时可以使用前者，若有删除节点的操作，则要使用后者。

由safe的说明可知，是专门为删除节点时准备的：iterate over a list safe against removal of list entry。其他带safe的处理也基本源于这个原因




ShenZC8
关注
专栏目录
list_head的使用方法
a3121772305的博客
02-28 174
定义一个list_head类型的head将我们自定义的结构体里面的所有的list_head串起来。后面我们需要的时候，就遍历head变量的所有list_head节点，找到的每一个节点，都使用container_of来找到该节点结构体的首地址，来判断是不是我们找寻的目标。最近用到了list_head，在这里记录一下。如果要搞清楚list_head的使用方法，需要了解container_of的原理。上面代码实现了list_head的增删改查的操作。里面有个我自己定义的删除函数，请忽略。
linux kernel --- struct list_head 结构
栀子花蛋糕的博客
07-18 290
内核中采用链表来管理对象，内核中对链表的定义如下
Linux内核中经典链表 list_head 常见使用方法解析
热门推荐
wanshilun的博客
07-03 4万+
      做内核驱动开发经常会使用linux内核最经典的双向链表 list_head， 以及它的拓展接口(或者宏定义)： list_add , list_add_tail, list_del , list_entry ,list_for_each , list_for_each_entry ......       每次看到这些接口，感觉都很像，并且陈老师的那本书《深入理解linux内核》（UL...
【Linux】详细解析Linux内核链表
最新发布
W__winter的博客
08-18 1158
LIST_POISON1 和 LIST_POISON2 是 Linux 内核用来标记已删除链表节点的特殊值。这是内核开发者采用的一种巧妙的防御性编程技术，有助于编写更安全、更健壮的内核代码。list_entry 利用了 C 语言的一个特性：结构体成员的偏移量是固定的。它计算出 struct list_head 成员在整个结构体中的偏移，然后从这个 list_head 指针反推出整个结构体的起始地址。在上面的函数原型中，有这两行代码，他们的含义是什么呢。
list_head结构的使用
junllee的专栏
12-12 7616
在Linux内核中，提供了一个用来创建双向循环链表的结构list_head。使用list_head提供的相应接口，链表操作将变得相当简单。 下面就是kernel中的list_head结构定义： struct list_head {         struct list_head *next, *prev; }; #define LIST_HEAD_INIT(name) { &(n
Linux利用list_head结构实现双向链表
weixin_34354173的博客
10-19 139
通常实现双向链表的数据结构： struct list_node1{ struct list_node1 *next,*prev; type1 m1; type2 m2; }; struct list_node2{ struct list_node2 *next,*prev; type1 m1; type2 m2; }; ……...
list_head使用
奋斗的伙计
11-19 490
list_head在内核中的实现： list.h文件源码 #ifndef _LIST_H #define _LIST_H #define _INLINE_ static inline struct list_head { struct list_head *next, *prev; }; #define LIST_HEAD_INIT(name) {&(name), &(name)
Linux内核中的链表——struct list_head
zsffzb的博客
06-12 1800
Linux内核中链表介绍_晴天_QQ的博客-CSDN博客_linux 链表链表是Linux内核中最简单、最普通的数据结构。链表是一种存放和操作可变数量元素(常称为节点)的数据结构。链表和静态数组的不同之处在于，它所包含的元素都是动态创建并插入链表的，在编译时不必知道具体需要创建多少个元素。另外也因为链表中每个元素的创建时间各不相同，所以它们在内存中无须占用连续内存区。正是因为元素不连续地存放，所以各元素需要通过某种方式被连接在一起。于是每个元素都包含一个指向下一个元素的...https://blog.csd
深入浅出linux内核源代码之双向链表list_head pdf codes
04-07
通过学习这份PDF文档和代码，读者将能够深入理解Linux内核中`list_head`双向链表的实现原理和使用方法，这对于理解和定制Linux内核，或者在用户空间开发需要高效链表操作的应用程序都是非常有价值的。
深入浅出linux内核源代码之双向链表list_head.pdf
09-10
### 深入浅出 Linux 内核源代码之双向...掌握 `list_head` 的使用方法对于理解 Linux 内核中的许多高级功能至关重要。此外，通过对 `list_head` 的理解和运用，也可以帮助开发者更好地理解和设计复杂的 C 语言程序。
list_head结构的实现和使用
余璜的技术博客
01-01 1637
        struct list_head {                struct list_head *next, *prev;        };       #define list_entry(ptr, type, member) /                ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->
list_head的用法总结
shexujia的专栏
03-02 1万+
前言：写贪吃蛇C语音代码，大多用到双向链表做蛇的数据结构体。如下： 点击(此处)折叠或打开 typedef struct node /* Snake_node structure */ { int x_pos; int y_pos; struct node *prev; struct node *next; } Snake_Node;
list_head使用介绍
kasalyn的专栏
08-11 937
list_head结构的介绍 http://blog.csdn.net/billpig/article/details/5880895 list_head结构定义在 里，它是一个double linked list的结构。 底下是它的结构宣告: struct list_head { struct list_head *next, *prev; }; 有的人可能看到这样的结构会觉得很
【C++ 库】list_head 的使用
Lionel的专栏
01-09 288
list_head使用
LIST_HEAD 的用法
07-23 482
首先来点声明： [cpp] view plaincopy struct list_head {      struct list_head *next, *prev;  };    #define LIST_HEAD_INIT(name) { &(name), &(name) }    #define LIST_HEAD(name) \      struct l
Linux list_head使用
Eric
05-07 516
Linux list.h 中list_head 是kernel中经常用到的，非常经典的动态数据处理方法 当然也可以用在自己的应用程序中 常用函数： INIT_LIST_HEAD(head) list_add (struct list_head *new, struct list_head *head) list_del (struct list_head *old) list_for_each...
list_head
幻影maple
04-21 4275
文章目录一、list_head介绍1、list_head简介2、list_head结构二、list_head实现1、list_head数据结构1）struct list_head三、list_head使用1、API函数1）创建链表2）添加节点a. __list_addb. list_addc. list_add_tail3）删除节点a. list_del...附录1、list_head疑问 一、l...
理解Linux内核：list_head双向链表解析
`list_head`是Linux内核中用于实现双向链表的核心结构，它由两个指针成员`next`和`prev`组成，分别指向链表的下一个节点和上一个节点。这样的设计使得在链表中进行插入和删除操作时可以从任一方向进行，提高了灵活性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值