list.h 解析

最新推荐文章于 2024-02-01 09:57:54 发布
最新推荐文章于 2024-02-01 09:57:54 发布
阅读量177 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/zmrlinux/p/4921391.html
版权

                                           内核数据结构list.h 解析

首先这个数据结构不同于我们我们设计的链表结构。

其实链表这种结构的各种操作就是改变链表的指针域而已，所以可以发现内核的链表结构在设计的时候其实只有指针域。

我的内核版本： 4.0.8-200.fc21.x86_6  此篇博客所有的源码都来自这个版本的内核。

节点的定义在./include/types.h 中

 

struct list_head {
    struct list_head *next,*prev;
};
 其实就是： 

struct list_head{

    struct list_head *next;
    struct list_head *prev;

};
可以看到链表的核心其实就是指针域的改变。

下面是两个头结点的初始化宏。

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

#define LIST_HEAD(name)\
        struct list_head name = LIST_HEAD_INIT(name)
这两句是源代码的头两个宏定义，作用是初始化一个链表节点的链接
例如申请一个变量head作为头结点
    LIST_HEAD(head) 等价于struct list_head head = {&(head),&(head)};
    就是对头节点的赋值了


同样有一个函数可以初始化

static inline void INIT_LIST_HEAD(struct list_head *list)
{
    list->next = list;
    list->prev = list;
}
在已知的两个节点中插入一个节点，此处是已经知道这两个节点的情况： 
static inline void __list_add(strcut list_head *new,strcut list_head *prev,
                              strcut list_head *next)
{
    next->prev = new;
    new->next  = next;
    new->prev  = prev;
    prev->next = new;
}
有了这个添加一个节点的函数，我们基本可以添加元素到任意位置了
例如添加一个节点进头结点之后 
static inline void list_add_tail(struct list_head *new,
                                struct list_head *head)
{
    __list_add(new,head,head->next);
}
添加一个节点到头指针之前 

static inline void list_add_tail(struct list_head *new,
                                struct list_head *head)
{
    __list_add(new,head->prev,head);
}
如果删除一个节点，其实本质上是两个节点之间的操作 

static inline void list_del(struct list_head *prev,struct list_head *next)
{
    next->prev = prev;
    prev->next = next;
}
如果需要删除一个具体存在的节点 

static inline void __list_del_entry(struct list_head *entry)
{
    __list_del(entry->prev,entry->next);
}
删除一个节点并且给相应的节点处理 

static inline void list_del(struct list_head *entry)
{
    __list_del(entry->prev,entry->next);
    entry->next = LIST_POISON1;
    entry->prev = LIST_POISON2;
}
使用一个新的节点替换一个旧的节点 

static inline void list_replace(struct list_head *old,
                               struct list_head *new)
{
    new->next = old->next;
    new->next->prev = new;
    new->prev = old->prev;
    new->prev->next = new;
}

使用一个新的节点替换一个旧的节点并且将旧的节点置空

static inline void list_replace_init(struct list_head *old,
                                    struct list_head *new)
{
    list_replace(old,new);
    INIT_LIST_HEAD(old);
}

删除一个结点从链表中，并且重新初始化 

static inline void list_del_init(struct list_head *entry)
{
    __list_del_entry(entry);
    INIT_LIST_HEAD(entry);
}


删除一个节点并且在这个位置上增加一个其它的节点

static inline void list_move(struct list_head *list,
                            struct list_head *head)
{
    __list_del_entry(list);
    list_add(list,head);
}
//删除一个节点的前一个节点，并且插入一个新节点 

static inline void list_move_tail(struct list_head *list
                                 struct list_head *head)
{
    __list_del_entry(list);
    list_add_tail(list,head);
}
/测试一个节点是不是其头节点 

static inline int list_is_last(const struct list_head *list,
                               const struct list_head *head)
{
    return list->next == head;
}

测试一个链表是不是空的 

static inline int list_empty(const struct list_head *head)
{
    return head->next == head;
}

测试一个链表是否非空 

