Linux中内核链表的实现

其他资料：https://www.cnblogs.com/wangzahngjun/p/5556448.html

采用分层思想，指针部分和数据部分剥离开来，其节点只包含指针域，不包含数据域。

struct list_head   //链表节点结构体
{
    struct list_head *prev;
    struct list_head *next;
};

增删改查部分代码如下：

/* 内核链表操作函数
* 部分代码，其他函数基本类似
*
*
*
 */

void INIT_LIST_HEAD(struct list_head *node)
{
    node->next = node;
    node->prev = node;
}
void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)
{
    prev->next = new;
    new->next = next;
    next->prev = new;
    new->prev = prev;
}
void list_add(struct list_head *new, struct list_head *head) // 头部插入
{
    __list_add(new, head, head->next);
}
void list_add_tail(struct list_head *new, struct list_head *head) // 尾部插入
{
    __list_add(new, head->prev, head);
}

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

void list_del(struct list_head *entry)
{
    __list_del(entry->prev, entry->next);
}

重点分析下面的宏定义：

#define offsetof(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER)
#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) ); })                        

#define list_for_each(pos, head) \
 for (pos = (head)->next; pos != (head); pos = pos->next)

//我先定义一个结构体
struct userInfo
{
  int id;
  char name[32];
  struct list_head node;
};

逐条分析这些宏定义:(这里采用上方结构体讲解比较直观)

#define offsetof(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER)

(1) TYPE是自己的结构体类型， ((TYPE *)0)，将地址0转换成TYPE类型

（2） ((struct userInfo *)0)->node，访问结构体中的node成员

（3）& ((struct userInfo *)0)->node)，获取成员node的地址，表示node成员在结构体中的偏移量

（4）((size_t) & ((struct userInfo *)0)->node) size_t 在32位系统是unsigned int ,64位系统则是unsigned long

2.

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

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

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

(1)typeof( ((struct userInfo *)0)->node) 获取成员node的数据类型

（2）const typeof( ((struct userInfo *)0)->node ) *__mptr = &(userInfo->node)

const struct list_head*__mptr=&(userInfo->node)

(3) offsetof(struct userInfo,node) 获取结构体中node成员偏移量

(4)(char *)__mptr - offsetof(struct userInfo,node) ) 获取结构体的成员地址

（5）(struct userInfo *)( (char *)__mptr - offsetof(struct userInfo,node) ); }) 强制转换成结构体类型

//成员地址-起始地址=偏移量

3.

#define list_for_each(pos, head) \

for (pos = (head)->next; pos != (head); pos = pos->next)

这个就比较简单了，就是一个单向循环链表的遍历操作，循环条件是！=头节点