LCOV - code coverage report
Current view: top level - include/linux - list.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 37 37 100.0 %
Date: 2017-01-25 Functions: 9 9 100.0 %

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

Generated by: LCOV version 1.10