linux内核list模块的使用

标签：

List模块是linux内核提供的循环链表函数集，头文件是：<linux/list.h>。

主要数据结构：

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

这是一个双向链表。

#define LIST_HEAD_INIT(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;
}

使用之前必须初始化一个链表头，可以使用下面的宏直接定义并且初始化一个链表头：

LIST_HEAD(name)

宏参数name是链表头定义名。

例如：

LIST_HEAD(listHead)

使用list模块中的方法时，你的数据结构中必须包含struct list_head类成员，例如:

Struct myNode{
      Int a;
      Struct list_head listNode;
};
Struct myNode nodeVar;

插入操作

/*
 * 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.
 */
#ifndef CONFIG_DEBUG_LIST
static inline void list_add(struct list_head *new, struct list_head *head)
{
        __list_add(new, head, head->next);
}
#else
extern void list_add(struct list_head *new, struct list_head *head);
#endif

调用list_add函数可以将一个数据节点加入到链表中.

List_add(&nodeVar->listNode,&listHead)

将元素加入到链表首位置，即链表头listHead的下一个位置。

/**
 * 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);
}

List_add_tail(&nodeVar->listNode,&listHead);

其实它是把nodeVar中的listNode元素接入链表末尾

删除操作

/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
        next->prev = prev;
        prev->next = next;
}
/**
 * list_del - deletes entry from list.
 * @entry: the element to delete from the list.
 * Note: list_empty on entry does not return true after this, the entry is
 * in an undefined state.
 */
#ifndef CONFIG_DEBUG_LIST
static inline void list_del(struct list_head *entry)
{
        __list_del(entry->prev, entry->next);
        entry->next = LIST_POISON1;
        entry->prev = LIST_POISON2;
}
#else
extern void list_del(struct list_head *entry);
#endif

#define list_for_each_entry(pos, head, member)                                  for (pos = list_entry((head)->next, typeof(*pos), member);                   prefetch(pos->member.next), &pos->member != (head);                     pos = list_entry(pos->member.next, typeof(*pos), member))
#define list_entry(ptr, type, member) 	container_of(ptr, type, member)

假如有n个struct myNode变量加入了链表，查找元素a =100的节点的操作如下

Struct myNode* Pos
list_for_each_entry(Pos, &listHead,listNode)
{
       If(Pos->a== 100)
       {
       …….
       }
}

 如果涉及到Pos的指针内存操作，例如释放等，可以使用函数：

/**
 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @pos:        the type * to use as a loop cursor.
 * @n:          another type * to use as temporary storage
 * @head:       the head for your list.
 * @member:     the name of the list_struct within the struct.
 */
#define list_for_each_entry_safe(pos, n, head, member)                          for (pos = list_entry((head)->next, typeof(*pos), member),                      n = list_entry(pos->member.next, typeof(*pos), member);              &pos->member != (head);                                                 pos = n, n = list_entry(n->member.next, typeof(*n), member))

例子：

Struct myNode* cPos， nPos;
list_for_each_entry_safe(cPos, nPos, &listHead, listNode)
{
	list_del(cPos);
	free(cPos);
}

注：

container_of(ptr, type, member)是那就是根据一个结构体变量中的一个域成员变量的指针来获取指向整个结构体变量的指针。

例如：container_of(&nodeVar->listNode, struct myNode, listNode)

/**
* 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 *)0)->member ) *__mptr = (ptr);     /
         (type *)( (char *)__mptr - offsetof(type,member) );})

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

linux内核list模块的使用

标签：

原文地址：http://blog.csdn.net/liuruiqun/article/details/46912705