1 #ifndef _LIST_H 2 #define _LIST_H 3 4 /* Stripped down implementation of linked list taken 5 * from the Linux Kernel. 6 */ 7 8 /* 9 * Simple doubly linked list implementation. 10 * 11 * Some of the internal functions ("__xxx") are useful when 12 * manipulating whole lists rather than single entries, as 13 * sometimes we already know the next/prev entries and we can 14 * generate better code by using them directly rather than 15 * using the generic single-entry routines. 16 */ 17 18 struct list_head { 19 struct list_head *next, *prev; 20 }; 21 22 #define LIST_HEAD_INIT(name) { &(name), &(name) } 23 24 #define LIST_HEAD(name) \ 25 struct list_head name = LIST_HEAD_INIT(name) 26 27 static inline void INIT_LIST_HEAD(struct list_head *list) 28 { 29 list->next = list; 30 list->prev = list; 31 } 32 33 /* 34 * Insert a new entry between two known consecutive entries. 35 * 36 * This is only for internal list manipulation where we know 37 * the prev/next entries already! 38 */ 39 static inline void __list_add(struct list_head *new, 40 struct list_head *prev, 41 struct list_head *next) 42 { 43 next->prev = new; 44 new->next = next; 45 new->prev = prev; 46 prev->next = new; 47 } 48 49 /** 50 * list_add - add a new entry 51 * @new: new entry to be added 52 * @head: list head to add it after 53 * 54 * Insert a new entry after the specified head. 55 * This is good for implementing stacks. 56 */ 57 static inline void list_add(struct list_head *new, struct list_head *head) 58 { 59 __list_add(new, head, head->next); 60 } 61 62 /* 63 * Delete a list entry by making the prev/next entries 64 * point to each other. 65 * 66 * This is only for internal list manipulation where we know 67 * the prev/next entries already! 68 */ 69 static inline void __list_del(struct list_head * prev, struct list_head * next) 70 { 71 next->prev = prev; 72 prev->next = next; 73 } 74 75 #define POISON_POINTER_DELTA 0 76 #define LIST_POISON1 ((void *) 0x00100100 + POISON_POINTER_DELTA) 77 #define LIST_POISON2 ((void *) 0x00200200 + POISON_POINTER_DELTA) 78 79 /** 80 * list_del - deletes entry from list. 81 * @entry: the element to delete from the list. 82 * Note: list_empty() on entry does not return true after this, the entry is 83 * in an undefined state. 84 */ 85 static inline void __list_del_entry(struct list_head *entry) 86 { 87 __list_del(entry->prev, entry->next); 88 } 89 90 static inline void list_del(struct list_head *entry) 91 { 92 __list_del(entry->prev, entry->next); 93 entry->next = LIST_POISON1; 94 entry->prev = LIST_POISON2; 95 } 96 97 /** 98 * list_entry - get the struct for this entry 99 * @ptr: the &struct list_head pointer. 100 * @type: the type of the struct this is embedded in. 101 * @member: the name of the list_head within the struct. 102 */ 103 #define list_entry(ptr, type, member) \ 104 container_of(ptr, type, member) 105 /** 106 * list_for_each - iterate over a list 107 * @pos: the &struct list_head to use as a loop cursor. 108 * @head: the head for your list. 109 */ 110 #define list_for_each(pos, head) \ 111 for (pos = (head)->next; pos != (head); pos = pos->next) 112 113 /** 114 * list_for_each_safe - iterate over a list safe against removal of list entry 115 * @pos: the &struct list_head to use as a loop cursor. 116 * @n: another &struct list_head to use as temporary storage 117 * @head: the head for your list. 118 */ 119 #define list_for_each_safe(pos, n, head) \ 120 for (pos = (head)->next, n = pos->next; pos != (head); \ 121 pos = n, n = pos->next) 122 123 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) 124 125 /** 126 * container_of - cast a member of a structure out to the containing structure 127 * @ptr: the pointer to the member. 128 * @type: the type of the container struct this is embedded in. 129 * @member: the name of the member within the struct. 130 * 131 */ 132 #define container_of(ptr, type, member) ({ \ 133 const typeof( ((type *)0)->member ) *__mptr = (ptr); \ 134 (type *)( (char *)__mptr - offsetof(type,member) );}) 135 136 #endif 137