static inline int list_empty_careful(const struct list_head *head)
{
    struct list_head *next = head->next;
    return (next == head) && (next == head->next);
}

反转一个节点 

static inline void list_roate_left(struct list_head *head)
{
    struct list_head *first;
    if(!list_empty(head)){
        first = head->next;
        list_move_tail(first,head);
    }
}

测试一个链表是不是仅仅只有一个节点 

static inline int list_is_singular(const struct list_head *head)
{
    return !list_empty(head) && (head->next == head->prev);
}

链表分割函数一共有三个参数，list :新的链表头结点；head:裁剪剩下的链表
entry:包含在链表head内并且是开始裁剪的结尾 

static inline void __list_cut_position(struct list_head *list,
                struct list_head *head,struct list_head *entry)
{
    struct list_head *new_first = entry->next;
    list->next = head->next;
    list->next->prev = list;
    list->prev = entry;
    entry->next = list;
    head->next = new_first;
    new_first->prev = head;
}

一个分割链表的实际操作 

static inline void list_cut_position(struct list_head *list,
                    struct list_head *head,struct list_head *entry)
{
    if(list_empty(head))
        return;
    if(list_is_singular(head) && (head->next != entry && head != entry))
        return ;
    if(entry == head)
        INIT_LIST_HEAD(list);
    else
        __list_cut_position(list,head,entry);

}
合并操作，这里主要看下核心步骤,就是将list领头的这个链表插入到
prev 和 next 之间不包含list 节点 

static inline void __list_splice(const struct listg_head *list,
                                struct list_head *prev,
                                struct list_head *next)
    struct list_head *first = list->next;
    struct list_head *last  = list->prev;

    first->prev = prev;
    prev->next  = first;
    last->next = next;
    next->prev = last;

}


static inline void list_splice(const struct list_head *list,
                              struct list_head *head)
{
    if(!list_empty(list)){
        __list_splice(list,head,head->next);
    }
}
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

@@@@@@@@@@@前@@@方@@@高@@@能@@@@@@@@@@@@@@@@@@@@@@@@@@@

链表的宏遍历再说这个之前，需要看几个必须的宏，不然，难以理解，

这是通过一个已经知道的指针地址，得到这个结构体的首地址，这样做封装性更好，适用范围更广。

#define list_entry(ptr, type, member)                  \

container_of(ptr, type , member)
这个宏的详细代码再下边 

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

const typeof(((type *)0)->member ) * __mptr  = (ptr);    \

(type *)((char *)__mptr  - offsetof(type, member)) ; })

offsetof 的代码还在下边 

#define offsetof(type, member）     ((unsigned int )&((type *)0)->member)
一般人看到这样的C代码肯定是一头雾水难以理解这是为什么，甚至根本看不明白是什么意思，毕竟是内核代码，看不懂也是正常的。首先第一个宏有三个参数  list_head *   指针，最终它会是这个链表节点的首地址，就可以通过访问它的其它成员变量了。  ptr 传入时的类型，也就是list_head * 这个结构体中    list_head  的变量名<其次是一个运算符 typeof 这是 C 语言的扩展。可以得到一个结构体的类型。((type *)0)->member ) * __mptr  = (ptr);
这一句，就是声明一个type 的member 类型的指针 __mptr  并且赋值ptr. 

#define offsetof(type, member）     ((unsigned int )&((type *)0)->member)

这个宏可以得到member 相对于结构体首地址的相对地址。 

(type *)((char *)__mptr  - offsetof(type, member)) ; })
这一句，就可以得到这个结构体的首地址了，就是地址相减，用member的地址减去它相对于首地址的偏移量就是这个结构体的首地址。


@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

这里ptr是一个链表的头结点，这个宏就是取得这个链表第一个元素的所指结构体的首地址

#define list_first_entry(ptr,type,member) \
        list_entry((ptr)->next,type,member)

判断一个链表是否为空，且取首地址。 

#define list_first_entry_or_null(ptr,type,member) \
        (!list_empty(ptr) ? list_first_entry(ptr,type,member):null)

也可以根据变量的next与prev来确定结构体的地址 

