~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/rculist.h

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp