内核中的list

转：http://www.cnblogs.com/westfly/archive/2011/04/07/2007549.html

学习链表的实现，还是觉得linux下的显得不错。

今天爬取了份可以用在linux下的代码。不必要重复造轮子了。对于这份代码的详细说明，请参考 《Linux Kernel Linked List Explained》

如下代码的获取路径

http://isis.poly.edu/kulesh/stuff/src/klist/list.h

list.h

  1 #ifndef __LIST_H
  2 #define __LIST_H  3   4 /* This file is from Linux Kernel (include/linux/list.h)
  5 * and modified by simply removing hardware prefetching of list items.
  6 * Here by copyright, credits attributed to wherever they belong.
  7 * Kulesh Shanmugasundaram (kulesh [squiggly] isis.poly.edu)
  8 */  9  10 /* 11 * Simple doubly linked list implementation.
 12 *
 13 * Some of the internal functions (“__xxx”) are useful when
 14 * manipulating whole lists rather than single entries, as
 15 * sometimes we already know the next/prev entries and we can
 16 * generate better code by using them directly rather than
 17 * using the generic single-entry routines.
 18 */ 19  20 struct list_head {
 21     struct list_head *next, *prev;
 22 };
 23  24 #define LIST_HEAD_INIT(name) { &(name), &(name) } 25  26 #define LIST_HEAD(name) \ 27 struct list_head name = LIST_HEAD_INIT(name)
 28  29 static inline void INIT_LIST_HEAD(struct list_head *list)
 30 {
 31     list->next = list;
 32     list->prev = list;
 33 }
 34 /* 35 * Insert a new entry between two known consecutive entries.
 36 *
 37 * This is only for internal list manipulation where we know
 38 * the prev/next entries already!
 39 */ 40 static inline void __list_add(struct list_head *new,
 41                               struct list_head *prev,
 42                               struct list_head *next)
 43 {
 44     next->prev = new;
 45     new->next = next;
 46     new->prev = prev;
 47     prev->next = new;
 48 }
 49  50 /**
 51 * list_add – add a new entry
 52 * @new: new entry to be added
 53 * @head: list head to add it after
 54 *
 55 * Insert a new entry after the specified head.
 56 * This is good for implementing stacks.
 57 */ 58 static inline void list_add(struct list_head *new, struct list_head *head)
 59 {
 60     __list_add(new, head, head->next);
 61 }
 62  63 /**
 64 * list_add_tail – add a new entry
 65 * @new: new entry to be added
 66 * @head: list head to add it before
 67 *
 68 * Insert a new entry before the specified head.
 69 * This is useful for implementing queues.
 70 */ 71 static inline void list_add_tail(struct list_head *new, struct list_head *head)
 72 {
 73     __list_add(new, head->prev, head);
 74 }
 75  76 /* 77 * Delete a list entry by making the prev/next entries
 78 * point to each other.
 79 *
 80 * This is only for internal list manipulation where we know
 81 * the prev/next entries already!
 82 */ 83 static inline void __list_del(struct list_head *prev, struct list_head *next)
 84 {
 85     next->prev = prev;
 86     prev->next = next;
 87 }
 88  89 /**
 90 * list_del – deletes entry from list.
 91 * @entry: the element to delete from the list.
 92 * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
 93 */ 94 static inline void list_del(struct list_head *entry)
 95 {
 96     __list_del(entry->prev, entry->next);
 97     entry->next = (void *) 0;
 98     entry->prev = (void *) 0;
 99 }
100 101 /**
102 * list_del_init – deletes entry from list and reinitialize it.
103 * @entry: the element to delete from the list.
104 */105 static inline void list_del_init(struct list_head *entry)
106 {
107     __list_del(entry->prev, entry->next);
108     INIT_LIST_HEAD(entry);
109 }
110 111 /**
112 * list_move – delete from one list and add as another’s head
113 * @list: the entry to move
114 * @head: the head that will precede our entry
115 */116 static inline void list_move(struct list_head *list, struct list_head *head)
117 {
118     __list_del(list->prev, list->next);
119     list_add(list, head);
120 }
121 122 /**
123 * list_move_tail – delete from one list and add as another’s tail
124 * @list: the entry to move
125 * @head: the head that will follow our entry
126 */127 static inline void list_move_tail(struct list_head *list,
128 struct list_head *head)
129 {
130     __list_del(list->prev, list->next);
131     list_add_tail(list, head);
132 }
133 134 /**
135 * list_empty – tests whether a list is empty
136 * @head: the list to test.
137 */138 static inline int list_empty(struct list_head *head)
139 {
140     return head->next == head;
141 }
142 143 static inline void __list_splice(struct list_head *list,
144 struct list_head *head)
145 {
146     struct list_head *first = list->next;
147     struct list_head *last = list->prev;
148     struct list_head *at = head->next;
149 150     first->prev = head;
151     head->next = first;
152 153     last->next = at;
154     at->prev = last;
155 }
156 157 /**
158 * list_splice – join two lists
159 * @list: the new list to add.
160 * @head: the place to add it in the first list.
161 */162 static inline void list_splice(struct list_head *list, struct list_head *head)
163 {
164     if (!list_empty(list))
165         __list_splice(list, head);
166 }
167 168 /**
169 * list_splice_init – join two lists and reinitialise the emptied list.
170 * @list: the new list to add.
171 * @head: the place to add it in the first list.
172 *
173 * The list at @list is reinitialised
174 */175 static inline void list_splice_init(struct list_head *list,
176                                     struct list_head *head)
177 {
178     if (!list_empty(list)) {
179         __list_splice(list, head);
180         INIT_LIST_HEAD(list);
181     }
182 }
183 184 /**
185 * list_entry – get the struct for this entry
186 * @ptr:    the &struct list_head pointer.
187 * @type:    the type of the struct this is embedded in.
188 * @member:    the name of the list_struct within the struct.
189 */190 #define list_entry(ptr, type, member) \191     ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
192 193 /**
194 * list_for_each    -    iterate over a list
195 * @pos:    the &struct list_head to use as a loop counter.
196 * @head:    the head for your list.
197 */198 #define list_for_each(pos, head) \199     for (pos = (head)->next; pos != (head); \
200         pos = pos->next)
201 /**
202 * list_for_each_prev    -    iterate over a list backwards
203 * @pos:    the &struct list_head to use as a loop counter.
204 * @head:    the head for your list.
205 */206 #define list_for_each_prev(pos, head) \207     for (pos = (head)->prev; pos != (head); \
208         pos = pos->prev)
209 210 /**
211 * list_for_each_safe    -    iterate over a list safe against removal of list entry
212 * @pos:    the &struct list_head to use as a loop counter.
213 * @n:        another &struct list_head to use as temporary storage
214 * @head:    the head for your list.
215 */216 #define list_for_each_safe(pos, n, head) \217     for (pos = (head)->next, n = pos->next; pos != (head);\
218         pos = n, n = pos->next)
219 220 221 /**
222 * list_for_each_entry    -    iterate over list of given type
223 * @pos:    the type * to use as a loop counter.
224 * @head:    the head for your list.
225 * @member:    the name of the list_struct within the struct.
226 */227 #define list_for_each_entry(pos, head, member)                \228     for (pos = list_entry((head)->next,typeof(*pos), member); \
229         &pos->member != (head);                                  \
230             pos = list_entry(pos->member.next, typeof(*pos), member))
231 232 /**
233 * list_for_each_entry_safe – iterate over list of given type safe against removal of list entry
234 * @pos:    the type * to use as a loop counter.
235 * @n:        another type * to use as temporary storage
236 * @head:    the head for your list.
237 * @member:    the name of the list_struct within the struct.
238 */239 #define list_for_each_entry_safe(pos, n, head, member)            \240 for (pos = list_entry((head)->next, typeof(*pos), member),    \
241     n = list_entry(pos->member.next, typeof(*pos), member);    \
242         &pos->member != (head);                     \
243             pos = n, n = list_entry(n->member.next, typeof(*n), member))
244 245 #endif

下面代码是给出的测试用例（也可以作为其函数的用法示例哦）

其可以从http://isis.poly.edu/kulesh/stuff/src/klist/test_list.c 下载

