Add the 'current_kthread' helper
[akaros.git] / kern / include / rculist.h
1 #ifndef _LINUX_RCULIST_H
2 #define _LINUX_RCULIST_H
3
4 #ifdef __KERNEL__
5
6 /*
7  * RCU-protected list version
8  */
9 #include <list.h>
10
11 /*
12  * Why is there no list_empty_rcu()?  Because list_empty() serves this
13  * purpose.  The list_empty() function fetches the RCU-protected pointer
14  * and compares it to the address of the list head, but neither dereferences
15  * this pointer itself nor provides this pointer to the caller.  Therefore,
16  * it is not necessary to use rcu_dereference(), so that list_empty() can
17  * be used anywhere you would want to use a list_empty_rcu().
18  */
19
20 /*
21  * INIT_LIST_HEAD_RCU - Initialize a list_head visible to RCU readers
22  * @list: list to be initialized
23  *
24  * You should instead use INIT_LIST_HEAD() for normal initialization and
25  * cleanup tasks, when readers have no access to the list being initialized.
26  * However, if the list being initialized is visible to readers, you
27  * need to keep the compiler from being too mischievous.
28  */
29 static inline void INIT_LIST_HEAD_RCU(struct list_head *list)
30 {
31         WRITE_ONCE(list->next, list);
32         WRITE_ONCE(list->prev, list);
33 }
34
35 /*
36  * return the ->next pointer of a list_head in an rcu safe
37  * way, we must not access it directly
38  */
39 #define list_next_rcu(list)     (*((struct list_head __rcu **)(&(list)->next)))
40
41 /*
42  * Insert a new entry between two known consecutive entries.
43  *
44  * This is only for internal list manipulation where we know
45  * the prev/next entries already!
46  */
47 static inline void __list_add_rcu(struct list_head *new,
48                 struct list_head *prev, struct list_head *next)
49 {
50         if (!__list_add_valid(new, prev, next))
51                 return;
52
53         new->next = next;
54         new->prev = prev;
55         rcu_assign_pointer(list_next_rcu(prev), new);
56         next->prev = new;
57 }
58
59 /**
60  * list_add_rcu - add a new entry to rcu-protected list
61  * @new: new entry to be added
62  * @head: list head to add it after
63  *
64  * Insert a new entry after the specified head.
65  * This is good for implementing stacks.
66  *
67  * The caller must take whatever precautions are necessary
68  * (such as holding appropriate locks) to avoid racing
69  * with another list-mutation primitive, such as list_add_rcu()
70  * or list_del_rcu(), running on this same list.
71  * However, it is perfectly legal to run concurrently with
72  * the _rcu list-traversal primitives, such as
73  * list_for_each_entry_rcu().
74  */
75 static inline void list_add_rcu(struct list_head *new, struct list_head *head)
76 {
77         __list_add_rcu(new, head, head->next);
78 }
79
80 /**
81  * list_add_tail_rcu - add a new entry to rcu-protected list
82  * @new: new entry to be added
83  * @head: list head to add it before
84  *
85  * Insert a new entry before the specified head.
86  * This is useful for implementing queues.
87  *
88  * The caller must take whatever precautions are necessary
89  * (such as holding appropriate locks) to avoid racing
90  * with another list-mutation primitive, such as list_add_tail_rcu()
91  * or list_del_rcu(), running on this same list.
92  * However, it is perfectly legal to run concurrently with
93  * the _rcu list-traversal primitives, such as
94  * list_for_each_entry_rcu().
95  */
96 static inline void list_add_tail_rcu(struct list_head *new,
97                                         struct list_head *head)
98 {
99         __list_add_rcu(new, head->prev, head);
100 }
101
102 /**
103  * list_del_rcu - deletes entry from list without re-initialization
104  * @entry: the element to delete from the list.
105  *
106  * Note: list_empty() on entry does not return true after this,
107  * the entry is in an undefined state. It is useful for RCU based
108  * lockfree traversal.
109  *
110  * In particular, it means that we can not poison the forward
111  * pointers that may still be used for walking the list.
112  *
113  * The caller must take whatever precautions are necessary
114  * (such as holding appropriate locks) to avoid racing
115  * with another list-mutation primitive, such as list_del_rcu()
116  * or list_add_rcu(), running on this same list.
117  * However, it is perfectly legal to run concurrently with
118  * the _rcu list-traversal primitives, such as
119  * list_for_each_entry_rcu().
120  *
121  * Note that the caller is not permitted to immediately free
122  * the newly deleted entry.  Instead, either synchronize_rcu()
123  * or call_rcu() must be used to defer freeing until an RCU
124  * grace period has elapsed.
125  */
126 static inline void list_del_rcu(struct list_head *entry)
127 {
128         __list_del_entry(entry);
129         entry->prev = LIST_POISON2;
130 }
131
132 /**
133  * hlist_del_init_rcu - deletes entry from hash list with re-initialization
134  * @n: the element to delete from the hash list.
135  *
136  * Note: list_unhashed() on the node return true after this. It is
137  * useful for RCU based read lockfree traversal if the writer side
138  * must know if the list entry is still hashed or already unhashed.
139  *
140  * In particular, it means that we can not poison the forward pointers
141  * that may still be used for walking the hash list and we can only
142  * zero the pprev pointer so list_unhashed() will return true after
143  * this.
144  *
145  * The caller must take whatever precautions are necessary (such as
146  * holding appropriate locks) to avoid racing with another
147  * list-mutation primitive, such as hlist_add_head_rcu() or
148  * hlist_del_rcu(), running on this same list.  However, it is
149  * perfectly legal to run concurrently with the _rcu list-traversal
150  * primitives, such as hlist_for_each_entry_rcu().
151  */
152 static inline void hlist_del_init_rcu(struct hlist_node *n)
153 {
154         if (!hlist_unhashed(n)) {
155                 __hlist_del(n);
156                 n->pprev = NULL;
157         }
158 }
159
160 /**
161  * list_replace_rcu - replace old entry by new one
162  * @old : the element to be replaced
163  * @new : the new element to insert
164  *
165  * The @old entry will be replaced with the @new entry atomically.
166  * Note: @old should not be empty.
167  */
168 static inline void list_replace_rcu(struct list_head *old,
169                                 struct list_head *new)
170 {
171         new->next = old->next;
172         new->prev = old->prev;
173         rcu_assign_pointer(list_next_rcu(new->prev), new);
174         new->next->prev = new;
175         old->prev = LIST_POISON2;
176 }
177
178 /**
179  * __list_splice_init_rcu - join an RCU-protected list into an existing list.
180  * @list:       the RCU-protected list to splice
181  * @prev:       points to the last element of the existing list
182  * @next:       points to the first element of the existing list
183  * @sync:       function to sync: synchronize_rcu(), synchronize_sched(), ...
184  *
185  * The list pointed to by @prev and @next can be RCU-read traversed
186  * concurrently with this function.
187  *
188  * Note that this function blocks.
189  *
190  * Important note: the caller must take whatever action is necessary to prevent
191  * any other updates to the existing list.  In principle, it is possible to
192  * modify the list as soon as sync() begins execution. If this sort of thing
193  * becomes necessary, an alternative version based on call_rcu() could be
194  * created.  But only if -really- needed -- there is no shortage of RCU API
195  * members.
196  */
197 static inline void __list_splice_init_rcu(struct list_head *list,
198                                           struct list_head *prev,
199                                           struct list_head *next,
200                                           void (*sync)(void))
201 {
202         struct list_head *first = list->next;
203         struct list_head *last = list->prev;
204
205         /*
206          * "first" and "last" tracking list, so initialize it.  RCU readers
207          * have access to this list, so we must use INIT_LIST_HEAD_RCU()
208          * instead of INIT_LIST_HEAD().
209          */
210
211         INIT_LIST_HEAD_RCU(list);
212
213         /*
214          * At this point, the list body still points to the source list.
215          * Wait for any readers to finish using the list before splicing
216          * the list body into the new list.  Any new readers will see
217          * an empty list.
218          */
219
220         sync();
221
222         /*
223          * Readers are finished with the source list, so perform splice.
224          * The order is important if the new list is global and accessible
225          * to concurrent RCU readers.  Note that RCU readers are not
226          * permitted to traverse the prev pointers without excluding
227          * this function.
228          */
229
230         last->next = next;
231         rcu_assign_pointer(list_next_rcu(prev), first);
232         first->prev = prev;
233         next->prev = last;
234 }
235
236 /**
237  * list_splice_init_rcu - splice an RCU-protected list into an existing list,
238  *                        designed for stacks.
239  * @list:       the RCU-protected list to splice
240  * @head:       the place in the existing list to splice the first list into
241  * @sync:       function to sync: synchronize_rcu(), synchronize_sched(), ...
242  */
243 static inline void list_splice_init_rcu(struct list_head *list,
244                                         struct list_head *head,
245                                         void (*sync)(void))
246 {
247         if (!list_empty(list))
248                 __list_splice_init_rcu(list, head, head->next, sync);
249 }
250
251 /**
252  * list_splice_tail_init_rcu - splice an RCU-protected list into an existing
253  *                             list, designed for queues.
254  * @list:       the RCU-protected list to splice
255  * @head:       the place in the existing list to splice the first list into
256  * @sync:       function to sync: synchronize_rcu(), synchronize_sched(), ...
257  */
258 static inline void list_splice_tail_init_rcu(struct list_head *list,
259                                              struct list_head *head,
260                                              void (*sync)(void))
261 {
262         if (!list_empty(list))
263                 __list_splice_init_rcu(list, head->prev, head, sync);
264 }
265
266 /**
267  * list_entry_rcu - get the struct for this entry
268  * @ptr:        the &struct list_head pointer.
269  * @type:       the type of the struct this is embedded in.
270  * @member:     the name of the list_head within the struct.
271  *
272  * This primitive may safely run concurrently with the _rcu list-mutation
273  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
274  */
275 #define list_entry_rcu(ptr, type, member) \
276         container_of(lockless_dereference(ptr), type, member)
277
278 /**
279  * Where are list_empty_rcu() and list_first_entry_rcu()?
280  *
281  * Implementing those functions following their counterparts list_empty() and
282  * list_first_entry() is not advisable because they lead to subtle race
283  * conditions as the following snippet shows:
284  *
285  * if (!list_empty_rcu(mylist)) {
286  *      struct foo *bar = list_first_entry_rcu(mylist, struct foo, list_member);
287  *      do_something(bar);
288  * }
289  *
290  * The list may not be empty when list_empty_rcu checks it, but it may be when
291  * list_first_entry_rcu rereads the ->next pointer.
292  *
293  * Rereading the ->next pointer is not a problem for list_empty() and
294  * list_first_entry() because they would be protected by a lock that blocks
295  * writers.
296  *
297  * See list_first_or_null_rcu for an alternative.
298  */
299
300 /**
301  * list_first_or_null_rcu - get the first element from a list
302  * @ptr:        the list head to take the element from.
303  * @type:       the type of the struct this is embedded in.
304  * @member:     the name of the list_head within the struct.
305  *
306  * Note that if the list is empty, it returns NULL.
307  *
308  * This primitive may safely run concurrently with the _rcu list-mutation
309  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
310  */
311 #define list_first_or_null_rcu(ptr, type, member) \
312 ({ \
313         struct list_head *__ptr = (ptr); \
314         struct list_head *__next = READ_ONCE(__ptr->next); \
315         likely(__ptr != __next) ? list_entry_rcu(__next, type, member) : NULL; \
316 })
317
318 /**
319  * list_next_or_null_rcu - get the first element from a list
320  * @head:       the head for the list.
321  * @ptr:        the list head to take the next element from.
322  * @type:       the type of the struct this is embedded in.
323  * @member:     the name of the list_head within the struct.
324  *
325  * Note that if the ptr is at the end of the list, NULL is returned.
326  *
327  * This primitive may safely run concurrently with the _rcu list-mutation
328  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
329  */
330 #define list_next_or_null_rcu(head, ptr, type, member) \
331 ({ \
332         struct list_head *__head = (head); \
333         struct list_head *__ptr = (ptr); \
334         struct list_head *__next = READ_ONCE(__ptr->next); \
335         likely(__next != __head) ? list_entry_rcu(__next, type, \
336                                                   member) : NULL; \
337 })
338
339 /**
340  * list_for_each_entry_rcu      -       iterate over rcu list of given type
341  * @pos:        the type * to use as a loop cursor.
342  * @head:       the head for your list.
343  * @member:     the name of the list_head within the struct.
344  *
345  * This list-traversal primitive may safely run concurrently with
346  * the _rcu list-mutation primitives such as list_add_rcu()
347  * as long as the traversal is guarded by rcu_read_lock().
348  */
349 #define list_for_each_entry_rcu(pos, head, member) \
350         for (pos = list_entry_rcu((head)->next, typeof(*pos), member); \
351                 &pos->member != (head); \
352                 pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
353
354 /**
355  * list_entry_lockless - get the struct for this entry
356  * @ptr:        the &struct list_head pointer.
357  * @type:       the type of the struct this is embedded in.
358  * @member:     the name of the list_head within the struct.
359  *
360  * This primitive may safely run concurrently with the _rcu list-mutation
361  * primitives such as list_add_rcu(), but requires some implicit RCU
362  * read-side guarding.  One example is running within a special
363  * exception-time environment where preemption is disabled and where
364  * lockdep cannot be invoked (in which case updaters must use RCU-sched,
365  * as in synchronize_sched(), call_rcu_sched(), and friends).  Another
366  * example is when items are added to the list, but never deleted.
367  */
368 #define list_entry_lockless(ptr, type, member) \
369         container_of((typeof(ptr))lockless_dereference(ptr), type, member)
370
371 /**
372  * list_for_each_entry_lockless - iterate over rcu list of given type
373  * @pos:        the type * to use as a loop cursor.
374  * @head:       the head for your list.
375  * @member:     the name of the list_struct within the struct.
376  *
377  * This primitive may safely run concurrently with the _rcu list-mutation
378  * primitives such as list_add_rcu(), but requires some implicit RCU
379  * read-side guarding.  One example is running within a special
380  * exception-time environment where preemption is disabled and where
381  * lockdep cannot be invoked (in which case updaters must use RCU-sched,
382  * as in synchronize_sched(), call_rcu_sched(), and friends).  Another
383  * example is when items are added to the list, but never deleted.
384  */
385 #define list_for_each_entry_lockless(pos, head, member) \
386         for (pos = list_entry_lockless((head)->next, typeof(*pos), member); \
387              &pos->member != (head); \
388              pos = list_entry_lockless(pos->member.next, typeof(*pos), member))
389
390 /**
391  * list_for_each_entry_continue_rcu - continue iteration over list of given type
392  * @pos:        the type * to use as a loop cursor.
393  * @head:       the head for your list.
394  * @member:     the name of the list_head within the struct.
395  *
396  * Continue to iterate over list of given type, continuing after
397  * the current position.
398  */
399 #define list_for_each_entry_continue_rcu(pos, head, member)             \
400         for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \
401              &pos->member != (head);    \
402              pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
403
404 /**
405  * hlist_del_rcu - deletes entry from hash list without re-initialization
406  * @n: the element to delete from the hash list.
407  *
408  * Note: list_unhashed() on entry does not return true after this,
409  * the entry is in an undefined state. It is useful for RCU based
410  * lockfree traversal.
411  *
412  * In particular, it means that we can not poison the forward
413  * pointers that may still be used for walking the hash list.
414  *
415  * The caller must take whatever precautions are necessary
416  * (such as holding appropriate locks) to avoid racing
417  * with another list-mutation primitive, such as hlist_add_head_rcu()
418  * or hlist_del_rcu(), running on this same list.
419  * However, it is perfectly legal to run concurrently with
420  * the _rcu list-traversal primitives, such as
421  * hlist_for_each_entry().
422  */
423 static inline void hlist_del_rcu(struct hlist_node *n)
424 {
425         __hlist_del(n);
426         n->pprev = LIST_POISON2;
427 }
428
429 /**
430  * hlist_replace_rcu - replace old entry by new one
431  * @old : the element to be replaced
432  * @new : the new element to insert
433  *
434  * The @old entry will be replaced with the @new entry atomically.
435  */
436 static inline void hlist_replace_rcu(struct hlist_node *old,
437                                         struct hlist_node *new)
438 {
439         struct hlist_node *next = old->next;
440
441         new->next = next;
442         new->pprev = old->pprev;
443         rcu_assign_pointer(*(struct hlist_node __rcu **)new->pprev, new);
444         if (next)
445                 new->next->pprev = &new->next;
446         old->pprev = LIST_POISON2;
447 }
448
449 /*
450  * return the first or the next element in an RCU protected hlist
451  */
452 #define hlist_first_rcu(head)   (*((struct hlist_node __rcu **)(&(head)->first)))
453 #define hlist_next_rcu(node)    (*((struct hlist_node __rcu **)(&(node)->next)))
454 #define hlist_pprev_rcu(node)   (*((struct hlist_node __rcu **)((node)->pprev)))
455
456 /**
457  * hlist_add_head_rcu
458  * @n: the element to add to the hash list.
459  * @h: the list to add to.
460  *
461  * Description:
462  * Adds the specified element to the specified hlist,
463  * while permitting racing traversals.
464  *
465  * The caller must take whatever precautions are necessary
466  * (such as holding appropriate locks) to avoid racing
467  * with another list-mutation primitive, such as hlist_add_head_rcu()
468  * or hlist_del_rcu(), running on this same list.
469  * However, it is perfectly legal to run concurrently with
470  * the _rcu list-traversal primitives, such as
471  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
472  * problems on Alpha CPUs.  Regardless of the type of CPU, the
473  * list-traversal primitive must be guarded by rcu_read_lock().
474  */
475 static inline void hlist_add_head_rcu(struct hlist_node *n,
476                                         struct hlist_head *h)
477 {
478         struct hlist_node *first = h->first;
479
480         n->next = first;
481         n->pprev = &h->first;
482         rcu_assign_pointer(hlist_first_rcu(h), n);
483         if (first)
484                 first->pprev = &n->next;
485 }
486
487 /**
488  * hlist_add_tail_rcu
489  * @n: the element to add to the hash list.
490  * @h: the list to add to.
491  *
492  * Description:
493  * Adds the specified element to the specified hlist,
494  * while permitting racing traversals.
495  *
496  * The caller must take whatever precautions are necessary
497  * (such as holding appropriate locks) to avoid racing
498  * with another list-mutation primitive, such as hlist_add_head_rcu()
499  * or hlist_del_rcu(), running on this same list.
500  * However, it is perfectly legal to run concurrently with
501  * the _rcu list-traversal primitives, such as
502  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
503  * problems on Alpha CPUs.  Regardless of the type of CPU, the
504  * list-traversal primitive must be guarded by rcu_read_lock().
505  */
506 static inline void hlist_add_tail_rcu(struct hlist_node *n,
507                                       struct hlist_head *h)
508 {
509         struct hlist_node *i, *last = NULL;
510
511         /* Note: write side code, so rcu accessors are not needed. */
512         for (i = h->first; i; i = i->next)
513                 last = i;
514
515         if (last) {
516                 n->next = last->next;
517                 n->pprev = &last->next;
518                 rcu_assign_pointer(hlist_next_rcu(last), n);
519         } else {
520                 hlist_add_head_rcu(n, h);
521         }
522 }
523
524 /**
525  * hlist_add_before_rcu
526  * @n: the new element to add to the hash list.
527  * @next: the existing element to add the new element before.
528  *
529  * Description:
530  * Adds the specified element to the specified hlist
531  * before the specified node while permitting racing traversals.
532  *
533  * The caller must take whatever precautions are necessary
534  * (such as holding appropriate locks) to avoid racing
535  * with another list-mutation primitive, such as hlist_add_head_rcu()
536  * or hlist_del_rcu(), running on this same list.
537  * However, it is perfectly legal to run concurrently with
538  * the _rcu list-traversal primitives, such as
539  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
540  * problems on Alpha CPUs.
541  */
542 static inline void hlist_add_before_rcu(struct hlist_node *n,
543                                         struct hlist_node *next)
544 {
545         n->pprev = next->pprev;
546         n->next = next;
547         rcu_assign_pointer(hlist_pprev_rcu(n), n);
548         next->pprev = &n->next;
549 }
550
551 /**
552  * hlist_add_behind_rcu
553  * @n: the new element to add to the hash list.
554  * @prev: the existing element to add the new element after.
555  *
556  * Description:
557  * Adds the specified element to the specified hlist
558  * after the specified node while permitting racing traversals.
559  *
560  * The caller must take whatever precautions are necessary
561  * (such as holding appropriate locks) to avoid racing
562  * with another list-mutation primitive, such as hlist_add_head_rcu()
563  * or hlist_del_rcu(), running on this same list.
564  * However, it is perfectly legal to run concurrently with
565  * the _rcu list-traversal primitives, such as
566  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
567  * problems on Alpha CPUs.
568  */
569 static inline void hlist_add_behind_rcu(struct hlist_node *n,
570                                         struct hlist_node *prev)
571 {
572         n->next = prev->next;
573         n->pprev = &prev->next;
574         rcu_assign_pointer(hlist_next_rcu(prev), n);
575         if (n->next)
576                 n->next->pprev = &n->next;
577 }
578
579 #define __hlist_for_each_rcu(pos, head)                         \
580         for (pos = rcu_dereference(hlist_first_rcu(head));      \
581              pos;                                               \
582              pos = rcu_dereference(hlist_next_rcu(pos)))
583
584 /**
585  * hlist_for_each_entry_rcu - iterate over rcu list of given type
586  * @pos:        the type * to use as a loop cursor.
587  * @head:       the head for your list.
588  * @member:     the name of the hlist_node within the struct.
589  *
590  * This list-traversal primitive may safely run concurrently with
591  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
592  * as long as the traversal is guarded by rcu_read_lock().
593  */
594 #define hlist_for_each_entry_rcu(pos, head, member)                     \
595         for (pos = hlist_entry_safe (rcu_dereference_raw(hlist_first_rcu(head)),\
596                         typeof(*(pos)), member);                        \
597                 pos;                                                    \
598                 pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu(\
599                         &(pos)->member)), typeof(*(pos)), member))
600
601 /**
602  * hlist_for_each_entry_rcu_notrace - iterate over rcu list of given type (for tracing)
603  * @pos:        the type * to use as a loop cursor.
604  * @head:       the head for your list.
605  * @member:     the name of the hlist_node within the struct.
606  *
607  * This list-traversal primitive may safely run concurrently with
608  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
609  * as long as the traversal is guarded by rcu_read_lock().
610  *
611  * This is the same as hlist_for_each_entry_rcu() except that it does
612  * not do any RCU debugging or tracing.
613  */
614 #define hlist_for_each_entry_rcu_notrace(pos, head, member)                     \
615         for (pos = hlist_entry_safe (rcu_dereference_raw_notrace(hlist_first_rcu(head)),\
616                         typeof(*(pos)), member);                        \
617                 pos;                                                    \
618                 pos = hlist_entry_safe(rcu_dereference_raw_notrace(hlist_next_rcu(\
619                         &(pos)->member)), typeof(*(pos)), member))
620
621 /**
622  * hlist_for_each_entry_rcu_bh - iterate over rcu list of given type
623  * @pos:        the type * to use as a loop cursor.
624  * @head:       the head for your list.
625  * @member:     the name of the hlist_node within the struct.
626  *
627  * This list-traversal primitive may safely run concurrently with
628  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
629  * as long as the traversal is guarded by rcu_read_lock().
630  */
631 #define hlist_for_each_entry_rcu_bh(pos, head, member)                  \
632         for (pos = hlist_entry_safe(rcu_dereference_bh(hlist_first_rcu(head)),\
633                         typeof(*(pos)), member);                        \
634                 pos;                                                    \
635                 pos = hlist_entry_safe(rcu_dereference_bh(hlist_next_rcu(\
636                         &(pos)->member)), typeof(*(pos)), member))
637
638 /**
639  * hlist_for_each_entry_continue_rcu - iterate over a hlist continuing after current point
640  * @pos:        the type * to use as a loop cursor.
641  * @member:     the name of the hlist_node within the struct.
642  */
643 #define hlist_for_each_entry_continue_rcu(pos, member)                  \
644         for (pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \
645                         &(pos)->member)), typeof(*(pos)), member);      \
646              pos;                                                       \
647              pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \
648                         &(pos)->member)), typeof(*(pos)), member))
649
650 /**
651  * hlist_for_each_entry_continue_rcu_bh - iterate over a hlist continuing after current point
652  * @pos:        the type * to use as a loop cursor.
653  * @member:     the name of the hlist_node within the struct.
654  */
655 #define hlist_for_each_entry_continue_rcu_bh(pos, member)               \
656         for (pos = hlist_entry_safe(rcu_dereference_bh(hlist_next_rcu(  \
657                         &(pos)->member)), typeof(*(pos)), member);      \
658              pos;                                                       \
659              pos = hlist_entry_safe(rcu_dereference_bh(hlist_next_rcu(  \
660                         &(pos)->member)), typeof(*(pos)), member))
661
662 /**
663  * hlist_for_each_entry_from_rcu - iterate over a hlist continuing from current point
664  * @pos:        the type * to use as a loop cursor.
665  * @member:     the name of the hlist_node within the struct.
666  */
667 #define hlist_for_each_entry_from_rcu(pos, member)                      \
668         for (; pos;                                                     \
669              pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \
670                         &(pos)->member)), typeof(*(pos)), member))
671
672 #endif  /* __KERNEL__ */
673 #endif