内核链表list.h文件剖析

最新推荐文章于 2024-03-06 20:24:40 发布

a1314521531

最新推荐文章于 2024-03-06 20:24:40 发布

阅读量1.3k

点赞数

分类专栏： C语言 Linux C高级编程 ARM 文章标签：内核链表内核链表剖析 list.h

本文链接：https://blog.csdn.net/wqx521/article/details/52385635

版权

ARM 同时被 3 个专栏收录

41 篇文章 1 订阅

订阅专栏

Linux C高级编程

40 篇文章 5 订阅

订阅专栏

C语言

31 篇文章 1 订阅

订阅专栏

内核链表list.h文件剖析

一、内核链表的结构【双向循环链表】

内核链表的好主要体现为两点，1是可扩展性，2是封装。可以将内核链表复用到用户态编程中，以后在用户态下编程就不需要写一些关于链表的代码了，直接将内核中list.h中的代码拷贝过来用。

struct list_head
{
  struct list_head *next, *prev;
}; // 包含了两个指向list_head结构体的指针next,prev[后驱和前驱]

二、内核链表常用接口

1、INIT_LIST_HEAD：创建链表

2、list_add：在prev和next之间插入结点

3、list_add_tail：在链表尾插入结点

4、list_del：删除结点

5、list_entry：取出结点

6、list_for_each：遍历链表

【推荐看使用sourceInsight查看代码】

三、深入分析list.h

1、offsetof【在已知某一个成员变量的名字和结构体类型的情况下，计算该成员相对于结构体的起始地址的偏移量】

#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER)__compiler_offsetof(TYPE,MEMBER)
#else
#ifndef offsetof
#define offsetof(type, member) ((size_t) &((type*)0)->member)
#endif

2、container_of【已知某一个成员变量的名字、指针和结构体类型的情况下，计算结构体的指针，也就是计算结构体的起始地址】

#define container_of(ptr, type, member) ({ \
  const typeof(((type *)0)->member ) *__mptr = (ptr); \
  (type *)((char *)__mptr - offsetof(type,member) );})

3、LIST_HEAD_INIT【初始化一个结点名字为name的双向循环链表的头结点】

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

4、LIST_HEAD【初始化一个结点名字为name的双向循环链表的头结点】

#define LIST_HEAD(name) \
  struct list_head name = LIST_HEAD_INIT(name)

5、INIT_LIST_HEAD【初始化链表节点，将next和prev指针都指向其自身，我们就构造了一个空的双循环链表。】

static __INLINE__ void INIT_LIST_HEAD(struct list_head *list)
{
  list->next= list;
  list->prev= list;
}

6、list_add【在头结点后加一个新结点】

#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
 
static __INLINE__ void list_add(struct list_head *new,struct list_head *head)
{
 __list_add(new, head, head->next);
}

7、list_add_tail【添加结点new到链表尾】

static __INLINE__ void list_add_tail(struct list_head *new, struct list_head *head)
{
 __list_add(new, head->prev, head);
} // 在head->prev和head之间加入new，即在链表尾加入new结点

8、list_del【list_del将会将该节点与外界的“联系”切断，然后就可以使用free释放了（如果是内核态就用kfree或vfree）】

#define LIST_POISON1 0
#define LIST_POISON2 0
 
static __INLINE__ void __list_del(struct list_head *prev, struct list_head * next)
{
  next->prev= prev;
  prev->next= next;
}
 
#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

9、list_replace【用结点new替换结点old】

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;
}

10、 list_replace_init【用结点new替换结点old，并初始化old】

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

11、list_del_init【删除结点entry，并初始化entry】

static __INLINE__ void list_del_init(struct list_head*entry)
{
 __list_del(entry->prev, entry->next);
 INIT_LIST_HEAD(entry);
}

12、list_move【先将list节点从原链表中删除，然后将其添加到head链表的表头】

static __INLINE__ void list_move(struct list_head *list, struct list_head *head)
{
 __list_del(list->prev, list->next);
  list_add(list,head);
}

13、list_move_tail【先将list节点从原链表中删除，然后将其添加到head链表的表尾】

static __INLINE__ void list_move_tail(struct list_head *list,
                                      struct list_head *head)
{
 __list_del(list->prev, list->next);
 list_add_tail(list, head);
}

14、list_is_last【测试list节点是否为head链表的表尾节点。是返回1，否则返回0】

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

15、list_empty【判断head链表是否为空链表，是返回1，否则返回为0】

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

16、list_empty_careful【判断节点head的前驱和后驱是否都指向head。是返回1，否则返回0】

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

17、list_rotate_left【函数每次将头结点后的一个结点放到head链表的末尾，直到head结点后没有其他结点】

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

18、list_is_singular【判断head链表是否为单节点链表。是返回1，否为0】

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

19、__list_cut_position【这个函数是将head链表的头结点至entry节点之间的节点连在list节点后面，即组成以list节点为头结点的新链表】

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;
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