mylist.c

  1 #include <stdio.h>  2 #include <stdlib.h>  3   4 #include "list.h"  5   6   7 struct kool_list{
  8     int to;
  9     struct list_head list;
 10     int from;
 11     };
 12  13 int main(int argc, char **argv){
 14  15     struct kool_list *tmp;
 16     struct list_head *pos, *q;
 17     unsigned int i;
 18  19     struct kool_list mylist;
 20     INIT_LIST_HEAD(&mylist.list);
 21     /* or you could have declared this with the following macro
 22      * LIST_HEAD(mylist); which declares and initializes the list
 23      */ 24  25     /* adding elements to mylist */ 26     for(i=5; i!=0; --i){
 27         tmp= (struct kool_list *)malloc(sizeof(struct kool_list));
 28         
 29         /* INIT_LIST_HEAD(&tmp->list); 
 30          *
 31          * this initializes a dynamically allocated list_head. we
 32          * you can omit this if subsequent call is add_list() or 
 33          * anything along that line because the next, prev
 34          * fields get initialized in those functions.
 35          */ 36         printf("enter to and from:");
 37         scanf("%d %d", &tmp->to, &tmp->from);
 38  39         /* add the new item 'tmp' to the list of items in mylist */ 40         list_add(&(tmp->list), &(mylist.list));
 41         /* you can also use list_add_tail() which adds new items to
 42          * the tail end of the list
 43          */ 44     }
 45     printf("\n");
 46  47  48     /* now you have a circularly linked list of items of type struct kool_list.
 49      * now let us go through the items and print them out
 50      */ 51  52  53     /* list_for_each() is a macro for a for loop. 
 54      * first parameter is used as the counter in for loop. in other words, inside the
 55      * loop it points to the current item's list_head.
 56      * second parameter is the pointer to the list. it is not manipulated by the macro.
 57      */ 58     printf("traversing the list using list_for_each()\n");
 59     list_for_each(pos, &mylist.list){
 60  61         /* at this point: pos->next points to the next item's 'list' variable and 
 62          * pos->prev points to the previous item's 'list' variable. Here item is 
 63          * of type struct kool_list. But we need to access the item itself not the 
 64          * variable 'list' in the item! macro list_entry() does just that. See "How
 65          * does this work?" below for an explanation of how this is done.
 66          */ 67          tmp= list_entry(pos, struct kool_list, list);
 68  69          /* given a pointer to struct list_head, type of data structure it is part of,
 70           * and it's name (struct list_head's name in the data structure) it returns a
 71           * pointer to the data structure in which the pointer is part of.
 72           * For example, in the above line list_entry() will return a pointer to the
 73           * struct kool_list item it is embedded in!
 74           */ 75  76          printf("to= %d from= %d\n", tmp->to, tmp->from);
 77  78     }
 79     printf("\n");
 80     /* since this is a circularly linked list. you can traverse the list in reverse order
 81      * as well. all you need to do is replace 'list_for_each' with 'list_for_each_prev'
 82      * everything else remain the same!
 83      *
 84      * Also you can traverse the list using list_for_each_entry() to iterate over a given
 85      * type of entries. For example:
 86      */ 87     printf("traversing the list using list_for_each_entry()\n");
 88     list_for_each_entry(tmp, &mylist.list, list){
 89          printf("to= %d from= %d\n", tmp->to, tmp->from);
 90     }
 91     list_for_each_entry(tmp,&mylist.list,list){
 92         if(tmp->to == 2)
 93             break;
 94     }
 95     printf("to = %d from %d\n",tmp->to,tmp->from);
 96     printf("\n");
 97     
 98  99     /* now let's be good and free the kool_list items. since we will be removing items
100      * off the list using list_del() we need to use a safer version of the list_for_each() 
101      * macro aptly named list_for_each_safe(). Note that you MUST use this macro if the loop 
102      * involves deletions of items (or moving items from one list to another).
103      */104     printf("deleting the list using list_for_each_safe()\n");
105     list_for_each_safe(pos, q, &mylist.list){
106          tmp= list_entry(pos, struct kool_list, list);
107          printf("freeing item to= %d from= %d\n", tmp->to, tmp->from);
108          list_del(pos);
109          free(tmp);
110     }
111 112     return 0;
113 }