详解Linux内核双向循环链表算法的实现（下）

最新推荐文章于 2022-10-30 19:10:07 发布

安瑾随风

最新推荐文章于 2022-10-30 19:10:07 发布

阅读量640

点赞数

分类专栏： Linux 内核文章标签： linux内核算法 list each 存储

本文链接：https://blog.csdn.net/ydt_lwj/article/details/7765815

版权

Linux 内核专栏收录该内容

9 篇文章 0 订阅

订阅专栏

2、双向链表在Linux内核中的实现

Linux内核对双向循环链表的设计非常巧妙，链表的所有运算都基于只有两个指针域的list_head结构体来进行。

/* linux-2.6.38.8/include/linux/types.h */  
struct list_head {  
    struct list_head *next, *prev;  
};

链表的运算（源代码都在linux-2.6.38.8/include/linux/list.h文件中定义，并且假定CONFIG_DEBUG_LIST未定义）：

（1）、链表头结点的创建

2.1.1 静态创建

#define LIST_HEAD_INIT(name) { &(name), &(name) }  
  
#define LIST_HEAD(name) \  
    struct list_head name = LIST_HEAD_INIT(name)

通过LIST_HEAD宏创建一个list_head结构体变量name，并把name的所有成员（next和prev）都初始化为name的首地址。

2.1.2 动态创建

static inline void INIT_LIST_HEAD(struct list_head *list)

  { 

     list->next = list; 

     list->prev = list; 

 }

把list_head结构体变量的首地址传递给INIT_LIST_HEAD函数来对其成员进行初始化。

（2）、结点的添加

list_add函数是把新结点new添加到head结点的后面，而list_add_tail函数是把新结点new插入到结点head的前面。

函数源代码如下：

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

图示如下：

（3）、结点的删除

list_del函数的作用是将结点*entry从链表中移走，并把此结点的两个成员分别初始化为LIST_POISON1和LIST_POISON2。注意，这里的*entry结点所占用的内存并没有被释放。

list_del_init函数的作用也是将结点*entry从链表中移走，但它把此结点的两个成员初始化为entry。

static inline void __list_del(struct list_head * prev, struct list_head * next)

 { 

     next->prev = prev; 

     prev->next = next;

  }

  static inline void __list_del_entry(struct list_head *entry) 

 { 

     __list_del(entry->prev, entry->next); 

 } 

 static inline void list_del(struct list_head *entry) 

 { 

     __list_del(entry->prev, entry->next); 

     entry->next = LIST_POISON1; 

     entry->prev = LIST_POISON2; 

 } 

 static inline void list_del_init(struct list_head *entry) 

 { 

     __list_del_entry(entry); 

    INIT_LIST_HEAD(entry); 

 }

LIST_POISON1和LIST_POISON2的值定义在linux-2.6.38.8/include/linux/poison.h文件中：

  #define LIST_POISON1 ((void *) 0x00100100 + POISON_POINTER_DELTA) 

 #define LIST_POISON2 ((void *) 0x00200200 + POISON_POINTER_DELTA)

其中POISON_POINTER_DELTA的值在CONFIG_ILLEGAL_POINTER_VALUE未配置时为0。

（4）、结点的替换

list_replace函数的作用是用结点*new替换掉结点*old，list_replace_init函数的作用与list_replace相同，除了它还会把*old结点的两个成员初始化为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; 

 } 

 static inline void list_replace_init(struct list_head *old, 

                     struct list_head *new) 

 { 

     list_replace(old, new); 

     INIT_LIST_HEAD(old); 

 }

（5）、结点的移动

list_move函数的作用是把*list结点从它所在的链表中移除，然后把它添加到*head结点的后面。list_move_tail函数的作用与list_move相同，但它把*list插入到*head结点的前面。

static inline void list_move(struct list_head *list, struct list_head *head) 


