/*

 * Simple doubly linked list implementation.

 *

 * Some of the internal functions ("__xxx") are useful when

 * manipulating whole lists rather than single entries, as

 * sometimes we already know the next/prev entries and we can

 * generate better code by using them directly rather than

 * using the generic single-entry routines.

 */

struct list_head {

    struct list_head *next, *prev;

};

#define LIST_HEAD_INIT(name) { &(name), &(name) }//初始化链表节点name，将前指针和后指针都指向自己

#define LIST_HEAD(name) \　　　　　　　　　　　　　　//定义的同时初始化

    struct list_head name = LIST_HEAD_INIT(name)

static inline void INIT_LIST_HEAD(struct list_head *list)　//链表头节点初始化函数

{

    list->next = list;

    list->prev = list;

}

/*

 * Insert a new entry between two known consecutive entries.

 *

 * This is only for internal list manipulation where we know

 * the prev/next entries already!

 */

#ifndef CONFIG_DEBUG_LIST

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;

    prev->next = new;

}

#else

extern void __list_add(struct list_head *new,

                  struct list_head *prev,

                  struct list_head *next);

#endif

/**

 * list_add - add a new entry

 * @new: new entry to be added

 * @head: list head to add it after

 *

 * Insert a new entry after the specified head.

 * This is good for implementing stacks.

 */

static inline void list_add(struct list_head *new, struct list_head *head)

{

    __list_add(new, head, head->next);

}

/**

 * list_add_tail - add a new entry

 * @new: new entry to be added

 * @head: list head to add it before

 *

 * Insert a new entry before the specified head.

 * This is useful for implementing queues.

 */

static inline void list_add_tail(struct list_head *new, struct list_head *head)

{

    __list_add(new, head->prev, head);

}

#include <linux/list.h>

struct driver_info

{

    int data;

};

// driver结构体用来管理内核中的驱动

struct driver

{

    char name[];                // 驱动名称

    int id;                        // 驱动id编号

    struct driver_info info;    // 驱动信息

    struct list_head head;        // 内嵌的内核链表成员

};

struct driver2

{

    char name[];                // 驱动名称

    int id;                        // 驱动id编号

    struct driver_info info;    // 驱动信息

    //struct list_head head;        // 内嵌的内核链表成员

    struct driver *prev;

    struct driver *next;

};

// 分析driver结构体，可知：前三个成员都是数据区域成员（就是我们之前简化为int data的东西），第4个成员是一个struct list_head类型的变量，这就是一个纯链表。

// 本来driver结构体是没有链表的，也无法用链表来管理。但是我们driver内嵌的head成员本身就是一个纯链表，所以driver通过head成员给自己扩展了链表的功能。

// driver通过内嵌的方式扩展链表成员，本身不只是有了一个链表成员，关键是可以通过利用list_head本身事先实现的链表的各种操作方法来操作head。

// 最终效果：我们可以通过遍历head来实现driver的遍历；遍历head的函数在list.h中已经事先写好了，所以我们内核中去遍历driver时就不用重复去写了。

// 通过操作head来操作driver，实质上就是通过操作结构体的某个成员变量来操作整个结构体变量。这里面要借助container_of宏

/**

 * list_entry - get the struct for this entry

 * @ptr:    the &struct list_head pointer.

 * @type:    the type of the struct this is embedded in.

 * @member:    the name of the list_struct within the struct.

 */

#define list_entry(ptr, type, member) \

    container_of(ptr, type, member)

#ifndef offsetof

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

#endif

#ifndef container_of

/**

 * container_of - cast a member of a structure out to the containing structure

 * @ptr:    the pointer to the member.

 * @type:    the type of the container struct this is embedded in.

 * @member:    the name of the member within the struct.

 *

 */

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

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

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

#endif