tiny.c 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  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, you can access it online at
  16. * http://www.gnu.org/licenses/gpl-2.0.html.
  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/completion.h>
  26. #include <linux/interrupt.h>
  27. #include <linux/notifier.h>
  28. #include <linux/rcupdate_wait.h>
  29. #include <linux/kernel.h>
  30. #include <linux/export.h>
  31. #include <linux/mutex.h>
  32. #include <linux/sched.h>
  33. #include <linux/types.h>
  34. #include <linux/init.h>
  35. #include <linux/time.h>
  36. #include <linux/cpu.h>
  37. #include <linux/prefetch.h>
  38. #include "rcu.h"
  39. /* Global control variables for rcupdate callback mechanism. */
  40. struct rcu_ctrlblk {
  41. struct rcu_head *rcucblist; /* List of pending callbacks (CBs). */
  42. struct rcu_head **donetail; /* ->next pointer of last "done" CB. */
  43. struct rcu_head **curtail; /* ->next pointer of last CB. */
  44. };
  45. /* Definition for rcupdate control block. */
  46. static struct rcu_ctrlblk rcu_sched_ctrlblk = {
  47. .donetail = &rcu_sched_ctrlblk.rcucblist,
  48. .curtail = &rcu_sched_ctrlblk.rcucblist,
  49. };
  50. static struct rcu_ctrlblk rcu_bh_ctrlblk = {
  51. .donetail = &rcu_bh_ctrlblk.rcucblist,
  52. .curtail = &rcu_bh_ctrlblk.rcucblist,
  53. };
  54. void rcu_barrier_bh(void)
  55. {
  56. wait_rcu_gp(call_rcu_bh);
  57. }
  58. EXPORT_SYMBOL(rcu_barrier_bh);
  59. void rcu_barrier_sched(void)
  60. {
  61. wait_rcu_gp(call_rcu_sched);
  62. }
  63. EXPORT_SYMBOL(rcu_barrier_sched);
  64. /*
  65. * Helper function for rcu_sched_qs() and rcu_bh_qs().
  66. * Also irqs are disabled to avoid confusion due to interrupt handlers
  67. * invoking call_rcu().
  68. */
  69. static int rcu_qsctr_help(struct rcu_ctrlblk *rcp)
  70. {
  71. if (rcp->donetail != rcp->curtail) {
  72. rcp->donetail = rcp->curtail;
  73. return 1;
  74. }
  75. return 0;
  76. }
  77. /*
  78. * Record an rcu quiescent state. And an rcu_bh quiescent state while we
  79. * are at it, given that any rcu quiescent state is also an rcu_bh
  80. * quiescent state. Use "+" instead of "||" to defeat short circuiting.
  81. */
  82. void rcu_sched_qs(void)
  83. {
  84. unsigned long flags;
  85. local_irq_save(flags);
  86. if (rcu_qsctr_help(&rcu_sched_ctrlblk) +
  87. rcu_qsctr_help(&rcu_bh_ctrlblk))
  88. raise_softirq(RCU_SOFTIRQ);
  89. local_irq_restore(flags);
  90. }
  91. /*
  92. * Record an rcu_bh quiescent state.
  93. */
  94. void rcu_bh_qs(void)
  95. {
  96. unsigned long flags;
  97. local_irq_save(flags);
  98. if (rcu_qsctr_help(&rcu_bh_ctrlblk))
  99. raise_softirq(RCU_SOFTIRQ);
  100. local_irq_restore(flags);
  101. }
  102. /*
  103. * Check to see if the scheduling-clock interrupt came from an extended
  104. * quiescent state, and, if so, tell RCU about it. This function must
  105. * be called from hardirq context. It is normally called from the
  106. * scheduling-clock interrupt.
  107. */
  108. void rcu_check_callbacks(int user)
  109. {
  110. if (user)
  111. rcu_sched_qs();
  112. if (user || !in_softirq())
  113. rcu_bh_qs();
  114. }
  115. /*
  116. * Invoke the RCU callbacks on the specified rcu_ctrlkblk structure
  117. * whose grace period has elapsed.
  118. */
  119. static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp)
  120. {
  121. struct rcu_head *next, *list;
  122. unsigned long flags;
  123. /* Move the ready-to-invoke callbacks to a local list. */
  124. local_irq_save(flags);
  125. if (rcp->donetail == &rcp->rcucblist) {
  126. /* No callbacks ready, so just leave. */
  127. local_irq_restore(flags);
  128. return;
  129. }
  130. list = rcp->rcucblist;
  131. rcp->rcucblist = *rcp->donetail;
  132. *rcp->donetail = NULL;
  133. if (rcp->curtail == rcp->donetail)
  134. rcp->curtail = &rcp->rcucblist;
  135. rcp->donetail = &rcp->rcucblist;
  136. local_irq_restore(flags);
  137. /* Invoke the callbacks on the local list. */
  138. while (list) {
  139. next = list->next;
  140. prefetch(next);
  141. debug_rcu_head_unqueue(list);
  142. local_bh_disable();
  143. __rcu_reclaim("", list);
  144. local_bh_enable();
  145. list = next;
  146. }
  147. }
  148. static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused)
  149. {
  150. __rcu_process_callbacks(&rcu_sched_ctrlblk);
  151. __rcu_process_callbacks(&rcu_bh_ctrlblk);
  152. }
  153. /*
  154. * Wait for a grace period to elapse. But it is illegal to invoke
  155. * synchronize_sched() from within an RCU read-side critical section.
  156. * Therefore, any legal call to synchronize_sched() is a quiescent
  157. * state, and so on a UP system, synchronize_sched() need do nothing.
  158. * Ditto for synchronize_rcu_bh(). (But Lai Jiangshan points out the
  159. * benefits of doing might_sleep() to reduce latency.)
  160. *
  161. * Cool, huh? (Due to Josh Triplett.)
  162. */
  163. void synchronize_sched(void)
  164. {
  165. RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map) ||
  166. lock_is_held(&rcu_lock_map) ||
  167. lock_is_held(&rcu_sched_lock_map),
  168. "Illegal synchronize_sched() in RCU read-side critical section");
  169. }
  170. EXPORT_SYMBOL_GPL(synchronize_sched);
  171. /*
  172. * Helper function for call_rcu() and call_rcu_bh().
  173. */
  174. static void __call_rcu(struct rcu_head *head,
  175. rcu_callback_t func,
  176. struct rcu_ctrlblk *rcp)
  177. {
  178. unsigned long flags;
  179. debug_rcu_head_queue(head);
  180. head->func = func;
  181. head->next = NULL;
  182. local_irq_save(flags);
  183. *rcp->curtail = head;
  184. rcp->curtail = &head->next;
  185. local_irq_restore(flags);
  186. if (unlikely(is_idle_task(current))) {
  187. /* force scheduling for rcu_sched_qs() */
  188. resched_cpu(0);
  189. }
  190. }
  191. /*
  192. * Post an RCU callback to be invoked after the end of an RCU-sched grace
  193. * period. But since we have but one CPU, that would be after any
  194. * quiescent state.
  195. */
  196. void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
  197. {
  198. __call_rcu(head, func, &rcu_sched_ctrlblk);
  199. }
  200. EXPORT_SYMBOL_GPL(call_rcu_sched);
  201. /*
  202. * Post an RCU bottom-half callback to be invoked after any subsequent
  203. * quiescent state.
  204. */
  205. void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
  206. {
  207. __call_rcu(head, func, &rcu_bh_ctrlblk);
  208. }
  209. EXPORT_SYMBOL_GPL(call_rcu_bh);
  210. void __init rcu_init(void)
  211. {
  212. open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
  213. rcu_early_boot_tests();
  214. }