srcu.h 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184
  1. /*
  2. * Sleepable Read-Copy Update mechanism for mutual exclusion
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License as published by
  6. * the Free Software Foundation; either version 2 of the License, or
  7. * (at your option) any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. *
  18. * Copyright (C) IBM Corporation, 2006
  19. *
  20. * Author: Paul McKenney <paulmck@us.ibm.com>
  21. *
  22. * For detailed explanation of Read-Copy Update mechanism see -
  23. * Documentation/RCU/ *.txt
  24. *
  25. */
  26. #ifndef _LINUX_SRCU_H
  27. #define _LINUX_SRCU_H
  28. #include <linux/mutex.h>
  29. #include <linux/rcupdate.h>
  30. struct srcu_struct_array {
  31. int c[2];
  32. };
  33. struct srcu_struct {
  34. int completed;
  35. struct srcu_struct_array __percpu *per_cpu_ref;
  36. struct mutex mutex;
  37. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  38. struct lockdep_map dep_map;
  39. #endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
  40. };
  41. #ifndef CONFIG_PREEMPT
  42. #define srcu_barrier() barrier()
  43. #else /* #ifndef CONFIG_PREEMPT */
  44. #define srcu_barrier()
  45. #endif /* #else #ifndef CONFIG_PREEMPT */
  46. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  47. int __init_srcu_struct(struct srcu_struct *sp, const char *name,
  48. struct lock_class_key *key);
  49. #define init_srcu_struct(sp) \
  50. ({ \
  51. static struct lock_class_key __srcu_key; \
  52. \
  53. __init_srcu_struct((sp), #sp, &__srcu_key); \
  54. })
  55. #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
  56. int init_srcu_struct(struct srcu_struct *sp);
  57. #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
  58. void cleanup_srcu_struct(struct srcu_struct *sp);
  59. int __srcu_read_lock(struct srcu_struct *sp) __acquires(sp);
  60. void __srcu_read_unlock(struct srcu_struct *sp, int idx) __releases(sp);
  61. void synchronize_srcu(struct srcu_struct *sp);
  62. void synchronize_srcu_expedited(struct srcu_struct *sp);
  63. long srcu_batches_completed(struct srcu_struct *sp);
  64. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  65. /**
  66. * srcu_read_lock_held - might we be in SRCU read-side critical section?
  67. *
  68. * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an SRCU
  69. * read-side critical section. In absence of CONFIG_DEBUG_LOCK_ALLOC,
  70. * this assumes we are in an SRCU read-side critical section unless it can
  71. * prove otherwise.
  72. *
  73. * Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
  74. * and while lockdep is disabled.
  75. *
  76. * Note that if the CPU is in the idle loop from an RCU point of view
  77. * (ie: that we are in the section between rcu_idle_enter() and
  78. * rcu_idle_exit()) then srcu_read_lock_held() returns false even if
  79. * the CPU did an srcu_read_lock(). The reason for this is that RCU
  80. * ignores CPUs that are in such a section, considering these as in
  81. * extended quiescent state, so such a CPU is effectively never in an
  82. * RCU read-side critical section regardless of what RCU primitives it
  83. * invokes. This state of affairs is required --- we need to keep an
  84. * RCU-free window in idle where the CPU may possibly enter into low
  85. * power mode. This way we can notice an extended quiescent state to
  86. * other CPUs that started a grace period. Otherwise we would delay any
  87. * grace period as long as we run in the idle task.
  88. */
  89. static inline int srcu_read_lock_held(struct srcu_struct *sp)
  90. {
  91. if (rcu_is_cpu_idle())
  92. return 0;
  93. if (!debug_lockdep_rcu_enabled())
  94. return 1;
  95. return lock_is_held(&sp->dep_map);
  96. }
  97. #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
  98. static inline int srcu_read_lock_held(struct srcu_struct *sp)
  99. {
  100. return 1;
  101. }
  102. #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
  103. /**
  104. * srcu_dereference_check - fetch SRCU-protected pointer for later dereferencing
  105. * @p: the pointer to fetch and protect for later dereferencing
  106. * @sp: pointer to the srcu_struct, which is used to check that we
  107. * really are in an SRCU read-side critical section.
  108. * @c: condition to check for update-side use
  109. *
  110. * If PROVE_RCU is enabled, invoking this outside of an RCU read-side
  111. * critical section will result in an RCU-lockdep splat, unless @c evaluates
  112. * to 1. The @c argument will normally be a logical expression containing
  113. * lockdep_is_held() calls.
  114. */
  115. #define srcu_dereference_check(p, sp, c) \
  116. __rcu_dereference_check((p), srcu_read_lock_held(sp) || (c), __rcu)
  117. /**
  118. * srcu_dereference - fetch SRCU-protected pointer for later dereferencing
  119. * @p: the pointer to fetch and protect for later dereferencing
  120. * @sp: pointer to the srcu_struct, which is used to check that we
  121. * really are in an SRCU read-side critical section.
  122. *
  123. * Makes rcu_dereference_check() do the dirty work. If PROVE_RCU
  124. * is enabled, invoking this outside of an RCU read-side critical
  125. * section will result in an RCU-lockdep splat.
  126. */
  127. #define srcu_dereference(p, sp) srcu_dereference_check((p), (sp), 0)
  128. /**
  129. * srcu_read_lock - register a new reader for an SRCU-protected structure.
  130. * @sp: srcu_struct in which to register the new reader.
  131. *
  132. * Enter an SRCU read-side critical section. Note that SRCU read-side
  133. * critical sections may be nested. However, it is illegal to
  134. * call anything that waits on an SRCU grace period for the same
  135. * srcu_struct, whether directly or indirectly. Please note that
  136. * one way to indirectly wait on an SRCU grace period is to acquire
  137. * a mutex that is held elsewhere while calling synchronize_srcu() or
  138. * synchronize_srcu_expedited().
  139. */
  140. static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
  141. {
  142. int retval = __srcu_read_lock(sp);
  143. rcu_lock_acquire(&(sp)->dep_map);
  144. return retval;
  145. }
  146. /**
  147. * srcu_read_unlock - unregister a old reader from an SRCU-protected structure.
  148. * @sp: srcu_struct in which to unregister the old reader.
  149. * @idx: return value from corresponding srcu_read_lock().
  150. *
  151. * Exit an SRCU read-side critical section.
  152. */
  153. static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
  154. __releases(sp)
  155. {
  156. rcu_lock_release(&(sp)->dep_map);
  157. __srcu_read_unlock(sp, idx);
  158. }
  159. #endif