20、list_cut_position【与__list_cut_position功能相似，不过要先判断链表head是否为空链表，再判断是否为了单链表而且节点不是entry的情况，如果head==entry，直接初始化list】

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

21、__list_splice【将list链表的全部节点（头节点list除外）插入在prev和next节点之间】

static __INLINE__ void __list_splice(const struct list_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;
}

22、list_splice_tail【在list是非空链表的情况下，将其插在head链表的尾部，即head节点的前面】

static __INLINE__ void list_splice_tail(struct list_head *list,
                                        struct list_head *head)
{
  if(!list_empty(list))
  {
   __list_splice(list, head->prev, head);
  }
}

23、list_splice_init【在list是非空链表的情况下，将其插在head链表的尾部，即head节点的前面。然后对list节点进行初始化，排除不安全因素】

static __INLINE__ void list_splice_init(struct list_head *list,
                                        struct list_head *head)
{
  if(!list_empty(list))
  {
   __list_splice(list, head, head->next);
   INIT_LIST_HEAD(list);
  }
}

24、list_splice_tail_init【在list是非空链表的情况下，将其插在head链表的尾部，即head节点的前面。然后对list节点进行初始化，排除不安全因素】

static __INLINE__ void list_splice_tail_init(struct list_head *list, struct list_head *head)
{
  if(!list_empty(list))
  {
   __list_splice(list, head->prev, head);
   INIT_LIST_HEAD(list);
  }
}

25、list_entry【获取type类型结构体的起始指针】

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

26、list_first_entry【已知type类型的结构体中member成员的指针后，求得它所在的链表的下一个指针所指的member所在的type类型的结构体的起始地址】

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

27、list_for_each【从head节点开始（不包括head节点）遍历它的每一个节点】

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

28、list_for_each_prev【它也是从head节点开始（不包括head节点）向前遍历每一个节点！即从链表的尾部开始遍历】

#define list_for_each_prev(pos, head) \
  for (pos =(head)->prev; prefetch(pos->prev), pos != (head); \
          pos =pos->prev)

29、list_for_each_safe【从head节点开始（不包括head节点！）遍历它的每一个节点！它用n先将下一个要遍历的节点保存起来，防止删除本节点后，无法找到下一个节点，而出现错误】

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

30、list_for_each_prev_safe【它也是从head节点开始（不包括head节点）向前遍历每一个节点！即从链表的尾部开始遍历】

#define list_for_each_prev_safe(pos, n, head) \
  for (pos =(head)->prev, n = pos->prev; \
      prefetch(pos->prev), pos != (head); \
       pos = n,n = pos->prev)

31、list_for_each_entry【已知指向某个结构体的指针pos，以及指向它中member成员的指针head，从下一个结构体开始向后遍历这个结构体链】

#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))

32、list_for_each_entry_reverse【已知指向某个结构体的指针pos，以及指向它中member成员的指针head，从下一个结构体开始向前遍历这个结构体链】

#define list_for_each_entry_reverse(pos, head,member)      \
  for (pos =list_entry((head)->prev, typeof(*pos), member);  \
      prefetch(pos->member.prev), &pos->member != (head);  \
       pos =list_entry(pos->member.prev, typeof(*pos), member))

33、list_prepare_entry【判断pos这个指针是否为空，为空的话给它赋值list_entry(head, typeof(*pos), member)这条语句求出来的结构体的地址】

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

34、list_for_each_entry_continue【已知指向某个结构体的指针pos，以及指向它中的member成员的head指针，从它的下一个结构体开始向后遍历这个链表】

#define list_for_each_entry_continue(pos, head,member)     \
  for (pos =list_entry(pos->member.next, typeof(*pos), member);  \
      prefetch(pos->member.next), &pos->member != (head);  \
       pos =list_entry(pos->member.next, typeof(*pos), member))

35、list_for_each_entry_continue_reverse【已知指向某个结构体的指针pos，以及指向它中的member成员的head指针，从它的前一个结构体开始向前遍历这个链表】

#define list_for_each_entry_continue_reverse(pos,head, member)   \
  for (pos =list_entry(pos->member.prev, typeof(*pos), member);  \
      prefetch(pos->member.prev), &pos->member != (head);  \
       pos =list_entry(pos->member.prev, typeof(*pos), member))

36、list_for_each_entry_from【从pos节点开始，向后遍历链表】

#define list_for_each_entry_from(pos, head,member)       \
  for (;prefetch(pos->member.next), &pos->member != (head);  \
       pos =list_entry(pos->member.next, typeof(*pos), member))

37、list_for_each_entry_safe【先保存下一个要遍历的节点！从head下一个节点向后遍历链表】

#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))

38、list_for_each_entry_safe_continue【先保存下一个要遍历的节点！从pos下一个节点向后遍历链表】

#define list_for_each_entry_safe_continue(pos, n, head,member)     \
  for (pos =list_entry(pos->member.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))

