Home | History | Annotate | Download | only in linux
      1 #ifndef _LINUX_LIST_H
      2 #define _LINUX_LIST_H
      3 
      4 #include <linux/types.h>
      5 #include <linux/stddef.h>
      6 #include <linux/poison.h>
      7 #include <linux/const.h>
      8 
      9 /*
     10  * Simple doubly linked list implementation.
     11  *
     12  * Some of the internal functions ("__xxx") are useful when
     13  * manipulating whole lists rather than single entries, as
     14  * sometimes we already know the next/prev entries and we can
     15  * generate better code by using them directly rather than
     16  * using the generic single-entry routines.
     17  */
     18 
     19 #define LIST_HEAD_INIT(name) { &(name), &(name) }
     20 
     21 #define LIST_HEAD(name) \
     22 	struct list_head name = LIST_HEAD_INIT(name)
     23 
     24 static inline void INIT_LIST_HEAD(struct list_head *list)
     25 {
     26 	list->next = list;
     27 	list->prev = list;
     28 }
     29 
     30 /*
     31  * Insert a new entry between two known consecutive entries.
     32  *
     33  * This is only for internal list manipulation where we know
     34  * the prev/next entries already!
     35  */
     36 #ifndef CONFIG_DEBUG_LIST
     37 static inline void __list_add(struct list_head *new,
     38 			      struct list_head *prev,
     39 			      struct list_head *next)
     40 {
     41 	next->prev = new;
     42 	new->next = next;
     43 	new->prev = prev;
     44 	prev->next = new;
     45 }
     46 #else
     47 extern void __list_add(struct list_head *new,
     48 			      struct list_head *prev,
     49 			      struct list_head *next);
     50 #endif
     51 
     52 /**
     53  * list_add - add a new entry
     54  * @new: new entry to be added
     55  * @head: list head to add it after
     56  *
     57  * Insert a new entry after the specified head.
     58  * This is good for implementing stacks.
     59  */
     60 static inline void list_add(struct list_head *new, struct list_head *head)
     61 {
     62 	__list_add(new, head, head->next);
     63 }
     64 
     65 
     66 /**
     67  * list_add_tail - add a new entry
     68  * @new: new entry to be added
     69  * @head: list head to add it before
     70  *
     71  * Insert a new entry before the specified head.
     72  * This is useful for implementing queues.
     73  */
     74 static inline void list_add_tail(struct list_head *new, struct list_head *head)
     75 {
     76 	__list_add(new, head->prev, head);
     77 }
     78 
     79 /*
     80  * Delete a list entry by making the prev/next entries
     81  * point to each other.
     82  *
     83  * This is only for internal list manipulation where we know
     84  * the prev/next entries already!
     85  */
     86 static inline void __list_del(struct list_head * prev, struct list_head * next)
     87 {
     88 	next->prev = prev;
     89 	prev->next = next;
     90 }
     91 
     92 /**
     93  * list_del - deletes entry from list.
     94  * @entry: the element to delete from the list.
     95  * Note: list_empty() on entry does not return true after this, the entry is
     96  * in an undefined state.
     97  */
     98 #ifndef CONFIG_DEBUG_LIST
     99 static inline void __list_del_entry(struct list_head *entry)
    100 {
    101 	__list_del(entry->prev, entry->next);
    102 }
    103 
    104 static inline void list_del(struct list_head *entry)
    105 {
    106 	__list_del(entry->prev, entry->next);
    107 	entry->next = LIST_POISON1;
    108 	entry->prev = LIST_POISON2;
    109 }
    110 #else
    111 extern void __list_del_entry(struct list_head *entry);
    112 extern void list_del(struct list_head *entry);
    113 #endif
    114 
    115 /**
    116  * list_replace - replace old entry by new one
    117  * @old : the element to be replaced
    118  * @new : the new element to insert
    119  *
    120  * If @old was empty, it will be overwritten.
    121  */
    122 static inline void list_replace(struct list_head *old,
    123 				struct list_head *new)
    124 {
    125 	new->next = old->next;
    126 	new->next->prev = new;
    127 	new->prev = old->prev;
    128 	new->prev->next = new;
    129 }
    130 
    131 static inline void list_replace_init(struct list_head *old,
    132 					struct list_head *new)
    133 {
    134 	list_replace(old, new);
    135 	INIT_LIST_HEAD(old);
    136 }
    137 
    138 /**
    139  * list_del_init - deletes entry from list and reinitialize it.
    140  * @entry: the element to delete from the list.
    141  */
    142 static inline void list_del_init(struct list_head *entry)
    143 {
    144 	__list_del_entry(entry);
    145 	INIT_LIST_HEAD(entry);
    146 }
    147 
    148 /**
    149  * list_move - delete from one list and add as another's head
    150  * @list: the entry to move
    151  * @head: the head that will precede our entry
    152  */
    153 static inline void list_move(struct list_head *list, struct list_head *head)
    154 {
    155 	__list_del_entry(list);
    156 	list_add(list, head);
    157 }
    158 
    159 /**
    160  * list_move_tail - delete from one list and add as another's tail
    161  * @list: the entry to move
    162  * @head: the head that will follow our entry
    163  */
    164 static inline void list_move_tail(struct list_head *list,
    165 				  struct list_head *head)
    166 {
    167 	__list_del_entry(list);
    168 	list_add_tail(list, head);
    169 }
    170 
    171 /**
    172  * list_is_last - tests whether @list is the last entry in list @head
    173  * @list: the entry to test
    174  * @head: the head of the list
    175  */
    176 static inline int list_is_last(const struct list_head *list,
    177 				const struct list_head *head)
    178 {
    179 	return list->next == head;
    180 }
    181 
    182 /**
    183  * list_empty - tests whether a list is empty
    184  * @head: the list to test.
    185  */
    186 static inline int list_empty(const struct list_head *head)
    187 {
    188 	return head->next == head;
    189 }
    190 
    191 /**
    192  * list_empty_careful - tests whether a list is empty and not being modified
    193  * @head: the list to test
    194  *
    195  * Description:
    196  * tests whether a list is empty _and_ checks that no other CPU might be
    197  * in the process of modifying either member (next or prev)
    198  *
    199  * NOTE: using list_empty_careful() without synchronization
    200  * can only be safe if the only activity that can happen
    201  * to the list entry is list_del_init(). Eg. it cannot be used
    202  * if another CPU could re-list_add() it.
    203  */
    204 static inline int list_empty_careful(const struct list_head *head)
    205 {
    206 	struct list_head *next = head->next;
    207 	return (next == head) && (next == head->prev);
    208 }
    209 
    210 /**
    211  * list_rotate_left - rotate the list to the left
    212  * @head: the head of the list
    213  */
    214 static inline void list_rotate_left(struct list_head *head)
    215 {
    216 	struct list_head *first;
    217 
    218 	if (!list_empty(head)) {
    219 		first = head->next;
    220 		list_move_tail(first, head);
    221 	}
    222 }
    223 
    224 /**
    225  * list_is_singular - tests whether a list has just one entry.
    226  * @head: the list to test.
    227  */
    228 static inline int list_is_singular(const struct list_head *head)
    229 {
    230 	return !list_empty(head) && (head->next == head->prev);
    231 }
    232 
    233 static inline void __list_cut_position(struct list_head *list,
    234 		struct list_head *head, struct list_head *entry)
    235 {
    236 	struct list_head *new_first = entry->next;
    237 	list->next = head->next;
    238 	list->next->prev = list;
    239 	list->prev = entry;
    240 	entry->next = list;
    241 	head->next = new_first;
    242 	new_first->prev = head;
    243 }
    244 
    245 /**
    246  * list_cut_position - cut a list into two
    247  * @list: a new list to add all removed entries
    248  * @head: a list with entries
    249  * @entry: an entry within head, could be the head itself
    250  *	and if so we won't cut the list
    251  *
    252  * This helper moves the initial part of @head, up to and
    253  * including @entry, from @head to @list. You should
    254  * pass on @entry an element you know is on @head. @list
    255  * should be an empty list or a list you do not care about
    256  * losing its data.
    257  *
    258  */
    259 static inline void list_cut_position(struct list_head *list,
    260 		struct list_head *head, struct list_head *entry)
    261 {
    262 	if (list_empty(head))
    263 		return;
    264 	if (list_is_singular(head) &&
    265 		(head->next != entry && head != entry))
    266 		return;
    267 	if (entry == head)
    268 		INIT_LIST_HEAD(list);
    269 	else
    270 		__list_cut_position(list, head, entry);
    271 }
    272 
    273 static inline void __list_splice(const struct list_head *list,
    274 				 struct list_head *prev,
    275 				 struct list_head *next)
    276 {
    277 	struct list_head *first = list->next;
    278 	struct list_head *last = list->prev;
    279 
    280 	first->prev = prev;
    281 	prev->next = first;
    282 
    283 	last->next = next;
    284 	next->prev = last;
    285 }
    286 
    287 /**
    288  * list_splice - join two lists, this is designed for stacks
    289  * @list: the new list to add.
    290  * @head: the place to add it in the first list.
    291  */
    292 static inline void list_splice(const struct list_head *list,
    293 				struct list_head *head)
    294 {
    295 	if (!list_empty(list))
    296 		__list_splice(list, head, head->next);
    297 }
    298 
    299 /**
    300  * list_splice_tail - join two lists, each list being a queue
    301  * @list: the new list to add.
    302  * @head: the place to add it in the first list.
    303  */
    304 static inline void list_splice_tail(struct list_head *list,
    305 				struct list_head *head)
    306 {
    307 	if (!list_empty(list))
    308 		__list_splice(list, head->prev, head);
    309 }
    310 
    311 /**
    312  * list_splice_init - join two lists and reinitialise the emptied list.
    313  * @list: the new list to add.
    314  * @head: the place to add it in the first list.
    315  *
    316  * The list at @list is reinitialised
    317  */
    318 static inline void list_splice_init(struct list_head *list,
    319 				    struct list_head *head)
    320 {
    321 	if (!list_empty(list)) {
    322 		__list_splice(list, head, head->next);
    323 		INIT_LIST_HEAD(list);
    324 	}
    325 }
    326 
    327 /**
    328  * list_splice_tail_init - join two lists and reinitialise the emptied list
    329  * @list: the new list to add.
    330  * @head: the place to add it in the first list.
    331  *
    332  * Each of the lists is a queue.
    333  * The list at @list is reinitialised
    334  */
    335 static inline void list_splice_tail_init(struct list_head *list,
    336 					 struct list_head *head)
    337 {
    338 	if (!list_empty(list)) {
    339 		__list_splice(list, head->prev, head);
    340 		INIT_LIST_HEAD(list);
    341 	}
    342 }
    343 
    344 /**
    345  * list_entry - get the struct for this entry
    346  * @ptr:	the &struct list_head pointer.
    347  * @type:	the type of the struct this is embedded in.
    348  * @member:	the name of the list_struct within the struct.
    349  */
    350 #define list_entry(ptr, type, member) \
    351 	container_of(ptr, type, member)
    352 
    353 /**
    354  * list_first_entry - get the first element from a list
    355  * @ptr:	the list head to take the element from.
    356  * @type:	the type of the struct this is embedded in.
    357  * @member:	the name of the list_struct within the struct.
    358  *
    359  * Note, that list is expected to be not empty.
    360  */
    361 #define list_first_entry(ptr, type, member) \
    362 	list_entry((ptr)->next, type, member)
    363 
    364 /**
    365  * list_first_entry_or_null - get the first element from a list
    366  * @ptr:	the list head to take the element from.
    367  * @type:	the type of the struct this is embedded in.
    368  * @member:	the name of the list_struct within the struct.
    369  *
    370  * Note that if the list is empty, it returns NULL.
    371  */
    372 #define list_first_entry_or_null(ptr, type, member) \
    373 	(!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL)
    374 
    375 /**
    376  * list_for_each	-	iterate over a list
    377  * @pos:	the &struct list_head to use as a loop cursor.
    378  * @head:	the head for your list.
    379  */
    380 #define list_for_each(pos, head) \
    381 	for (pos = (head)->next; pos != (head); pos = pos->next)
    382 
    383 /**
    384  * list_for_each_prev	-	iterate over a list backwards
    385  * @pos:	the &struct list_head to use as a loop cursor.
    386  * @head:	the head for your list.
    387  */
    388 #define list_for_each_prev(pos, head) \
    389 	for (pos = (head)->prev; pos != (head); pos = pos->prev)
    390 
    391 /**
    392  * list_for_each_safe - iterate over a list safe against removal of list entry
    393  * @pos:	the &struct list_head to use as a loop cursor.
    394  * @n:		another &struct list_head to use as temporary storage
    395  * @head:	the head for your list.
    396  */
    397 #define list_for_each_safe(pos, n, head) \
    398 	for (pos = (head)->next, n = pos->next; pos != (head); \
    399 		pos = n, n = pos->next)
    400 
    401 /**
    402  * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
    403  * @pos:	the &struct list_head to use as a loop cursor.
    404  * @n:		another &struct list_head to use as temporary storage
    405  * @head:	the head for your list.
    406  */
    407 #define list_for_each_prev_safe(pos, n, head) \
    408 	for (pos = (head)->prev, n = pos->prev; \
    409 	     pos != (head); \
    410 	     pos = n, n = pos->prev)
    411 
    412 /**
    413  * list_for_each_entry	-	iterate over list of given type
    414  * @pos:	the type * to use as a loop cursor.
    415  * @head:	the head for your list.
    416  * @member:	the name of the list_struct within the struct.
    417  */
    418 #define list_for_each_entry(pos, head, member)				\
    419 	for (pos = list_entry((head)->next, typeof(*pos), member);	\
    420 	     &pos->member != (head); 	\
    421 	     pos = list_entry(pos->member.next, typeof(*pos), member))
    422 
    423 /**
    424  * list_for_each_entry_reverse - iterate backwards over list of given type.
    425  * @pos:	the type * to use as a loop cursor.
    426  * @head:	the head for your list.
    427  * @member:	the name of the list_struct within the struct.
    428  */
    429 #define list_for_each_entry_reverse(pos, head, member)			\
    430 	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
    431 	     &pos->member != (head); 	\
    432 	     pos = list_entry(pos->member.prev, typeof(*pos), member))
    433 
    434 /**
    435  * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
    436  * @pos:	the type * to use as a start point
    437  * @head:	the head of the list
    438  * @member:	the name of the list_struct within the struct.
    439  *
    440  * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
    441  */
    442 #define list_prepare_entry(pos, head, member) \
    443 	((pos) ? : list_entry(head, typeof(*pos), member))
    444 
    445 /**
    446  * list_for_each_entry_continue - continue iteration over list of given type
    447  * @pos:	the type * to use as a loop cursor.
    448  * @head:	the head for your list.
    449  * @member:	the name of the list_struct within the struct.
    450  *
    451  * Continue to iterate over list of given type, continuing after
    452  * the current position.
    453  */
    454 #define list_for_each_entry_continue(pos, head, member) 		\
    455 	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
    456 	     &pos->member != (head);	\
    457 	     pos = list_entry(pos->member.next, typeof(*pos), member))
    458 
    459 /**
    460  * list_for_each_entry_continue_reverse - iterate backwards from the given point
    461  * @pos:	the type * to use as a loop cursor.
    462  * @head:	the head for your list.
    463  * @member:	the name of the list_struct within the struct.
    464  *
    465  * Start to iterate over list of given type backwards, continuing after
    466  * the current position.
    467  */
    468 #define list_for_each_entry_continue_reverse(pos, head, member)		\
    469 	for (pos = list_entry(pos->member.prev, typeof(*pos), member);	\
    470 	     &pos->member != (head);	\
    471 	     pos = list_entry(pos->member.prev, typeof(*pos), member))
    472 
    473 /**
    474  * list_for_each_entry_from - iterate over list of given type from the current point
    475  * @pos:	the type * to use as a loop cursor.
    476  * @head:	the head for your list.
    477  * @member:	the name of the list_struct within the struct.
    478  *
    479  * Iterate over list of given type, continuing from current position.
    480  */
    481 #define list_for_each_entry_from(pos, head, member) 			\
    482 	for (; &pos->member != (head);	\
    483 	     pos = list_entry(pos->member.next, typeof(*pos), member))
    484 
    485 /**
    486  * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
    487  * @pos:	the type * to use as a loop cursor.
    488  * @n:		another type * to use as temporary storage
    489  * @head:	the head for your list.
    490  * @member:	the name of the list_struct within the struct.
    491  */
    492 #define list_for_each_entry_safe(pos, n, head, member)			\
    493 	for (pos = list_entry((head)->next, typeof(*pos), member),	\
    494 		n = list_entry(pos->member.next, typeof(*pos), member);	\
    495 	     &pos->member != (head); 					\
    496 	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
    497 
    498 /**
    499  * list_for_each_entry_safe_continue - continue list iteration safe against removal
    500  * @pos:	the type * to use as a loop cursor.
    501  * @n:		another type * to use as temporary storage
    502  * @head:	the head for your list.
    503  * @member:	the name of the list_struct within the struct.
    504  *
    505  * Iterate over list of given type, continuing after current point,
    506  * safe against removal of list entry.
    507  */
    508 #define list_for_each_entry_safe_continue(pos, n, head, member) 		\
    509 	for (pos = list_entry(pos->member.next, typeof(*pos), member), 		\
    510 		n = list_entry(pos->member.next, typeof(*pos), member);		\
    511 	     &pos->member != (head);						\
    512 	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
    513 
    514 /**
    515  * list_for_each_entry_safe_from - iterate over list from current point safe against removal
    516  * @pos:	the type * to use as a loop cursor.
    517  * @n:		another type * to use as temporary storage
    518  * @head:	the head for your list.
    519  * @member:	the name of the list_struct within the struct.
    520  *
    521  * Iterate over list of given type from current point, safe against
    522  * removal of list entry.
    523  */
    524 #define list_for_each_entry_safe_from(pos, n, head, member) 			\
    525 	for (n = list_entry(pos->member.next, typeof(*pos), member);		\
    526 	     &pos->member != (head);						\
    527 	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
    528 
    529 /**
    530  * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
    531  * @pos:	the type * to use as a loop cursor.
    532  * @n:		another type * to use as temporary storage
    533  * @head:	the head for your list.
    534  * @member:	the name of the list_struct within the struct.
    535  *
    536  * Iterate backwards over list of given type, safe against removal
    537  * of list entry.
    538  */
    539 #define list_for_each_entry_safe_reverse(pos, n, head, member)		\
    540 	for (pos = list_entry((head)->prev, typeof(*pos), member),	\
    541 		n = list_entry(pos->member.prev, typeof(*pos), member);	\
    542 	     &pos->member != (head); 					\
    543 	     pos = n, n = list_entry(n->member.prev, typeof(*n), member))
    544 
    545 /**
    546  * list_safe_reset_next - reset a stale list_for_each_entry_safe loop
    547  * @pos:	the loop cursor used in the list_for_each_entry_safe loop
    548  * @n:		temporary storage used in list_for_each_entry_safe
    549  * @member:	the name of the list_struct within the struct.
    550  *
    551  * list_safe_reset_next is not safe to use in general if the list may be
    552  * modified concurrently (eg. the lock is dropped in the loop body). An
    553  * exception to this is if the cursor element (pos) is pinned in the list,
    554  * and list_safe_reset_next is called after re-taking the lock and before
    555  * completing the current iteration of the loop body.
    556  */
    557 #define list_safe_reset_next(pos, n, member)				\
    558 	n = list_entry(pos->member.next, typeof(*pos), member)
    559 
    560 /*
    561  * Double linked lists with a single pointer list head.
    562  * Mostly useful for hash tables where the two pointer list head is
    563  * too wasteful.
    564  * You lose the ability to access the tail in O(1).
    565  */
    566 
    567 #define HLIST_HEAD_INIT { .first = NULL }
    568 #define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
    569 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
    570 static inline void INIT_HLIST_NODE(struct hlist_node *h)
    571 {
    572 	h->next = NULL;
    573 	h->pprev = NULL;
    574 }
    575 
    576 static inline int hlist_unhashed(const struct hlist_node *h)
    577 {
    578 	return !h->pprev;
    579 }
    580 
    581 static inline int hlist_empty(const struct hlist_head *h)
    582 {
    583 	return !h->first;
    584 }
    585 
    586 static inline void __hlist_del(struct hlist_node *n)
    587 {
    588 	struct hlist_node *next = n->next;
    589 	struct hlist_node **pprev = n->pprev;
    590 	*pprev = next;
    591 	if (next)
    592 		next->pprev = pprev;
    593 }
    594 
    595 static inline void hlist_del(struct hlist_node *n)
    596 {
    597 	__hlist_del(n);
    598 	n->next = LIST_POISON1;
    599 	n->pprev = LIST_POISON2;
    600 }
    601 
    602 static inline void hlist_del_init(struct hlist_node *n)
    603 {
    604 	if (!hlist_unhashed(n)) {
    605 		__hlist_del(n);
    606 		INIT_HLIST_NODE(n);
    607 	}
    608 }
    609 
    610 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
    611 {
    612 	struct hlist_node *first = h->first;
    613 	n->next = first;
    614 	if (first)
    615 		first->pprev = &n->next;
    616 	h->first = n;
    617 	n->pprev = &h->first;
    618 }
    619 
    620 /* next must be != NULL */
    621 static inline void hlist_add_before(struct hlist_node *n,
    622 					struct hlist_node *next)
    623 {
    624 	n->pprev = next->pprev;
    625 	n->next = next;
    626 	next->pprev = &n->next;
    627 	*(n->pprev) = n;
    628 }
    629 
    630 static inline void hlist_add_after(struct hlist_node *n,
    631 					struct hlist_node *next)
    632 {
    633 	next->next = n->next;
    634 	n->next = next;
    635 	next->pprev = &n->next;
    636 
    637 	if(next->next)
    638 		next->next->pprev  = &next->next;
    639 }
    640 
    641 /* after that we'll appear to be on some hlist and hlist_del will work */
    642 static inline void hlist_add_fake(struct hlist_node *n)
    643 {
    644 	n->pprev = &n->next;
    645 }
    646 
    647 /*
    648  * Move a list from one list head to another. Fixup the pprev
    649  * reference of the first entry if it exists.
    650  */
    651 static inline void hlist_move_list(struct hlist_head *old,
    652 				   struct hlist_head *new)
    653 {
    654 	new->first = old->first;
    655 	if (new->first)
    656 		new->first->pprev = &new->first;
    657 	old->first = NULL;
    658 }
    659 
    660 #define hlist_entry(ptr, type, member) container_of(ptr,type,member)
    661 
    662 #define hlist_for_each(pos, head) \
    663 	for (pos = (head)->first; pos ; pos = pos->next)
    664 
    665 #define hlist_for_each_safe(pos, n, head) \
    666 	for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
    667 	     pos = n)
    668 
    669 #define hlist_entry_safe(ptr, type, member) \
    670 	({ typeof(ptr) ____ptr = (ptr); \
    671 	   ____ptr ? hlist_entry(____ptr, type, member) : NULL; \
    672 	})
    673 
    674 /**
    675  * hlist_for_each_entry	- iterate over list of given type
    676  * @pos:	the type * to use as a loop cursor.
    677  * @head:	the head for your list.
    678  * @member:	the name of the hlist_node within the struct.
    679  */
    680 #define hlist_for_each_entry(pos, head, member)				\
    681 	for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\
    682 	     pos;							\
    683 	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
    684 
    685 /**
    686  * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
    687  * @pos:	the type * to use as a loop cursor.
    688  * @member:	the name of the hlist_node within the struct.
    689  */
    690 #define hlist_for_each_entry_continue(pos, member)			\
    691 	for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\
    692 	     pos;							\
    693 	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
    694 
    695 /**
    696  * hlist_for_each_entry_from - iterate over a hlist continuing from current point
    697  * @pos:	the type * to use as a loop cursor.
    698  * @member:	the name of the hlist_node within the struct.
    699  */
    700 #define hlist_for_each_entry_from(pos, member)				\
    701 	for (; pos;							\
    702 	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
    703 
    704 /**
    705  * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
    706  * @pos:	the type * to use as a loop cursor.
    707  * @n:		another &struct hlist_node to use as temporary storage
    708  * @head:	the head for your list.
    709  * @member:	the name of the hlist_node within the struct.
    710  */
    711 #define hlist_for_each_entry_safe(pos, n, head, member) 		\
    712 	for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\
    713 	     pos && ({ n = pos->member.next; 1; });			\
    714 	     pos = hlist_entry_safe(n, typeof(*pos), member))
    715 
    716 #endif
    717