Linux内核双向循环链表 list_head 部分功能重构

一 为什么要重构Linux中的双向循环链表?
第一，首先 Linux内核双向循环链表的实现依赖于GNU编译器，里面有一些语法是GUN编译器的语法，标准C编译器不能使用它。所以需要清除平台相关代码。

1 ({})
2 typeof()
3 _builtin_prefetch() 用于优化代码
4 static inline GNU编译器中可以这样组合是用，但是标准C中不可以这样使用

第二，需要清除文件中的依赖

// #include <linux/types.h>
// #include <linux/stddef.h>
// #include <linux/poison.h>
// #include <linux/prefetch.h>

---

Linux内核链表的实现：

1 带头结点的双向循环链表，并且，头结点是链表中的成员
2 头结点的next指针指向首节点
3 头结点的prev指针指向尾节点

Linux 内核链表的节点的定义：

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

Linux 内核链表的节点的使用

//使用 struct list_head 自定义链表节点
struct Node
{
struct list_head head;
Type1 value1;
Type2 value2;
//...
};

Linux 内核链表的创建及初始化

struct Node
{
struct list_head head;
int value;
};

int main(void)
{
	struct Node L = {0};
	struct list_head* list = (struct list_head*)&L;

	INIT_LIST_HEAD(list);
	//...
}

---

关于内核链表的几点注意：

1 关于INIT_LIST_HEAD() 初始化头结点

//初始化头结点 让头结点自己变成一个双向循环链表
static void INIT_LIST_HEAD(struct list_head *list)
{
    list->next = list;
    list->prev = list;
}

2 关于 Linux 内核链表的插入操作

1 在链表头部插入： list_add(new,head)
2 在链表尾部插入： list_add_tail(new,head)


//new插入位置：prev -> new ->next
static 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;
}

/*
  向链表头插入新节点
 */
static void list_add(struct list_head *new, struct list_head *head)
{
    __list_add(new, head, head->next);
}


/*
  向链表尾插入新节点
 */
static void list_add_tail(struct list_head *new, struct list_head *head)
{
    __list_add(new, head->prev, head);
}

3 关于 Linux 内核链表的删除操作

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

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

4 关于Linux内核链表遍历操作

1 正向遍历
2 反向遍历 


/*
正向遍历链表
 */
#define list_for_each(pos, head) \
    for (pos = (head)->next; prefetch(pos->next), pos != (head); \
            pos = pos->next)

/*
反向遍历链表
 */
#define list_for_each_prev(pos, head) \
    for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
            pos = pos->prev)

双向链表部分功能移植：

LinuxList.h

#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H

// #include <linux/types.h>
// #include <linux/stddef.h>
// #include <linux/poison.h>
// #include <linux/prefetch.h>

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

//修改 container_of，去除依赖GUN编译器的类型检查一行
#ifndef container_of
#define container_of(ptr, type, member) ((type *)((char *)ptr - offsetof(type,member)))
#endif

//去除依赖
#define prefetch(x) ((void)x)
//去除依赖
#define LIST_POISON1  (NULL)
#define LIST_POISON2  (NULL)

//节点
struct list_head {
    struct list_head *next, *prev;
};

//初始化头结点 让头结点自己变成一个双向循环链表
static void INIT_LIST_HEAD(struct list_head *list)
{
    list->next = list;
    list->prev = list;
}


#ifndef CONFIG_DEBUG_LIST

//new插入位置：prev -> new ->next
static 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;
}
#else
extern void __list_add(struct list_head *new,
                  struct list_head *prev,
                  struct list_head *next);
#endif

/*
  向链表头插入新节点
 */
static void list_add(struct list_head *new, struct list_head *head)
{
    __list_add(new, head, head->next);
}


/*
  向链表尾插入新节点
 */
static void list_add_tail(struct list_head *new, struct list_head *head)
{
    __list_add(new, head->prev, head);
}

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

/*
  list_entry == container_of
*/
#define list_entry(ptr, type, member) \
    container_of(ptr, type, member)


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


#endif

main.c

#include <stdio.h>
#include "LinuxList.h"

//struct  list_head放在自定义节点首位置
void list_demo_1()
{
    //节点类型，list_head放在节点首
    struct Node
    {
        struct list_head head;
        int value;
    };

    //创建头结点
    struct Node l = {0};
    //取头结点 list_head 地址，由于list_head位于自定义节点头，所以可以这样强制类型转换
    struct list_head* list = (struct list_head*)&l;

    struct list_head* slider = NULL;
    int i = 0;

    //将头结点自己设置为双向循环链表
    INIT_LIST_HEAD(list);

    printf("Insert begin ...\n");

    for(i=0; i<5; i++)
    {
        //创建新节点
        struct Node* n = (struct Node*)malloc(sizeof(struct Node));

        //初始化节点 value值
        n->value = i;

        //将新节点插入到链表尾部，由于list_head位于自定义节点头，所以可以这样强制类型转换
        list_add_tail((struct list_head*)n, list);
    }

    //用slider指针遍历 list链表
    list_for_each(slider, list)
    {
        //访问链表指针所在节点的value,由于list_head位于自定义节点头，所以可以这样强制类型转换
        printf("%d\n", ((struct Node*)slider)->value);
    }

    printf("Insert end ...\n");

    printf("Delete begin ...\n");

    //用slider指针遍历 list链表
    list_for_each(slider, list)
    {
        //删除value为3  的节点，由于list_head位于自定义节点头，所以可以这样强制类型转换
        if( ((struct Node*)slider)->value == 3 )
        {
            list_del(slider);
            free(slider);
            break;
        }
    }

    list_for_each(slider, list)
    {
        printf("%d\n", ((struct Node*)slider)->value);
    }

    printf("Delete end ...\n");
}

//struct  list_head放在自定义节点尾位置
void list_demo_2()
{
    //节点类型，list_head放在节点尾
    struct Node
    {
        int value;
        struct list_head head;
    };
    //创建头结点
    struct Node l = {0};
    //取头结点 list_head 地址
    struct list_head* list = &l.head;
    struct list_head* slider = NULL;
    int i = 0;

    //将头结点自己设置为双向循环链表
    INIT_LIST_HEAD(list);

    printf("Insert begin ...\n");

    for(i=0; i<5; i++)
    {
        struct Node* n = (struct Node*)malloc(sizeof(struct Node));

        n->value = i;

        //将新节点插入到链表头部，list_head位于自定义节点尾
        list_add(&n->head, list);
    }

    list_for_each(slider, list)
    {
        //list_entry == container_of, slide 指向Node节点中的 head成员，得到Node首地址
        printf("%d\n", list_entry(slider, struct Node, head)->value);
    }

    printf("Insert end ...\n");


    printf("Delete begin ...\n");

    list_for_each(slider, list)
    {
         //list_entry == container_of, slide 指向Node节点中的 head成员，得到Node首地址
        struct Node* n = list_entry(slider, struct Node, head);

        if( n->value == 3 )
        {
            list_del(slider);
            free(n);
            break;
        }
    }

    list_for_each(slider, list)
    {
        //list_entry == container_of, slide 指向Node节点中的 head成员，得到Node首地址
        printf("%d\n", list_entry(slider, struct Node, head)->value);
    }

    printf("Delete end ...\n");
}

int main()
{
     list_demo_1();
    // list_demo_2();

    return 0;
}