{ 

      __list_del_entry(list); 

      list_add(list, head); 

  } 

  static inline void list_move_tail(struct list_head *list, 

                    struct list_head *head) 

  {

      __list_del_entry(list); 

      list_add_tail(list, head); 

  }

（6）、判断*list是否是链表head的最后一个结点，是则返回1，否则返回0

 static inline int list_is_last(const struct list_head *list,  

                const struct list_head *head)  

{  

   return list->next == head;  

}

（7）、判断head是否为空表，是则返回1，否则返回0

static inline int list_empty(const struct list_head *head) 

  { 

      return head->next == head; 

  } 

  static inline int list_empty_careful(const struct list_head *head) 

  { 

      struct list_head *next = head->next; 

     return (next == head) && (next == head->prev); 

  }

（8）、翻转链表

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

     } 

  }

（9）、判断链表是否只有一个结点，是则返回1，否则返回0

static inline int list_is_singular(const struct list_head *head) 

  { 

      return !list_empty(head) && (head->next == head->prev); 

  }

（10）、切割链表

list_cut_position函数的功能是将链表head从头结点head（不包含）开始到entry（包含，并且它是链表head中的结点）结点结束之间的所有结点都切割下来，并添加到list上，以组成一个新的链表list。原来的head链表将组成一个新的小链表。

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; 

  } 

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

  }

（11）、合并链表

list_splice函数的作用是将链表list（不包含结点*list）插入到链表head的head结点后，而list_splice_tail函数的作用是将链表list（不包含结点*list）插入到链表head的head结点前。

list_splice_init和list_splice_tail_init函数的作用与其相应的函数相同，除了它们都初始化*list结点为list。

 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; 

  } 

  static inline void list_splice(const struct list_head *list, 

                  struct list_head *head) 

  { 

      if (!list_empty(list)) 

          __list_splice(list, head, head->next); 

  } 

  static inline void list_splice_tail(struct list_head *list, 

                  struct list_head *head) 

  { 

      if (!list_empty(list)) 

          __list_splice(list, head->prev, head); 

  } 

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

      } 

  } 

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

      } 

  }

（12）、通过成员指针获得整个结构体的指针

链表操作如果仅仅针对list_head结构体就没有什么意义，所以必须要获得包含它的整个结构体的地址。它们只是对container_of宏的封装，关于container_of宏的使用方法请参考http://blog.csdn.net/npy_lp/article/details/7010752。

   #define list_entry(ptr, type, member) \ 

      container_of(ptr, type, member) 

  #define list_first_entry(ptr, type, member) \ 

      list_entry((ptr)->next, type, member)

（13）、遍历链表

list_for_each函数是根据list_head的next成员来遍历整个链表，而list_for_each_prev函数是根据prev成员。其中参数head一般是链表的头结点。

  #define list_for_each(pos, head) \ 

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

              pos = pos->next) 

  #define __list_for_each(pos, head) \ 

      for (pos = (head)->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)

list_for_each_safe和list_for_each_prev_safe函数使用list_head结构体变量n作为临时存储变量。

#define list_for_each_safe(pos, n, head) \ 

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

          pos = n, n = pos->next) 

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

list_for_each_entry和list_for_each_entry_reverse函数的作用是根据head的下一个或前一个结点来遍历整个head链表，并返回包含list_head结构体成员的大结构体指针，member是list_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)) 

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

list_for_each_entry_continue和list_for_each_entry_continue_reverse函数是以pos的下一个或前一个结点开始遍历链表head。

#define list_prepare_entry(pos, head, member) \ 

      ((pos) ? : list_entry(head, typeof(*pos), member)) 

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

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

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

list_for_each_entry_safe、list_for_each_entry_safe_continue、list_for_each_entry_safe_from和list_for_each_entry_safe_reverse这四个函数中的n参数与pos的数据类型相同，其他功能与它们相应的函数是相同的。

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

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

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

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

list_safe_reset_next函数的作用是根据结点pos获得n。

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

安瑾随风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录