#define list_prev_entry(pos,member) \
        list_entry((pos)->member.prev,typeof(*(pos)),member)
#define list_next_entry(pos,member) \
        list_entry((pos)->member.prev,typeof(*(pos)),member)

链表的遍历 
#define list_for_each(pos,head)\
    for(pos = (head)->next; pos != (head);pos = pos->next)

遍历一遍链表，使用entry方法 

#define list_for_each_entry(pos,head,member) \
        for(pos = list_first_entry(head,typeof(*pos),member)\
           &pos->member != (head) \
           pos = list_next_entry(pos,member))

pos 表示结构体变量，head 是头结点，member 是list_head 在结构体当中的名字，这个函数就是如果Pos 为非空，那么pos就是其本身，否则在链表头强制扩充一个虚指针，为了list_for_each_entry_continue()做准备 

#define list_prepare_entry(pos,head,member)  \
        ((pos) ? :list_entry(head,typeof(*pos),member))

可以指定链表的任意一个节点开始遍历 

#define list_for_each_entry_continue(pos,head,member) \
        for(pos = list_next_entry(pos,member);           \
            &pos->member != (head);                   \
            pos = list_next_entry(pos,member))
同上从前边遍历 

#define list_for_each_continue_reverse(pos,head,member)   \
        for(pos = list_prev_entry(pos,member);\
           &pos->member != (head);              \
           pos = list_prev_entry(pos,member))


#define list_safe_reset_next(pos,n,member)       \
        n = list_next_entry(pos,member)


内核哈希链表：

这个链表和我们平时常见的链表有很大的不同，哈希表的结构设计和普通的链表有很大的区别

首先哈希表的头结点和其它节点有很大的不同。

struct hlist_head{
    struct hlist_node *first;
};

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

这个链表首先使用的是hlist_head 节点做头结点，然后使用hlist_node 做其它节点，最后一个节点指向NULL
其中**prev 指向的是前一个节点的next.就是指向自己。


如果画成图就是这个样子的。

初始化以及判断是否为空

#define HLIST_HEAD_INIT{ .first = NULL }
#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
#define INIT_HLIST_HEAD(ptr)  ((ptr)->first = NULL)

static inline void INIT_LIST_NODE(struct hlist_node *h)
{
    h->next = NULL;
    h->pprev = NULL;
}

static inline int hlist_unhashed(const struct hlist_node *n)
{
    return !h->pprev;
}

static inline int hlist_empty(const struct hlist_head *h)
{
    return !h->first;
}


删除一个结点，看起来代码不多但是挺复杂的
static inline void __hlist_del(struct hlist_node *n)
{
    struct hlist_node *next = n->next;  //首先删除N节点，申请一个next 指向n的下一个节点；
    struct hlist_node **prev = n->pprev;//申请一个二重指针开始指向n,
    *pprev = next;                      //n前面的next指向了n后面的元素
    if(next)                            //如果next非空，后一个元素赋值pprev
        next->pprev = pprev;
}



添加节点一共有三个函数
第一个向链表头结点后边增加节点
static inline void hlist_add_head(struct hlist_node *n,struct hlist_head *h)
{
    struct hlist_node *first = h->first;
    n->next = first;
    if(first)
        first->pprev = &n->next;   //注意符号优先级，二级指针
    h->first = n;
    n->pprev = &h->first;
}


//next must be != NULL,在next前边添加一个节点n
static inline void hlist_add_before(struct hlist_node *n,struct hlist_node *next)
{
    n->pprev = next->pprev;
    n->next  = next;
    next->pprev = &n->next;
    *(n->pprev) = n;
}


//next must be != NULL ,在next后边添加一个节点n
static inline void hlist_add_behind(struct hlist_node *n,struct hlist_node *prev)
{
    n->next = prev->next;
    prev->next = n;
    n->pprev = &prev->next;
    if(n->next)
        n->next->pprev = &n->next;

}


下面是hlist的宏遍历
#define hlist_entry(ptr,type,member) \
        container_of(ptr,type,member)

