24f43165f222b8d6c6bfa2f1293204188469d5a5
[linux-2.6.git] / kernel / rcutiny_plugin.h
1 /*
2  * Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition
3  * Internal non-public definitions that provide either classic
4  * or preemptible semantics.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  *
20  * Copyright (c) 2010 Linaro
21  *
22  * Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
23  */
24
25 #include <linux/kthread.h>
26
27 /* Global control variables for rcupdate callback mechanism. */
28 struct rcu_ctrlblk {
29         struct rcu_head *rcucblist;     /* List of pending callbacks (CBs). */
30         struct rcu_head **donetail;     /* ->next pointer of last "done" CB. */
31         struct rcu_head **curtail;      /* ->next pointer of last CB. */
32 };
33
34 /* Definition for rcupdate control block. */
35 static struct rcu_ctrlblk rcu_sched_ctrlblk = {
36         .donetail       = &rcu_sched_ctrlblk.rcucblist,
37         .curtail        = &rcu_sched_ctrlblk.rcucblist,
38 };
39
40 static struct rcu_ctrlblk rcu_bh_ctrlblk = {
41         .donetail       = &rcu_bh_ctrlblk.rcucblist,
42         .curtail        = &rcu_bh_ctrlblk.rcucblist,
43 };
44
45 #ifdef CONFIG_DEBUG_LOCK_ALLOC
46 int rcu_scheduler_active __read_mostly;
47 EXPORT_SYMBOL_GPL(rcu_scheduler_active);
48 #endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
49
50 #ifdef CONFIG_TINY_PREEMPT_RCU
51
52 #include <linux/delay.h>
53
54 /* Global control variables for preemptible RCU. */
55 struct rcu_preempt_ctrlblk {
56         struct rcu_ctrlblk rcb; /* curtail: ->next ptr of last CB for GP. */
57         struct rcu_head **nexttail;
58                                 /* Tasks blocked in a preemptible RCU */
59                                 /*  read-side critical section while an */
60                                 /*  preemptible-RCU grace period is in */
61                                 /*  progress must wait for a later grace */
62                                 /*  period.  This pointer points to the */
63                                 /*  ->next pointer of the last task that */
64                                 /*  must wait for a later grace period, or */
65                                 /*  to &->rcb.rcucblist if there is no */
66                                 /*  such task. */
67         struct list_head blkd_tasks;
68                                 /* Tasks blocked in RCU read-side critical */
69                                 /*  section.  Tasks are placed at the head */
70                                 /*  of this list and age towards the tail. */
71         struct list_head *gp_tasks;
72                                 /* Pointer to the first task blocking the */
73                                 /*  current grace period, or NULL if there */
74                                 /*  is no such task. */
75         struct list_head *exp_tasks;
76                                 /* Pointer to first task blocking the */
77                                 /*  current expedited grace period, or NULL */
78                                 /*  if there is no such task.  If there */
79                                 /*  is no current expedited grace period, */
80                                 /*  then there cannot be any such task. */
81 #ifdef CONFIG_RCU_BOOST
82         struct list_head *boost_tasks;
83                                 /* Pointer to first task that needs to be */
84                                 /*  priority-boosted, or NULL if no priority */
85                                 /*  boosting is needed.  If there is no */
86                                 /*  current or expedited grace period, there */
87                                 /*  can be no such task. */
88 #endif /* #ifdef CONFIG_RCU_BOOST */
89         u8 gpnum;               /* Current grace period. */
90         u8 gpcpu;               /* Last grace period blocked by the CPU. */
91         u8 completed;           /* Last grace period completed. */
92                                 /*  If all three are equal, RCU is idle. */
93         s8 boosted_this_gp;     /* Has boosting already happened? */
94         unsigned long boost_time; /* When to start boosting (jiffies) */
95 };
96
97 static struct rcu_preempt_ctrlblk rcu_preempt_ctrlblk = {
98         .rcb.donetail = &rcu_preempt_ctrlblk.rcb.rcucblist,
99         .rcb.curtail = &rcu_preempt_ctrlblk.rcb.rcucblist,
100         .nexttail = &rcu_preempt_ctrlblk.rcb.rcucblist,
101         .blkd_tasks = LIST_HEAD_INIT(rcu_preempt_ctrlblk.blkd_tasks),
102 };
103
104 static int rcu_preempted_readers_exp(void);
105 static void rcu_report_exp_done(void);
106
107 /*
108  * Return true if the CPU has not yet responded to the current grace period.
109  */
110 static int rcu_cpu_blocking_cur_gp(void)
111 {
112         return rcu_preempt_ctrlblk.gpcpu != rcu_preempt_ctrlblk.gpnum;
113 }
114
115 /*
116  * Check for a running RCU reader.  Because there is only one CPU,
117  * there can be but one running RCU reader at a time.  ;-)
118  */
119 static int rcu_preempt_running_reader(void)
120 {
121         return current->rcu_read_lock_nesting;
122 }
123
124 /*
125  * Check for preempted RCU readers blocking any grace period.
126  * If the caller needs a reliable answer, it must disable hard irqs.
127  */
128 static int rcu_preempt_blocked_readers_any(void)
129 {
130         return !list_empty(&rcu_preempt_ctrlblk.blkd_tasks);
131 }
132
133 /*
134  * Check for preempted RCU readers blocking the current grace period.
135  * If the caller needs a reliable answer, it must disable hard irqs.
136  */
137 static int rcu_preempt_blocked_readers_cgp(void)
138 {
139         return rcu_preempt_ctrlblk.gp_tasks != NULL;
140 }
141
142 /*
143  * Return true if another preemptible-RCU grace period is needed.
144  */
145 static int rcu_preempt_needs_another_gp(void)
146 {
147         return *rcu_preempt_ctrlblk.rcb.curtail != NULL;
148 }
149
150 /*
151  * Return true if a preemptible-RCU grace period is in progress.
152  * The caller must disable hardirqs.
153  */
154 static int rcu_preempt_gp_in_progress(void)
155 {
156         return rcu_preempt_ctrlblk.completed != rcu_preempt_ctrlblk.gpnum;
157 }
158
159 /*
160  * Advance a ->blkd_tasks-list pointer to the next entry, instead
161  * returning NULL if at the end of the list.
162  */
163 static struct list_head *rcu_next_node_entry(struct task_struct *t)
164 {
165         struct list_head *np;
166
167         np = t->rcu_node_entry.next;
168         if (np == &rcu_preempt_ctrlblk.blkd_tasks)
169                 np = NULL;
170         return np;
171 }
172
173 #ifdef CONFIG_RCU_BOOST
174
175 #include "rtmutex_common.h"
176
177 /*
178  * Carry out RCU priority boosting on the task indicated by ->boost_tasks,
179  * and advance ->boost_tasks to the next task in the ->blkd_tasks list.
180  */
181 static int rcu_boost(void)
182 {
183         unsigned long flags;
184         struct rt_mutex mtx;
185         struct list_head *np;
186         struct task_struct *t;
187
188         if (rcu_preempt_ctrlblk.boost_tasks == NULL)
189                 return 0;  /* Nothing to boost. */
190         raw_local_irq_save(flags);
191         rcu_preempt_ctrlblk.boosted_this_gp++;
192         t = container_of(rcu_preempt_ctrlblk.boost_tasks, struct task_struct,
193                          rcu_node_entry);
194         np = rcu_next_node_entry(t);
195         rt_mutex_init_proxy_locked(&mtx, t);
196         t->rcu_boost_mutex = &mtx;
197         t->rcu_read_unlock_special |= RCU_READ_UNLOCK_BOOSTED;
198         raw_local_irq_restore(flags);
199         rt_mutex_lock(&mtx);
200         rt_mutex_unlock(&mtx);
201         return rcu_preempt_ctrlblk.boost_tasks != NULL;
202 }
203
204 /*
205  * Check to see if it is now time to start boosting RCU readers blocking
206  * the current grace period, and, if so, tell the rcu_kthread_task to
207  * start boosting them.  If there is an expedited boost in progress,
208  * we wait for it to complete.
209  */
210 static void rcu_initiate_boost(void)
211 {
212         if (rcu_preempt_ctrlblk.gp_tasks != NULL &&
213             rcu_preempt_ctrlblk.boost_tasks == NULL &&
214             rcu_preempt_ctrlblk.boosted_this_gp == 0 &&
215             ULONG_CMP_GE(jiffies, rcu_preempt_ctrlblk.boost_time)) {
216                 rcu_preempt_ctrlblk.boost_tasks = rcu_preempt_ctrlblk.gp_tasks;
217                 invoke_rcu_kthread();
218         }
219 }
220
221 /*
222  * Initiate boosting for an expedited grace period.
223  */
224 static void rcu_initiate_expedited_boost(void)
225 {
226         unsigned long flags;
227
228         raw_local_irq_save(flags);
229         if (!list_empty(&rcu_preempt_ctrlblk.blkd_tasks)) {
230                 rcu_preempt_ctrlblk.boost_tasks =
231                         rcu_preempt_ctrlblk.blkd_tasks.next;
232                 rcu_preempt_ctrlblk.boosted_this_gp = -1;
233                 invoke_rcu_kthread();
234         }
235         raw_local_irq_restore(flags);
236 }
237
238 #define RCU_BOOST_DELAY_JIFFIES DIV_ROUND_UP(CONFIG_RCU_BOOST_DELAY * HZ, 1000);
239
240 /*
241  * Do priority-boost accounting for the start of a new grace period.
242  */
243 static void rcu_preempt_boost_start_gp(void)
244 {
245         rcu_preempt_ctrlblk.boost_time = jiffies + RCU_BOOST_DELAY_JIFFIES;
246         if (rcu_preempt_ctrlblk.boosted_this_gp > 0)
247                 rcu_preempt_ctrlblk.boosted_this_gp = 0;
248 }
249
250 #else /* #ifdef CONFIG_RCU_BOOST */
251
252 /*
253  * If there is no RCU priority boosting, we don't boost.
254  */
255 static int rcu_boost(void)
256 {
257         return 0;
258 }
259
260 /*
261  * If there is no RCU priority boosting, we don't initiate boosting.
262  */
263 static void rcu_initiate_boost(void)
264 {
265 }
266
267 /*
268  * If there is no RCU priority boosting, we don't initiate expedited boosting.
269  */
270 static void rcu_initiate_expedited_boost(void)
271 {
272 }
273
274 /*
275  * If there is no RCU priority boosting, nothing to do at grace-period start.
276  */
277 static void rcu_preempt_boost_start_gp(void)
278 {
279 }
280
281 #endif /* else #ifdef CONFIG_RCU_BOOST */
282
283 /*
284  * Record a preemptible-RCU quiescent state for the specified CPU.  Note
285  * that this just means that the task currently running on the CPU is
286  * in a quiescent state.  There might be any number of tasks blocked
287  * while in an RCU read-side critical section.
288  *
289  * Unlike the other rcu_*_qs() functions, callers to this function
290  * must disable irqs in order to protect the assignment to
291  * ->rcu_read_unlock_special.
292  *
293  * Because this is a single-CPU implementation, the only way a grace
294  * period can end is if the CPU is in a quiescent state.  The reason is
295  * that a blocked preemptible-RCU reader can exit its critical section
296  * only if the CPU is running it at the time.  Therefore, when the
297  * last task blocking the current grace period exits its RCU read-side
298  * critical section, neither the CPU nor blocked tasks will be stopping
299  * the current grace period.  (In contrast, SMP implementations
300  * might have CPUs running in RCU read-side critical sections that
301  * block later grace periods -- but this is not possible given only
302  * one CPU.)
303  */
304 static void rcu_preempt_cpu_qs(void)
305 {
306         /* Record both CPU and task as having responded to current GP. */
307         rcu_preempt_ctrlblk.gpcpu = rcu_preempt_ctrlblk.gpnum;
308         current->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_NEED_QS;
309
310         /* If there is no GP then there is nothing more to do.  */
311         if (!rcu_preempt_gp_in_progress() || rcu_preempt_blocked_readers_cgp())
312                 return;
313         /* If there are blocked readers, go check up on boosting. */
314         if (rcu_preempt_blocked_readers_cgp()) {
315                 rcu_initiate_boost();
316                 return;
317         }
318
319         /* Advance callbacks. */
320         rcu_preempt_ctrlblk.completed = rcu_preempt_ctrlblk.gpnum;
321         rcu_preempt_ctrlblk.rcb.donetail = rcu_preempt_ctrlblk.rcb.curtail;
322         rcu_preempt_ctrlblk.rcb.curtail = rcu_preempt_ctrlblk.nexttail;
323
324         /* If there are no blocked readers, next GP is done instantly. */
325         if (!rcu_preempt_blocked_readers_any())
326                 rcu_preempt_ctrlblk.rcb.donetail = rcu_preempt_ctrlblk.nexttail;
327
328         /* If there are done callbacks, cause them to be invoked. */
329         if (*rcu_preempt_ctrlblk.rcb.donetail != NULL)
330                 invoke_rcu_kthread();
331 }
332
333 /*
334  * Start a new RCU grace period if warranted.  Hard irqs must be disabled.
335  */
336 static void rcu_preempt_start_gp(void)
337 {
338         if (!rcu_preempt_gp_in_progress() && rcu_preempt_needs_another_gp()) {
339
340                 /* Official start of GP. */
341                 rcu_preempt_ctrlblk.gpnum++;
342
343                 /* Any blocked RCU readers block new GP. */
344                 if (rcu_preempt_blocked_readers_any())
345                         rcu_preempt_ctrlblk.gp_tasks =
346                                 rcu_preempt_ctrlblk.blkd_tasks.next;
347
348                 /* Set up for RCU priority boosting. */
349                 rcu_preempt_boost_start_gp();
350
351                 /* If there is no running reader, CPU is done with GP. */
352                 if (!rcu_preempt_running_reader())
353                         rcu_preempt_cpu_qs();
354         }
355 }
356
357 /*
358  * We have entered the scheduler, and the current task might soon be
359  * context-switched away from.  If this task is in an RCU read-side
360  * critical section, we will no longer be able to rely on the CPU to
361  * record that fact, so we enqueue the task on the blkd_tasks list.
362  * If the task started after the current grace period began, as recorded
363  * by ->gpcpu, we enqueue at the beginning of the list.  Otherwise
364  * before the element referenced by ->gp_tasks (or at the tail if
365  * ->gp_tasks is NULL) and point ->gp_tasks at the newly added element.
366  * The task will dequeue itself when it exits the outermost enclosing
367  * RCU read-side critical section.  Therefore, the current grace period
368  * cannot be permitted to complete until the ->gp_tasks pointer becomes
369  * NULL.
370  *
371  * Caller must disable preemption.
372  */
373 void rcu_preempt_note_context_switch(void)
374 {
375         struct task_struct *t = current;
376         unsigned long flags;
377
378         local_irq_save(flags); /* must exclude scheduler_tick(). */
379         if (rcu_preempt_running_reader() &&
380             (t->rcu_read_unlock_special & RCU_READ_UNLOCK_BLOCKED) == 0) {
381
382                 /* Possibly blocking in an RCU read-side critical section. */
383                 t->rcu_read_unlock_special |= RCU_READ_UNLOCK_BLOCKED;
384
385                 /*
386                  * If this CPU has already checked in, then this task
387                  * will hold up the next grace period rather than the
388                  * current grace period.  Queue the task accordingly.
389                  * If the task is queued for the current grace period
390                  * (i.e., this CPU has not yet passed through a quiescent
391                  * state for the current grace period), then as long
392                  * as that task remains queued, the current grace period
393                  * cannot end.
394                  */
395                 list_add(&t->rcu_node_entry, &rcu_preempt_ctrlblk.blkd_tasks);
396                 if (rcu_cpu_blocking_cur_gp())
397                         rcu_preempt_ctrlblk.gp_tasks = &t->rcu_node_entry;
398         }
399
400         /*
401          * Either we were not in an RCU read-side critical section to
402          * begin with, or we have now recorded that critical section
403          * globally.  Either way, we can now note a quiescent state
404          * for this CPU.  Again, if we were in an RCU read-side critical
405          * section, and if that critical section was blocking the current
406          * grace period, then the fact that the task has been enqueued
407          * means that current grace period continues to be blocked.
408          */
409         rcu_preempt_cpu_qs();
410         local_irq_restore(flags);
411 }
412
413 /*
414  * Tiny-preemptible RCU implementation for rcu_read_lock().
415  * Just increment ->rcu_read_lock_nesting, shared state will be updated
416  * if we block.
417  */
418 void __rcu_read_lock(void)
419 {
420         current->rcu_read_lock_nesting++;
421         barrier();  /* needed if we ever invoke rcu_read_lock in rcutiny.c */
422 }
423 EXPORT_SYMBOL_GPL(__rcu_read_lock);
424
425 /*
426  * Handle special cases during rcu_read_unlock(), such as needing to
427  * notify RCU core processing or task having blocked during the RCU
428  * read-side critical section.
429  */
430 static void rcu_read_unlock_special(struct task_struct *t)
431 {
432         int empty;
433         int empty_exp;
434         unsigned long flags;
435         struct list_head *np;
436         int special;
437
438         /*
439          * NMI handlers cannot block and cannot safely manipulate state.
440          * They therefore cannot possibly be special, so just leave.
441          */
442         if (in_nmi())
443                 return;
444
445         local_irq_save(flags);
446
447         /*
448          * If RCU core is waiting for this CPU to exit critical section,
449          * let it know that we have done so.
450          */
451         special = t->rcu_read_unlock_special;
452         if (special & RCU_READ_UNLOCK_NEED_QS)
453                 rcu_preempt_cpu_qs();
454
455         /* Hardware IRQ handlers cannot block. */
456         if (in_irq()) {
457                 local_irq_restore(flags);
458                 return;
459         }
460
461         /* Clean up if blocked during RCU read-side critical section. */
462         if (special & RCU_READ_UNLOCK_BLOCKED) {
463                 t->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_BLOCKED;
464
465                 /*
466                  * Remove this task from the ->blkd_tasks list and adjust
467                  * any pointers that might have been referencing it.
468                  */
469                 empty = !rcu_preempt_blocked_readers_cgp();
470                 empty_exp = rcu_preempt_ctrlblk.exp_tasks == NULL;
471                 np = rcu_next_node_entry(t);
472                 list_del(&t->rcu_node_entry);
473                 if (&t->rcu_node_entry == rcu_preempt_ctrlblk.gp_tasks)
474                         rcu_preempt_ctrlblk.gp_tasks = np;
475                 if (&t->rcu_node_entry == rcu_preempt_ctrlblk.exp_tasks)
476                         rcu_preempt_ctrlblk.exp_tasks = np;
477 #ifdef CONFIG_RCU_BOOST
478                 if (&t->rcu_node_entry == rcu_preempt_ctrlblk.boost_tasks)
479                         rcu_preempt_ctrlblk.boost_tasks = np;
480 #endif /* #ifdef CONFIG_RCU_BOOST */
481                 INIT_LIST_HEAD(&t->rcu_node_entry);
482
483                 /*
484                  * If this was the last task on the current list, and if
485                  * we aren't waiting on the CPU, report the quiescent state
486                  * and start a new grace period if needed.
487                  */
488                 if (!empty && !rcu_preempt_blocked_readers_cgp()) {
489                         rcu_preempt_cpu_qs();
490                         rcu_preempt_start_gp();
491                 }
492
493                 /*
494                  * If this was the last task on the expedited lists,
495                  * then we need wake up the waiting task.
496                  */
497                 if (!empty_exp && rcu_preempt_ctrlblk.exp_tasks == NULL)
498                         rcu_report_exp_done();
499         }
500 #ifdef CONFIG_RCU_BOOST
501         /* Unboost self if was boosted. */
502         if (special & RCU_READ_UNLOCK_BOOSTED) {
503                 t->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_BOOSTED;
504                 rt_mutex_unlock(t->rcu_boost_mutex);
505                 t->rcu_boost_mutex = NULL;
506         }
507 #endif /* #ifdef CONFIG_RCU_BOOST */
508         local_irq_restore(flags);
509 }
510
511 /*
512  * Tiny-preemptible RCU implementation for rcu_read_unlock().
513  * Decrement ->rcu_read_lock_nesting.  If the result is zero (outermost
514  * rcu_read_unlock()) and ->rcu_read_unlock_special is non-zero, then
515  * invoke rcu_read_unlock_special() to clean up after a context switch
516  * in an RCU read-side critical section and other special cases.
517  */
518 void __rcu_read_unlock(void)
519 {
520         struct task_struct *t = current;
521
522         barrier();  /* needed if we ever invoke rcu_read_unlock in rcutiny.c */
523         --t->rcu_read_lock_nesting;
524         barrier();  /* decrement before load of ->rcu_read_unlock_special */
525         if (t->rcu_read_lock_nesting == 0 &&
526             unlikely(ACCESS_ONCE(t->rcu_read_unlock_special)))
527                 rcu_read_unlock_special(t);
528 #ifdef CONFIG_PROVE_LOCKING
529         WARN_ON_ONCE(t->rcu_read_lock_nesting < 0);
530 #endif /* #ifdef CONFIG_PROVE_LOCKING */
531 }
532 EXPORT_SYMBOL_GPL(__rcu_read_unlock);
533
534 /*
535  * Check for a quiescent state from the current CPU.  When a task blocks,
536  * the task is recorded in the rcu_preempt_ctrlblk structure, which is
537  * checked elsewhere.  This is called from the scheduling-clock interrupt.
538  *
539  * Caller must disable hard irqs.
540  */
541 static void rcu_preempt_check_callbacks(void)
542 {
543         struct task_struct *t = current;
544
545         if (rcu_preempt_gp_in_progress() &&
546             (!rcu_preempt_running_reader() ||
547              !rcu_cpu_blocking_cur_gp()))
548                 rcu_preempt_cpu_qs();
549         if (&rcu_preempt_ctrlblk.rcb.rcucblist !=
550             rcu_preempt_ctrlblk.rcb.donetail)
551                 invoke_rcu_kthread();
552         if (rcu_preempt_gp_in_progress() &&
553             rcu_cpu_blocking_cur_gp() &&
554             rcu_preempt_running_reader())
555                 t->rcu_read_unlock_special |= RCU_READ_UNLOCK_NEED_QS;
556 }
557
558 /*
559  * TINY_PREEMPT_RCU has an extra callback-list tail pointer to
560  * update, so this is invoked from rcu_process_callbacks() to
561  * handle that case.  Of course, it is invoked for all flavors of
562  * RCU, but RCU callbacks can appear only on one of the lists, and
563  * neither ->nexttail nor ->donetail can possibly be NULL, so there
564  * is no need for an explicit check.
565  */
566 static void rcu_preempt_remove_callbacks(struct rcu_ctrlblk *rcp)
567 {
568         if (rcu_preempt_ctrlblk.nexttail == rcp->donetail)
569                 rcu_preempt_ctrlblk.nexttail = &rcp->rcucblist;
570 }
571
572 /*
573  * Process callbacks for preemptible RCU.
574  */
575 static void rcu_preempt_process_callbacks(void)
576 {
577         rcu_process_callbacks(&rcu_preempt_ctrlblk.rcb);
578 }
579
580 /*
581  * Queue a preemptible -RCU callback for invocation after a grace period.
582  */
583 void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
584 {
585         unsigned long flags;
586
587         debug_rcu_head_queue(head);
588         head->func = func;
589         head->next = NULL;
590
591         local_irq_save(flags);
592         *rcu_preempt_ctrlblk.nexttail = head;
593         rcu_preempt_ctrlblk.nexttail = &head->next;
594         rcu_preempt_start_gp();  /* checks to see if GP needed. */
595         local_irq_restore(flags);
596 }
597 EXPORT_SYMBOL_GPL(call_rcu);
598
599 void rcu_barrier(void)
600 {
601         struct rcu_synchronize rcu;
602
603         init_rcu_head_on_stack(&rcu.head);
604         init_completion(&rcu.completion);
605         /* Will wake me after RCU finished. */
606         call_rcu(&rcu.head, wakeme_after_rcu);
607         /* Wait for it. */
608         wait_for_completion(&rcu.completion);
609         destroy_rcu_head_on_stack(&rcu.head);
610 }
611 EXPORT_SYMBOL_GPL(rcu_barrier);
612
613 /*
614  * synchronize_rcu - wait until a grace period has elapsed.
615  *
616  * Control will return to the caller some time after a full grace
617  * period has elapsed, in other words after all currently executing RCU
618  * read-side critical sections have completed.  RCU read-side critical
619  * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
620  * and may be nested.
621  */
622 void synchronize_rcu(void)
623 {
624 #ifdef CONFIG_DEBUG_LOCK_ALLOC
625         if (!rcu_scheduler_active)
626                 return;
627 #endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
628
629         WARN_ON_ONCE(rcu_preempt_running_reader());
630         if (!rcu_preempt_blocked_readers_any())
631                 return;
632
633         /* Once we get past the fastpath checks, same code as rcu_barrier(). */
634         rcu_barrier();
635 }
636 EXPORT_SYMBOL_GPL(synchronize_rcu);
637
638 static DECLARE_WAIT_QUEUE_HEAD(sync_rcu_preempt_exp_wq);
639 static unsigned long sync_rcu_preempt_exp_count;
640 static DEFINE_MUTEX(sync_rcu_preempt_exp_mutex);
641
642 /*
643  * Return non-zero if there are any tasks in RCU read-side critical
644  * sections blocking the current preemptible-RCU expedited grace period.
645  * If there is no preemptible-RCU expedited grace period currently in
646  * progress, returns zero unconditionally.
647  */
648 static int rcu_preempted_readers_exp(void)
649 {
650         return rcu_preempt_ctrlblk.exp_tasks != NULL;
651 }
652
653 /*
654  * Report the exit from RCU read-side critical section for the last task
655  * that queued itself during or before the current expedited preemptible-RCU
656  * grace period.
657  */
658 static void rcu_report_exp_done(void)
659 {
660         wake_up(&sync_rcu_preempt_exp_wq);
661 }
662
663 /*
664  * Wait for an rcu-preempt grace period, but expedite it.  The basic idea
665  * is to rely in the fact that there is but one CPU, and that it is
666  * illegal for a task to invoke synchronize_rcu_expedited() while in a
667  * preemptible-RCU read-side critical section.  Therefore, any such
668  * critical sections must correspond to blocked tasks, which must therefore
669  * be on the ->blkd_tasks list.  So just record the current head of the
670  * list in the ->exp_tasks pointer, and wait for all tasks including and
671  * after the task pointed to by ->exp_tasks to drain.
672  */
673 void synchronize_rcu_expedited(void)
674 {
675         unsigned long flags;
676         struct rcu_preempt_ctrlblk *rpcp = &rcu_preempt_ctrlblk;
677         unsigned long snap;
678
679         barrier(); /* ensure prior action seen before grace period. */
680
681         WARN_ON_ONCE(rcu_preempt_running_reader());
682
683         /*
684          * Acquire lock so that there is only one preemptible RCU grace
685          * period in flight.  Of course, if someone does the expedited
686          * grace period for us while we are acquiring the lock, just leave.
687          */
688         snap = sync_rcu_preempt_exp_count + 1;
689         mutex_lock(&sync_rcu_preempt_exp_mutex);
690         if (ULONG_CMP_LT(snap, sync_rcu_preempt_exp_count))
691                 goto unlock_mb_ret; /* Others did our work for us. */
692
693         local_irq_save(flags);
694
695         /*
696          * All RCU readers have to already be on blkd_tasks because
697          * we cannot legally be executing in an RCU read-side critical
698          * section.
699          */
700
701         /* Snapshot current head of ->blkd_tasks list. */
702         rpcp->exp_tasks = rpcp->blkd_tasks.next;
703         if (rpcp->exp_tasks == &rpcp->blkd_tasks)
704                 rpcp->exp_tasks = NULL;
705         local_irq_restore(flags);
706
707         /* Wait for tail of ->blkd_tasks list to drain. */
708         if (rcu_preempted_readers_exp())
709                 rcu_initiate_expedited_boost();
710                 wait_event(sync_rcu_preempt_exp_wq,
711                            !rcu_preempted_readers_exp());
712
713         /* Clean up and exit. */
714         barrier(); /* ensure expedited GP seen before counter increment. */
715         sync_rcu_preempt_exp_count++;
716 unlock_mb_ret:
717         mutex_unlock(&sync_rcu_preempt_exp_mutex);
718         barrier(); /* ensure subsequent action seen after grace period. */
719 }
720 EXPORT_SYMBOL_GPL(synchronize_rcu_expedited);
721
722 /*
723  * Does preemptible RCU need the CPU to stay out of dynticks mode?
724  */
725 int rcu_preempt_needs_cpu(void)
726 {
727         if (!rcu_preempt_running_reader())
728                 rcu_preempt_cpu_qs();
729         return rcu_preempt_ctrlblk.rcb.rcucblist != NULL;
730 }
731
732 /*
733  * Check for a task exiting while in a preemptible -RCU read-side
734  * critical section, clean up if so.  No need to issue warnings,
735  * as debug_check_no_locks_held() already does this if lockdep
736  * is enabled.
737  */
738 void exit_rcu(void)
739 {
740         struct task_struct *t = current;
741
742         if (t->rcu_read_lock_nesting == 0)
743                 return;
744         t->rcu_read_lock_nesting = 1;
745         rcu_read_unlock();
746 }
747
748 #else /* #ifdef CONFIG_TINY_PREEMPT_RCU */
749
750 /*
751  * Because preemptible RCU does not exist, it is never necessary to
752  * boost preempted RCU readers.
753  */
754 static int rcu_boost(void)
755 {
756         return 0;
757 }
758
759 /*
760  * Because preemptible RCU does not exist, it never has any callbacks
761  * to check.
762  */
763 static void rcu_preempt_check_callbacks(void)
764 {
765 }
766
767 /*
768  * Because preemptible RCU does not exist, it never has any callbacks
769  * to remove.
770  */
771 static void rcu_preempt_remove_callbacks(struct rcu_ctrlblk *rcp)
772 {
773 }
774
775 /*
776  * Because preemptible RCU does not exist, it never has any callbacks
777  * to process.
778  */
779 static void rcu_preempt_process_callbacks(void)
780 {
781 }
782
783 #endif /* #else #ifdef CONFIG_TINY_PREEMPT_RCU */
784
785 #ifdef CONFIG_DEBUG_LOCK_ALLOC
786 #include <linux/kernel_stat.h>
787
788 /*
789  * During boot, we forgive RCU lockdep issues.  After this function is
790  * invoked, we start taking RCU lockdep issues seriously.
791  */
792 void __init rcu_scheduler_starting(void)
793 {
794         WARN_ON(nr_context_switches() > 0);
795         rcu_scheduler_active = 1;
796 }
797
798 #endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
799
800 #ifdef CONFIG_RCU_BOOST
801 #define RCU_BOOST_PRIO CONFIG_RCU_BOOST_PRIO
802 #else /* #ifdef CONFIG_RCU_BOOST */
803 #define RCU_BOOST_PRIO 1
804 #endif /* #else #ifdef CONFIG_RCU_BOOST */