Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/include/linux/list.h

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us