#define hlist_for_each(pos,head)     \
        for(pos = (head)->first;pos;pos= pos->next)


//这是一个hlist的宏的安全遍历，其中添加了变量n,防止在遍历过程中
//发生断链的情况

#define hlist_for_each_safe(pos,n.head) \
        for(pos = (head)->first;pos && ({n = pos->next;1;});\
           pos = n) \



可能有人对pos && ({n = pos->next;1;})

这一句也不理解，这个for循环还是在判断pos这个东西是不是为空值于后边的部分，其实就是一个赋值操作，但是它必须返回1，

所以就写成<pre name="code" class="cpp" style="font-size:18px;"> ({n = pos->next;1;})

这个样子了，这个部分始终返回1.

#define hlist_entry_safe(ptr,type,member) \
        ({typeof(ptr)___ptr = (ptr); \
          ___ptr?hlist_entry(___ptr,type,member):NULL; \
         })


遍历整个链表
#define hlist_for_each_entry(pos,head,member) \
        for(pos = hlist_entry_safe((head)->first),typeof(*(pos)),member); \
        pos;\
        pos = hlist_entry_safe((pos)->member.next,typeof(*(pos)),member)


#define hlist_for_each_entry_continue(pos, member)pos\
            for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\
                         pos;for\
                         pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))


#define hlist_for_each_entry_from(pos, member)hlist_for_each_entry_from\
            for (; pos;typeof\
                         pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))


#define hlist_for_each_entry_safe(pos, n, head, member)         \
            for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\
                         pos && ({ n = pos->member.next; 1;  });pos\
                         pos = hlist_entry_safe(n, typeof(*pos), member))


版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://www.cnblogs.com/zmrlinux/p/4921391.html