39、list_for_each_entry_safe_from【先保存下一个要遍历的节点！从pos节点向后遍历链表】

#define list_for_each_entry_safe_from(pos, n, head,member)       \
  for (n =list_entry(pos->member.next, typeof(*pos), member);    \
      &pos->member != (head);           \
       pos = n, n = list_entry(n->member.next,typeof(*n), member))

40、list_for_each_entry_safe_reverse【先保存下一个要遍历的节点！从链表尾部向前遍历链表】

#define list_for_each_entry_safe_reverse(pos, n, head,member)    \
  for (pos =list_entry((head)->prev, typeof(*pos), member),  \
    n =list_entry(pos->member.prev, typeof(*pos), member); \
      &pos->member != (head);         \
       pos = n,n = list_entry(n->member.prev, typeof(*n), member))

41、list_safe_reset_next【获取n结构体指针】

#define list_safe_reset_next(pos, n, member)        \
  n =list_entry(pos->member.next, typeof(*pos), member)

// hash链表头
struct hlist_head
{
  structh list_node *first;
};
 
struct hlist_node
{
  struct hlist_node *next, **pprev;
};

1、INIT_HLIST_HEAD【初始化头节点指针ptr】

#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)

2、INIT_HLIST_NODE【初始化hlist节点】

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

3、hlist_unhashed【判断h->pprev是否为空，是返回1，否返回0】

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

4、hlist_empty【判断hlist是否为空，是返回1，否返回0】

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

5、__hlist_del【删除结点n】

static __INLINE__ void __hlist_del(struct hlist_node*n)
{
  struct hlist_node *next = n->next;
  struct hlist_node **pprev = n->pprev;
  *pprev = next;
  if (next)
  {
   next->pprev = pprev;
  }
}

6、hlist_del【删除结点n，将结点next、pprev分别指向LIST_POISON1、LIST_POISON2。这样设置是为了保证不在链表中的结点项不能被访问】

static __INLINE__ void hlist_del(struct hlist_node *n)
{
 __hlist_del(n);
  n->next =LIST_POISON1;
  n->pprev =LIST_POISON2;
}

7、hlist_del_init【先判断结点是否为空，不为空删除，再初始化节点】

static __INLINE__ void hlist_del_init(struct hlist_node *n)
{
  if(!hlist_unhashed(n))
  {
   __hlist_del(n);
   INIT_HLIST_NODE(n);
  }
}

8、hlist_add_head【增加结点n到h表头】

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;
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

9、hlist_add_before【增加结点n到结点next之前】

/* next must be != NULL */
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;
}

10、hlist_add_after【增加结点n到结点next之后】

static __INLINE__ void hlist_add_after(struct hlist_node *n,
                                       struct hlist_node *next)
{
  next->next= n->next;
  n->next =next;
  next->pprev= &n->next;
 
 if(next->next)
  {
   next->next->pprev  =&next->next;
  }
}

11、hlist_move_list【头结点new接管头结点old的所有节点，并初始化old】

static __INLINE__ void hlist_move_list(struct hlist_head *old,
                                       struct hlist_head *new)
{
  new->first= old->first;
  if(new->first)
  {
   new->first->pprev = &new->first;
  }
  old->first= NULL;
}

12、hlist_entry【已知某一个成员变量的名字、指针和结构体类型的情况下，计算结构体的指针，也就是计算结构体的起始地址】

#define hlist_entry(ptr, type, member) container_of(ptr,type,member)

13、hlist_for_each【遍历hlist链表】

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

14、 hlist_for_each_safe【遍历hlist链表，一般在删除结点使用】

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

15、hlist_for_each_entry【遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry(tpos, pos, head,member)      \
  for (pos =(head)->first;          \
       pos&& ({ prefetch(pos->next); 1;}) &&      \
    ({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \
       pos =pos->next)

16、hlist_for_each_entry_continue【从结点pos下一个遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry_continue(tpos, pos,member)     \
  for (pos =(pos)->next;            \
       pos&& ({ prefetch(pos->next); 1;}) &&      \
    ({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \
       pos =pos->next)

17、hlist_for_each_entry_from【从节点pos开始遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry_from(tpos, pos,member)       \
  for (; pos&& ({ prefetch(pos->next); 1;}) &&      \
    ({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \
       pos =pos->next)

18、hlist_for_each_entry_safe【从头节点head开始遍历找typeof(*tpos)的结构体类型入口地址】

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

a1314521531

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
内核链表list.h文件剖析

内核链表list.h文件剖析一、内核链表的结构【双向循环链表】内核链表的好主要体现为两点，1是可扩展性，2是封装。可以将内核链表复用到用户态编程中，以后在用户态下编程就不需要写一些关于链表的代码了，直接将内核中list.h中的代码拷贝过来用。struct list_head{ struct list_head *next, *prev;}; // 包含了两个指向list
复制链接

扫一扫