rcutiny.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253
  1. /*
  2. * Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition.
  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 IBM Corporation, 2008
  19. *
  20. * Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
  21. *
  22. * For detailed explanation of Read-Copy Update mechanism see -
  23. * Documentation/RCU
  24. */
  25. #include <linux/moduleparam.h>
  26. #include <linux/completion.h>
  27. #include <linux/interrupt.h>
  28. #include <linux/notifier.h>
  29. #include <linux/rcupdate.h>
  30. #include <linux/kernel.h>
  31. #include <linux/module.h>
  32. #include <linux/mutex.h>
  33. #include <linux/sched.h>
  34. #include <linux/types.h>
  35. #include <linux/init.h>
  36. #include <linux/time.h>
  37. #include <linux/cpu.h>
  38. #include <linux/prefetch.h>
  39. #ifdef CONFIG_RCU_TRACE
  40. #include <trace/events/rcu.h>
  41. #endif /* #else #ifdef CONFIG_RCU_TRACE */
  42. #include "rcu.h"
  43. /* Forward declarations for rcutiny_plugin.h. */
  44. struct rcu_ctrlblk;
  45. static void invoke_rcu_callbacks(void);
  46. static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp);
  47. static void rcu_process_callbacks(struct softirq_action *unused);
  48. static void __call_rcu(struct rcu_head *head,
  49. void (*func)(struct rcu_head *rcu),
  50. struct rcu_ctrlblk *rcp);
  51. #include "rcutiny_plugin.h"
  52. #ifdef CONFIG_NO_HZ
  53. static long rcu_dynticks_nesting = 1;
  54. /*
  55. * Enter dynticks-idle mode, which is an extended quiescent state
  56. * if we have fully entered that mode (i.e., if the new value of
  57. * dynticks_nesting is zero).
  58. */
  59. void rcu_enter_nohz(void)
  60. {
  61. if (--rcu_dynticks_nesting == 0)
  62. rcu_sched_qs(0); /* implies rcu_bh_qsctr_inc(0) */
  63. }
  64. /*
  65. * Exit dynticks-idle mode, so that we are no longer in an extended
  66. * quiescent state.
  67. */
  68. void rcu_exit_nohz(void)
  69. {
  70. rcu_dynticks_nesting++;
  71. }
  72. #endif /* #ifdef CONFIG_NO_HZ */
  73. /*
  74. * Helper function for rcu_sched_qs() and rcu_bh_qs().
  75. * Also irqs are disabled to avoid confusion due to interrupt handlers
  76. * invoking call_rcu().
  77. */
  78. static int rcu_qsctr_help(struct rcu_ctrlblk *rcp)
  79. {
  80. if (rcp->rcucblist != NULL &&
  81. rcp->donetail != rcp->curtail) {
  82. rcp->donetail = rcp->curtail;
  83. return 1;
  84. }
  85. return 0;
  86. }
  87. /*
  88. * Record an rcu quiescent state. And an rcu_bh quiescent state while we
  89. * are at it, given that any rcu quiescent state is also an rcu_bh
  90. * quiescent state. Use "+" instead of "||" to defeat short circuiting.
  91. */
  92. void rcu_sched_qs(int cpu)
  93. {
  94. unsigned long flags;
  95. local_irq_save(flags);
  96. if (rcu_qsctr_help(&rcu_sched_ctrlblk) +
  97. rcu_qsctr_help(&rcu_bh_ctrlblk))
  98. invoke_rcu_callbacks();
  99. local_irq_restore(flags);
  100. }
  101. /*
  102. * Record an rcu_bh quiescent state.
  103. */
  104. void rcu_bh_qs(int cpu)
  105. {
  106. unsigned long flags;
  107. local_irq_save(flags);
  108. if (rcu_qsctr_help(&rcu_bh_ctrlblk))
  109. invoke_rcu_callbacks();
  110. local_irq_restore(flags);
  111. }
  112. /*
  113. * Check to see if the scheduling-clock interrupt came from an extended
  114. * quiescent state, and, if so, tell RCU about it.
  115. */
  116. void rcu_check_callbacks(int cpu, int user)
  117. {
  118. if (user ||
  119. (idle_cpu(cpu) &&
  120. !in_softirq() &&
  121. hardirq_count() <= (1 << HARDIRQ_SHIFT)))
  122. rcu_sched_qs(cpu);
  123. else if (!in_softirq())
  124. rcu_bh_qs(cpu);
  125. rcu_preempt_check_callbacks();
  126. }
  127. /*
  128. * Invoke the RCU callbacks on the specified rcu_ctrlkblk structure
  129. * whose grace period has elapsed.
  130. */
  131. static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp)
  132. {
  133. struct rcu_head *next, *list;
  134. unsigned long flags;
  135. RCU_TRACE(int cb_count = 0);
  136. /* If no RCU callbacks ready to invoke, just return. */
  137. if (&rcp->rcucblist == rcp->donetail) {
  138. RCU_TRACE(trace_rcu_batch_start(rcp->name, 0, -1));
  139. RCU_TRACE(trace_rcu_batch_end(rcp->name, 0));
  140. return;
  141. }
  142. /* Move the ready-to-invoke callbacks to a local list. */
  143. local_irq_save(flags);
  144. RCU_TRACE(trace_rcu_batch_start(rcp->name, 0, -1));
  145. list = rcp->rcucblist;
  146. rcp->rcucblist = *rcp->donetail;
  147. *rcp->donetail = NULL;
  148. if (rcp->curtail == rcp->donetail)
  149. rcp->curtail = &rcp->rcucblist;
  150. rcu_preempt_remove_callbacks(rcp);
  151. rcp->donetail = &rcp->rcucblist;
  152. local_irq_restore(flags);
  153. /* Invoke the callbacks on the local list. */
  154. while (list) {
  155. next = list->next;
  156. prefetch(next);
  157. debug_rcu_head_unqueue(list);
  158. local_bh_disable();
  159. __rcu_reclaim(list);
  160. local_bh_enable();
  161. list = next;
  162. RCU_TRACE(cb_count++);
  163. }
  164. RCU_TRACE(rcu_trace_sub_qlen(rcp, cb_count));
  165. RCU_TRACE(trace_rcu_batch_end(rcp->name, cb_count));
  166. }
  167. static void rcu_process_callbacks(struct softirq_action *unused)
  168. {
  169. __rcu_process_callbacks(&rcu_sched_ctrlblk);
  170. __rcu_process_callbacks(&rcu_bh_ctrlblk);
  171. rcu_preempt_process_callbacks();
  172. }
  173. /*
  174. * Wait for a grace period to elapse. But it is illegal to invoke
  175. * synchronize_sched() from within an RCU read-side critical section.
  176. * Therefore, any legal call to synchronize_sched() is a quiescent
  177. * state, and so on a UP system, synchronize_sched() need do nothing.
  178. * Ditto for synchronize_rcu_bh(). (But Lai Jiangshan points out the
  179. * benefits of doing might_sleep() to reduce latency.)
  180. *
  181. * Cool, huh? (Due to Josh Triplett.)
  182. *
  183. * But we want to make this a static inline later. The cond_resched()
  184. * currently makes this problematic.
  185. */
  186. void synchronize_sched(void)
  187. {
  188. cond_resched();
  189. }
  190. EXPORT_SYMBOL_GPL(synchronize_sched);
  191. /*
  192. * Helper function for call_rcu() and call_rcu_bh().
  193. */
  194. static void __call_rcu(struct rcu_head *head,
  195. void (*func)(struct rcu_head *rcu),
  196. struct rcu_ctrlblk *rcp)
  197. {
  198. unsigned long flags;
  199. debug_rcu_head_queue(head);
  200. head->func = func;
  201. head->next = NULL;
  202. local_irq_save(flags);
  203. *rcp->curtail = head;
  204. rcp->curtail = &head->next;
  205. RCU_TRACE(rcp->qlen++);
  206. local_irq_restore(flags);
  207. }
  208. /*
  209. * Post an RCU callback to be invoked after the end of an RCU-sched grace
  210. * period. But since we have but one CPU, that would be after any
  211. * quiescent state.
  212. */
  213. void call_rcu_sched(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
  214. {
  215. __call_rcu(head, func, &rcu_sched_ctrlblk);
  216. }
  217. EXPORT_SYMBOL_GPL(call_rcu_sched);
  218. /*
  219. * Post an RCU bottom-half callback to be invoked after any subsequent
  220. * quiescent state.
  221. */
  222. void call_rcu_bh(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
  223. {
  224. __call_rcu(head, func, &rcu_bh_ctrlblk);
  225. }
  226. EXPORT_SYMBOL_GPL(call_rcu_bh);