weixin_30478619
关注
浅谈List.h,list.h函数解析
09-01
"List.h头文件解析" List.h头文件是Linux内核中一个非常重要的头文件，提供了链表操作的相关函数和宏。下面我们将对List.h头文件中的重要知识点进行详细的解析。 1. 链表的初始化 List.h头文件中定义了一个链表...
Linux中List.h文件的分析和应用
fengel_cs的专栏
10-07 2297
本文介绍Linux中List.h文件，此文件中用双向链表实现了多种数据结构，比如队列，堆栈等，短小精湛，值得借鉴。此文件中还有哈希表的应用。
C语言---list.h宏解读
小豹Miss鲍的博客
10-14 3957
C语言—宏解读 这个宏定义,主要就返回一个结构体成员的指针 环境:mac + gcc编译器 + vscode代码编辑器 #define list_entry(ptr, type, member) \ ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member))) 先来一段代码说明怎么使用和作用 ...
list.h使用说明
热门推荐
lmjjw的专栏
08-08 1万+
1     位置 2     数据结构 3     接口 3.1  offsetof 3.2  container_of 3.3  LIST_HEAD_INIT 3.4  LIST_HEAD 3.5  INIT_LIST_HEAD 3.6 _list_add 3.7  list_add 3.8  list_add_tail 3.
linux内核list.h头文件分析（一）
sunjiangangok的博客
04-10 744
之前上《linux操作系统》课程的时候，陈老师安排的一个作业就是分析linux内核中的头文件list.h，但是之前我没有认真做，都是完成任务式的去做。    今天比较伤心些，一个同学问我list.h中的#define LIST_HEAD_INIT(name) { &(name), &(name) } #define LIST_HEAD(name) \     struct list_head
【数据结构】list.h 常用函数实现详解
wkd_007的博客
09-24 1373
本文介绍了 list.h 的函数实现，对如何使用 list.h 有一定帮助。
list.h.zip
06-18
本文将深入探讨《Linux C——通用链表（整理自Linux内核链表）》中涉及的知识点，结合压缩包中的"kernel_list.h"和"common_list.h"文件，我们将对Linux内核中的链表实现进行详细的解析。 链表主要分为单链表、双...
kernel的list.h（分享）
01-31
这份文档深入解析了`list.h`中的关键知识点，为初学者提供了宝贵的指导。 #### 二、结构体`struct list_head` 在`list.h`中最基础的数据结构是`struct list_head`： ```c struct list_head { struct list_head *...
C语言进行解析域名.docx
07-24
- `h_addr_list`：域名对应的IP地址列表。 #### 四、注意事项 - 在实际应用中，需要注意`gethostbyname()`函数已经被`getaddrinfo()`等更现代的函数所替代，后者支持更多的地址族和协议。 - 对于错误处理，应当...
深入浅出linux内核源代码之双向链表list_head(list.h).pdf
03-31
在Linux内核中，`list.h`头文件定义了双向链表的核心结构——`struct list_head`，这是一个非常简单的结构体： ```c struct list_head { struct list_head *next, *prev; }; ``` 这个结构体包含两个指针字段：`...
linux——list.h
sinat_34467747的博客
09-23 6348
*linux中的头文件list.h 在Linux的源码中有一个自己为建立链表而写的链表头文件，以后可以直接调用里面的函数来使用链表。 list.h在linux中的路径为/usr/src/kernels/include/linux。不同的版本可能不一样。 list.h中有两个宏定义：#define LIST_HEAD_INIT(name) {&(name),&（name）} #define LI
【数据结构】list.h 详细使用教程 -- 附带例子代码
wkd_007的博客
09-24 1427
介绍list.h 的详细用法，并给出例子代码
深入理解Linux内核之链表 list.h 功能实现原理、接口说明及示例代码
猪哥的专栏
08-11 6144
目录 一、双向链表接口函数及相关宏定义分析 0、list_head 结构体 1、offsetof(TYPE, MEMBER) 宏 2、ontainer_of(ptr, type, member) 宏 3、LIST_HEAD_INIT 宏 4、LIST_HEAD 宏 5、INIT_LIST_HEAD 函数 6、LIST_HEAD 和INIT_LIST_HEAD 的区别 7、lis...
c语言内核链表list.h的解释及应用_c笔记
最新发布
fudra的博客
02-01 590
一个简单的学生管理系统。
list 移植与基本使用
lpaim的博客
03-11 721
list 移植与基本使用
Linux 中list.h使用实例和坑
monkeyzh123的专栏
08-25 2319
​ list.h是Linux内核中，为了提供统一的链表操作，减少结构体的额外开支提供的链表操作。list.h中定义的链表了一个双向循环链表，和一个哈希表。内含实际例子 ​
数据结构-链表list.h 使用操作
jiu_yue_ya的博客
05-22 463
读者可自己画个读，就不难发现 list_add_tail 宏所实现的是一个类头插法，它是将节点插入在头节点的前面，但是头节点的位置不会变，也就是以我们一开始定义的头节点为头，新来的节点始终插入在这个头节点的前面，所以可以看到__list_add 中的操作就是将新节点插入在头节点和头节点前面元素之间。在对链表进行操作之前，首先我们需要为链表指定好链表头，以方便管理，后面的操作接口中的参数很多也是要和这个链表头有关联，在操作之前，要先定义一个。是返回头节点下一个节点的节点地址，因为头节点就是一个。
FreeRTOS —— 关于 list.c 与 list.h 中部分内容详解
T541132的博客
04-13 295
迷你列表项就是精简的列表项，对应的结构体成员与前一个列表项结构体一样。为什么要进行 ( ListItem_t * ) ，因为根节点。，所以需要强制类型转换。
内核链表 list.h
qq_43001551的博客
10-19 212
记录一下整理的关于内核链表相关函数内容 一、双指针双向循环链表（list） 1. 基本原理 struct list_head { struct list_head* pPre; struct list_head* pNext; }; typedef struct _STU { char cSex; char szAddress[128]; int iNumber; int iFlag; struct list_head mylist; }STU;
深入解析Linux内核list.h：遍历与操作
本篇文章将深入解析`list.h`中的关键概念和宏。 ### 1. 前言 `list.h`中的链表分为两种类型：`list`和`hlist`。`list`是双链表，而`hlist`则是一种优化的单链表，常用于哈希表。本文主要关注`list`链表的使用和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值