blob: e012b9be777e3ba00ccf2fe4d05df78b78abd8f5 [file] [log] [blame]
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001/*
2 * Read-Copy Update mechanism for mutual exclusion (tree-based version)
3 * Internal non-public definitions that provide either classic
Paul E. McKenney6cc68792011-03-02 13:15:15 -08004 * or preemptible semantics.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07005 *
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
Paul E. McKenney87de1cf2013-12-03 10:02:52 -080017 * along with this program; if not, you can access it online at
18 * http://www.gnu.org/licenses/gpl-2.0.html.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -070019 *
20 * Copyright Red Hat, 2009
21 * Copyright IBM Corporation, 2009
22 *
23 * Author: Ingo Molnar <mingo@elte.hu>
24 * Paul E. McKenney <paulmck@linux.vnet.ibm.com>
25 */
26
Paul E. McKenneyd9a3da02009-12-02 12:10:15 -080027#include <linux/delay.h>
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -070028#include <linux/gfp.h>
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -070029#include <linux/oom.h>
Ingo Molnarb17b0152017-02-08 18:51:35 +010030#include <linux/sched/debug.h>
Paul E. McKenney62ab7072012-07-16 10:42:38 +000031#include <linux/smpboot.h>
Ingo Molnarae7e81c2017-02-01 18:07:51 +010032#include <uapi/linux/sched/types.h>
Paul E. McKenney4102ada2013-10-08 20:23:47 -070033#include "../time/tick-internal.h"
Paul E. McKenneyf41d9112009-08-22 13:56:52 -070034
Mike Galbraith5b61b0b2011-08-19 11:39:11 -070035#ifdef CONFIG_RCU_BOOST
Paul E. McKenney61cfd092014-09-02 12:30:58 -070036
Paul E. McKenneyabaa93d2014-06-12 13:30:25 -070037#include "../locking/rtmutex_common.h"
Clark Williams21871d72014-09-12 21:21:09 -050038
Paul E. McKenney61cfd092014-09-02 12:30:58 -070039/*
40 * Control variables for per-CPU and per-rcu_node kthreads. These
41 * handle all flavors of RCU.
42 */
43static DEFINE_PER_CPU(struct task_struct *, rcu_cpu_kthread_task);
44DEFINE_PER_CPU(unsigned int, rcu_cpu_kthread_status);
45DEFINE_PER_CPU(unsigned int, rcu_cpu_kthread_loops);
46DEFINE_PER_CPU(char, rcu_cpu_has_work);
47
Paul E. McKenney727b7052015-03-03 14:49:26 -080048#else /* #ifdef CONFIG_RCU_BOOST */
49
50/*
51 * Some architectures do not define rt_mutexes, but if !CONFIG_RCU_BOOST,
52 * all uses are in dead code. Provide a definition to keep the compiler
53 * happy, but add WARN_ON_ONCE() to complain if used in the wrong place.
54 * This probably needs to be excluded from -rt builds.
55 */
56#define rt_mutex_owner(a) ({ WARN_ON_ONCE(1); NULL; })
57
58#endif /* #else #ifdef CONFIG_RCU_BOOST */
Mike Galbraith5b61b0b2011-08-19 11:39:11 -070059
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -070060#ifdef CONFIG_RCU_NOCB_CPU
61static cpumask_var_t rcu_nocb_mask; /* CPUs to have callbacks offloaded. */
62static bool have_rcu_nocb_mask; /* Was rcu_nocb_mask allocated? */
Paul Gortmaker1b0048a2012-12-20 13:19:22 -080063static bool __read_mostly rcu_nocb_poll; /* Offload kthread are to poll. */
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -070064#endif /* #ifdef CONFIG_RCU_NOCB_CPU */
65
Paul E. McKenney26845c22010-04-13 14:19:23 -070066/*
67 * Check the RCU kernel configuration parameters and print informative
Paul E. McKenney699d4032015-09-29 08:47:49 -070068 * messages about anything out of the ordinary.
Paul E. McKenney26845c22010-04-13 14:19:23 -070069 */
70static void __init rcu_bootup_announce_oddness(void)
71{
Paul E. McKenneyab6f5bd2015-01-21 16:58:06 -080072 if (IS_ENABLED(CONFIG_RCU_TRACE))
Paul E. McKenneyae91aa02017-05-15 15:30:32 -070073 pr_info("\tRCU event tracing is enabled.\n");
Paul E. McKenney05c5df32015-04-20 14:27:43 -070074 if ((IS_ENABLED(CONFIG_64BIT) && RCU_FANOUT != 64) ||
75 (!IS_ENABLED(CONFIG_64BIT) && RCU_FANOUT != 32))
Paul E. McKenneyab6f5bd2015-01-21 16:58:06 -080076 pr_info("\tCONFIG_RCU_FANOUT set to non-default value of %d\n",
Paul E. McKenney05c5df32015-04-20 14:27:43 -070077 RCU_FANOUT);
Paul E. McKenney7fa27002015-04-20 10:27:15 -070078 if (rcu_fanout_exact)
Paul E. McKenneyab6f5bd2015-01-21 16:58:06 -080079 pr_info("\tHierarchical RCU autobalancing is disabled.\n");
80 if (IS_ENABLED(CONFIG_RCU_FAST_NO_HZ))
81 pr_info("\tRCU dyntick-idle grace-period acceleration is enabled.\n");
Paul E. McKenneyc4a09ff2017-05-12 14:37:19 -070082 if (IS_ENABLED(CONFIG_PROVE_RCU))
Paul E. McKenneyab6f5bd2015-01-21 16:58:06 -080083 pr_info("\tRCU lockdep checking is enabled.\n");
Alexander Gordeev42621692015-06-03 08:18:31 +020084 if (RCU_NUM_LVLS >= 4)
85 pr_info("\tFour(or more)-level hierarchy is enabled.\n");
Paul E. McKenney47d631a2015-04-21 09:12:13 -070086 if (RCU_FANOUT_LEAF != 16)
Paul E. McKenneya3bd2c09a2015-01-21 20:58:57 -080087 pr_info("\tBuild-time adjustment of leaf fanout to %d.\n",
Paul E. McKenney47d631a2015-04-21 09:12:13 -070088 RCU_FANOUT_LEAF);
89 if (rcu_fanout_leaf != RCU_FANOUT_LEAF)
Paul E. McKenney9a5739d72013-03-28 20:48:36 -070090 pr_info("\tBoot-time adjustment of leaf fanout to %d.\n", rcu_fanout_leaf);
Paul E. McKenneycca6f392012-05-08 21:00:28 -070091 if (nr_cpu_ids != NR_CPUS)
Alexey Dobriyan9b130ad2017-09-08 16:14:18 -070092 pr_info("\tRCU restricting CPUs from NR_CPUS=%d to nr_cpu_ids=%u.\n", NR_CPUS, nr_cpu_ids);
Paul E. McKenney17c77982017-04-28 11:12:34 -070093#ifdef CONFIG_RCU_BOOST
94 pr_info("\tRCU priority boosting: priority %d delay %d ms.\n", kthread_prio, CONFIG_RCU_BOOST_DELAY);
95#endif
96 if (blimit != DEFAULT_RCU_BLIMIT)
97 pr_info("\tBoot-time adjustment of callback invocation limit to %ld.\n", blimit);
98 if (qhimark != DEFAULT_RCU_QHIMARK)
99 pr_info("\tBoot-time adjustment of callback high-water mark to %ld.\n", qhimark);
100 if (qlowmark != DEFAULT_RCU_QLOMARK)
101 pr_info("\tBoot-time adjustment of callback low-water mark to %ld.\n", qlowmark);
102 if (jiffies_till_first_fqs != ULONG_MAX)
103 pr_info("\tBoot-time adjustment of first FQS scan delay to %ld jiffies.\n", jiffies_till_first_fqs);
104 if (jiffies_till_next_fqs != ULONG_MAX)
105 pr_info("\tBoot-time adjustment of subsequent FQS scan delay to %ld jiffies.\n", jiffies_till_next_fqs);
106 if (rcu_kick_kthreads)
107 pr_info("\tKick kthreads if too-long grace period.\n");
108 if (IS_ENABLED(CONFIG_DEBUG_OBJECTS_RCU_HEAD))
109 pr_info("\tRCU callback double-/use-after-free debug enabled.\n");
Paul E. McKenney90040c92017-05-10 14:36:55 -0700110 if (gp_preinit_delay)
Paul E. McKenney17c77982017-04-28 11:12:34 -0700111 pr_info("\tRCU debug GP pre-init slowdown %d jiffies.\n", gp_preinit_delay);
Paul E. McKenney90040c92017-05-10 14:36:55 -0700112 if (gp_init_delay)
Paul E. McKenney17c77982017-04-28 11:12:34 -0700113 pr_info("\tRCU debug GP init slowdown %d jiffies.\n", gp_init_delay);
Paul E. McKenney90040c92017-05-10 14:36:55 -0700114 if (gp_cleanup_delay)
Paul E. McKenney17c77982017-04-28 11:12:34 -0700115 pr_info("\tRCU debug GP init slowdown %d jiffies.\n", gp_cleanup_delay);
116 if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG))
117 pr_info("\tRCU debug extended QS entry/exit.\n");
Paul E. McKenney59d80fd2017-04-28 10:20:28 -0700118 rcupdate_announce_bootup_oddness();
Paul E. McKenney26845c22010-04-13 14:19:23 -0700119}
120
Pranith Kumar28f65692014-09-22 14:00:48 -0400121#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700122
Steven Rostedt (Red Hat)a41bfeb2013-07-12 17:00:28 -0400123RCU_STATE_INITIALIZER(rcu_preempt, 'p', call_rcu);
Paul E. McKenneyb28a7c02015-03-04 07:39:27 -0800124static struct rcu_state *const rcu_state_p = &rcu_preempt_state;
Paul E. McKenney2927a682015-03-04 07:53:04 -0800125static struct rcu_data __percpu *const rcu_data_p = &rcu_preempt_data;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700126
Paul E. McKenneyd19fb8d2014-10-31 12:56:16 -0700127static void rcu_report_exp_rnp(struct rcu_state *rsp, struct rcu_node *rnp,
128 bool wake);
Paul E. McKenneyd9a3da02009-12-02 12:10:15 -0800129
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700130/*
131 * Tell them what RCU they are running.
132 */
Paul E. McKenney0e0fc1c2009-11-11 11:28:06 -0800133static void __init rcu_bootup_announce(void)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700134{
Paul E. McKenneyefc151c2013-03-18 16:24:11 -0700135 pr_info("Preemptible hierarchical RCU implementation.\n");
Paul E. McKenney26845c22010-04-13 14:19:23 -0700136 rcu_bootup_announce_oddness();
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700137}
138
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700139/* Flags for rcu_preempt_ctxt_queue() decision table. */
140#define RCU_GP_TASKS 0x8
141#define RCU_EXP_TASKS 0x4
142#define RCU_GP_BLKD 0x2
143#define RCU_EXP_BLKD 0x1
144
145/*
146 * Queues a task preempted within an RCU-preempt read-side critical
147 * section into the appropriate location within the ->blkd_tasks list,
148 * depending on the states of any ongoing normal and expedited grace
149 * periods. The ->gp_tasks pointer indicates which element the normal
150 * grace period is waiting on (NULL if none), and the ->exp_tasks pointer
151 * indicates which element the expedited grace period is waiting on (again,
152 * NULL if none). If a grace period is waiting on a given element in the
153 * ->blkd_tasks list, it also waits on all subsequent elements. Thus,
154 * adding a task to the tail of the list blocks any grace period that is
155 * already waiting on one of the elements. In contrast, adding a task
156 * to the head of the list won't block any grace period that is already
157 * waiting on one of the elements.
158 *
159 * This queuing is imprecise, and can sometimes make an ongoing grace
160 * period wait for a task that is not strictly speaking blocking it.
161 * Given the choice, we needlessly block a normal grace period rather than
162 * blocking an expedited grace period.
163 *
164 * Note that an endless sequence of expedited grace periods still cannot
165 * indefinitely postpone a normal grace period. Eventually, all of the
166 * fixed number of preempted tasks blocking the normal grace period that are
167 * not also blocking the expedited grace period will resume and complete
168 * their RCU read-side critical sections. At that point, the ->gp_tasks
169 * pointer will equal the ->exp_tasks pointer, at which point the end of
170 * the corresponding expedited grace period will also be the end of the
171 * normal grace period.
172 */
Paul E. McKenney46a5d162015-10-07 09:10:48 -0700173static void rcu_preempt_ctxt_queue(struct rcu_node *rnp, struct rcu_data *rdp)
174 __releases(rnp->lock) /* But leaves rrupts disabled. */
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700175{
176 int blkd_state = (rnp->gp_tasks ? RCU_GP_TASKS : 0) +
177 (rnp->exp_tasks ? RCU_EXP_TASKS : 0) +
178 (rnp->qsmask & rdp->grpmask ? RCU_GP_BLKD : 0) +
179 (rnp->expmask & rdp->grpmask ? RCU_EXP_BLKD : 0);
180 struct task_struct *t = current;
181
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -0700182 lockdep_assert_held(&rnp->lock);
Paul E. McKenney2dee9402017-07-11 21:52:31 -0700183 WARN_ON_ONCE(rdp->mynode != rnp);
184 WARN_ON_ONCE(rnp->level != rcu_num_lvls - 1);
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -0700185
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700186 /*
187 * Decide where to queue the newly blocked task. In theory,
188 * this could be an if-statement. In practice, when I tried
189 * that, it was quite messy.
190 */
191 switch (blkd_state) {
192 case 0:
193 case RCU_EXP_TASKS:
194 case RCU_EXP_TASKS + RCU_GP_BLKD:
195 case RCU_GP_TASKS:
196 case RCU_GP_TASKS + RCU_EXP_TASKS:
197
198 /*
199 * Blocking neither GP, or first task blocking the normal
200 * GP but not blocking the already-waiting expedited GP.
201 * Queue at the head of the list to avoid unnecessarily
202 * blocking the already-waiting GPs.
203 */
204 list_add(&t->rcu_node_entry, &rnp->blkd_tasks);
205 break;
206
207 case RCU_EXP_BLKD:
208 case RCU_GP_BLKD:
209 case RCU_GP_BLKD + RCU_EXP_BLKD:
210 case RCU_GP_TASKS + RCU_EXP_BLKD:
211 case RCU_GP_TASKS + RCU_GP_BLKD + RCU_EXP_BLKD:
212 case RCU_GP_TASKS + RCU_EXP_TASKS + RCU_GP_BLKD + RCU_EXP_BLKD:
213
214 /*
215 * First task arriving that blocks either GP, or first task
216 * arriving that blocks the expedited GP (with the normal
217 * GP already waiting), or a task arriving that blocks
218 * both GPs with both GPs already waiting. Queue at the
219 * tail of the list to avoid any GP waiting on any of the
220 * already queued tasks that are not blocking it.
221 */
222 list_add_tail(&t->rcu_node_entry, &rnp->blkd_tasks);
223 break;
224
225 case RCU_EXP_TASKS + RCU_EXP_BLKD:
226 case RCU_EXP_TASKS + RCU_GP_BLKD + RCU_EXP_BLKD:
227 case RCU_GP_TASKS + RCU_EXP_TASKS + RCU_EXP_BLKD:
228
229 /*
230 * Second or subsequent task blocking the expedited GP.
231 * The task either does not block the normal GP, or is the
232 * first task blocking the normal GP. Queue just after
233 * the first task blocking the expedited GP.
234 */
235 list_add(&t->rcu_node_entry, rnp->exp_tasks);
236 break;
237
238 case RCU_GP_TASKS + RCU_GP_BLKD:
239 case RCU_GP_TASKS + RCU_EXP_TASKS + RCU_GP_BLKD:
240
241 /*
242 * Second or subsequent task blocking the normal GP.
243 * The task does not block the expedited GP. Queue just
244 * after the first task blocking the normal GP.
245 */
246 list_add(&t->rcu_node_entry, rnp->gp_tasks);
247 break;
248
249 default:
250
251 /* Yet another exercise in excessive paranoia. */
252 WARN_ON_ONCE(1);
253 break;
254 }
255
256 /*
257 * We have now queued the task. If it was the first one to
258 * block either grace period, update the ->gp_tasks and/or
259 * ->exp_tasks pointers, respectively, to reference the newly
260 * blocked tasks.
261 */
262 if (!rnp->gp_tasks && (blkd_state & RCU_GP_BLKD))
263 rnp->gp_tasks = &t->rcu_node_entry;
264 if (!rnp->exp_tasks && (blkd_state & RCU_EXP_BLKD))
265 rnp->exp_tasks = &t->rcu_node_entry;
Paul E. McKenney2dee9402017-07-11 21:52:31 -0700266 WARN_ON_ONCE(!(blkd_state & RCU_GP_BLKD) !=
267 !(rnp->qsmask & rdp->grpmask));
268 WARN_ON_ONCE(!(blkd_state & RCU_EXP_BLKD) !=
269 !(rnp->expmask & rdp->grpmask));
Boqun Feng67c583a72015-12-29 12:18:47 +0800270 raw_spin_unlock_rcu_node(rnp); /* interrupts remain disabled. */
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700271
272 /*
273 * Report the quiescent state for the expedited GP. This expedited
274 * GP should not be able to end until we report, so there should be
275 * no need to check for a subsequent expedited GP. (Though we are
276 * still in a quiescent state in any case.)
277 */
278 if (blkd_state & RCU_EXP_BLKD &&
279 t->rcu_read_unlock_special.b.exp_need_qs) {
280 t->rcu_read_unlock_special.b.exp_need_qs = false;
281 rcu_report_exp_rdp(rdp->rsp, rdp, true);
282 } else {
283 WARN_ON_ONCE(t->rcu_read_unlock_special.b.exp_need_qs);
284 }
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700285}
286
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700287/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800288 * Record a preemptible-RCU quiescent state for the specified CPU. Note
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700289 * that this just means that the task currently running on the CPU is
290 * not in a quiescent state. There might be any number of tasks blocked
291 * while in an RCU read-side critical section.
Paul E. McKenney25502a62010-04-01 17:37:01 -0700292 *
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700293 * As with the other rcu_*_qs() functions, callers to this function
294 * must disable preemption.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700295 */
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700296static void rcu_preempt_qs(void)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700297{
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -0700298 RCU_LOCKDEP_WARN(preemptible(), "rcu_preempt_qs() invoked with preemption enabled!!!\n");
Paul E. McKenney5b74c452015-08-06 15:16:57 -0700299 if (__this_cpu_read(rcu_data_p->cpu_no_qs.s)) {
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700300 trace_rcu_grace_period(TPS("rcu_preempt"),
Paul E. McKenney2927a682015-03-04 07:53:04 -0800301 __this_cpu_read(rcu_data_p->gpnum),
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700302 TPS("cpuqs"));
Paul E. McKenney5b74c452015-08-06 15:16:57 -0700303 __this_cpu_write(rcu_data_p->cpu_no_qs.b.norm, false);
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700304 barrier(); /* Coordinate with rcu_preempt_check_callbacks(). */
305 current->rcu_read_unlock_special.b.need_qs = false;
306 }
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700307}
308
309/*
Paul E. McKenneyc3422be2009-09-13 09:15:10 -0700310 * We have entered the scheduler, and the current task might soon be
311 * context-switched away from. If this task is in an RCU read-side
312 * critical section, we will no longer be able to rely on the CPU to
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800313 * record that fact, so we enqueue the task on the blkd_tasks list.
314 * The task will dequeue itself when it exits the outermost enclosing
315 * RCU read-side critical section. Therefore, the current grace period
316 * cannot be permitted to complete until the blkd_tasks list entries
317 * predating the current grace period drain, in other words, until
318 * rnp->gp_tasks becomes NULL.
Paul E. McKenneyc3422be2009-09-13 09:15:10 -0700319 *
Paul E. McKenney46a5d162015-10-07 09:10:48 -0700320 * Caller must disable interrupts.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700321 */
Paul E. McKenney5b72f962017-04-12 15:29:14 -0700322static void rcu_preempt_note_context_switch(bool preempt)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700323{
324 struct task_struct *t = current;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700325 struct rcu_data *rdp;
326 struct rcu_node *rnp;
327
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -0700328 RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_preempt_note_context_switch() invoked with interrupts enabled!!!\n");
Paul E. McKenney5b72f962017-04-12 15:29:14 -0700329 WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);
Paul E. McKenney10f39bb2011-07-17 21:14:35 -0700330 if (t->rcu_read_lock_nesting > 0 &&
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700331 !t->rcu_read_unlock_special.b.blocked) {
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700332
333 /* Possibly blocking in an RCU read-side critical section. */
Paul E. McKenneye63c8872015-03-03 12:56:43 -0800334 rdp = this_cpu_ptr(rcu_state_p->rda);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700335 rnp = rdp->mynode;
Paul E. McKenney46a5d162015-10-07 09:10:48 -0700336 raw_spin_lock_rcu_node(rnp);
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700337 t->rcu_read_unlock_special.b.blocked = true;
Paul E. McKenney86848962009-08-27 15:00:12 -0700338 t->rcu_blocked_node = rnp;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700339
340 /*
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700341 * Verify the CPU's sanity, trace the preemption, and
342 * then queue the task as required based on the states
343 * of any ongoing and expedited grace periods.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700344 */
Paul E. McKenney0aa04b02015-01-23 21:52:37 -0800345 WARN_ON_ONCE((rdp->grpmask & rcu_rnp_online_cpus(rnp)) == 0);
Paul E. McKenneye7d88422009-09-18 09:50:18 -0700346 WARN_ON_ONCE(!list_empty(&t->rcu_node_entry));
Paul E. McKenneyd4c08f22011-06-25 06:36:56 -0700347 trace_rcu_preempt_task(rdp->rsp->name,
348 t->pid,
349 (rnp->qsmask & rdp->grpmask)
350 ? rnp->gpnum
351 : rnp->gpnum + 1);
Paul E. McKenney46a5d162015-10-07 09:10:48 -0700352 rcu_preempt_ctxt_queue(rnp, rdp);
Paul E. McKenney10f39bb2011-07-17 21:14:35 -0700353 } else if (t->rcu_read_lock_nesting < 0 &&
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700354 t->rcu_read_unlock_special.s) {
Paul E. McKenney10f39bb2011-07-17 21:14:35 -0700355
356 /*
357 * Complete exit from RCU read-side critical section on
358 * behalf of preempted instance of __rcu_read_unlock().
359 */
360 rcu_read_unlock_special(t);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700361 }
362
363 /*
364 * Either we were not in an RCU read-side critical section to
365 * begin with, or we have now recorded that critical section
366 * globally. Either way, we can now note a quiescent state
367 * for this CPU. Again, if we were in an RCU read-side critical
368 * section, and if that critical section was blocking the current
369 * grace period, then the fact that the task has been enqueued
370 * means that we continue to block the current grace period.
371 */
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700372 rcu_preempt_qs();
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700373}
374
375/*
Paul E. McKenneyfc2219d42009-09-23 09:50:41 -0700376 * Check for preempted RCU readers blocking the current grace period
377 * for the specified rcu_node structure. If the caller needs a reliable
378 * answer, it must hold the rcu_node's ->lock.
379 */
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800380static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp)
Paul E. McKenneyfc2219d42009-09-23 09:50:41 -0700381{
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800382 return rnp->gp_tasks != NULL;
Paul E. McKenneyfc2219d42009-09-23 09:50:41 -0700383}
384
Paul E. McKenneyb668c9c2009-11-22 08:53:48 -0800385/*
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800386 * Advance a ->blkd_tasks-list pointer to the next entry, instead
387 * returning NULL if at the end of the list.
388 */
389static struct list_head *rcu_next_node_entry(struct task_struct *t,
390 struct rcu_node *rnp)
391{
392 struct list_head *np;
393
394 np = t->rcu_node_entry.next;
395 if (np == &rnp->blkd_tasks)
396 np = NULL;
397 return np;
398}
399
400/*
Paul E. McKenney8af3a5e2014-10-31 11:22:37 -0700401 * Return true if the specified rcu_node structure has tasks that were
402 * preempted within an RCU read-side critical section.
403 */
404static bool rcu_preempt_has_tasks(struct rcu_node *rnp)
405{
406 return !list_empty(&rnp->blkd_tasks);
407}
408
409/*
Paul E. McKenneyb668c9c2009-11-22 08:53:48 -0800410 * Handle special cases during rcu_read_unlock(), such as needing to
411 * notify RCU core processing or task having blocked during the RCU
412 * read-side critical section.
413 */
Paul E. McKenney2a3fa842012-05-21 11:58:36 -0700414void rcu_read_unlock_special(struct task_struct *t)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700415{
Paul E. McKenneyb6a932d2014-10-31 12:05:04 -0700416 bool empty_exp;
417 bool empty_norm;
418 bool empty_exp_now;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700419 unsigned long flags;
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800420 struct list_head *np;
Paul E. McKenneyabaa93d2014-06-12 13:30:25 -0700421 bool drop_boost_mutex = false;
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700422 struct rcu_data *rdp;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700423 struct rcu_node *rnp;
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700424 union rcu_special special;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700425
426 /* NMI handlers cannot block and cannot safely manipulate state. */
427 if (in_nmi())
428 return;
429
430 local_irq_save(flags);
431
432 /*
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700433 * If RCU core is waiting for this CPU to exit its critical section,
434 * report the fact that it has exited. Because irqs are disabled,
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700435 * t->rcu_read_unlock_special cannot change.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700436 */
437 special = t->rcu_read_unlock_special;
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700438 if (special.b.need_qs) {
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700439 rcu_preempt_qs();
Paul E. McKenneyc0135d02015-01-22 22:47:14 -0800440 t->rcu_read_unlock_special.b.need_qs = false;
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700441 if (!t->rcu_read_unlock_special.s) {
Lai Jiangshan79a62f92013-10-30 04:13:22 -0700442 local_irq_restore(flags);
443 return;
444 }
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700445 }
446
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700447 /*
448 * Respond to a request for an expedited grace period, but only if
449 * we were not preempted, meaning that we were running on the same
450 * CPU throughout. If we were preempted, the exp_need_qs flag
451 * would have been cleared at the time of the first preemption,
452 * and the quiescent state would be reported when we were dequeued.
453 */
454 if (special.b.exp_need_qs) {
455 WARN_ON_ONCE(special.b.blocked);
456 t->rcu_read_unlock_special.b.exp_need_qs = false;
457 rdp = this_cpu_ptr(rcu_state_p->rda);
458 rcu_report_exp_rdp(rcu_state_p, rdp, true);
459 if (!t->rcu_read_unlock_special.s) {
460 local_irq_restore(flags);
461 return;
462 }
463 }
464
Lai Jiangshan79a62f92013-10-30 04:13:22 -0700465 /* Hardware IRQ handlers cannot block, complain if they get here. */
Paul E. McKenneyd24209bb2015-01-21 15:26:03 -0800466 if (in_irq() || in_serving_softirq()) {
467 lockdep_rcu_suspicious(__FILE__, __LINE__,
468 "rcu_read_unlock() from irq or softirq with blocking in critical section!!!\n");
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700469 pr_alert("->rcu_read_unlock_special: %#x (b: %d, enq: %d nq: %d)\n",
Paul E. McKenneyd24209bb2015-01-21 15:26:03 -0800470 t->rcu_read_unlock_special.s,
471 t->rcu_read_unlock_special.b.blocked,
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700472 t->rcu_read_unlock_special.b.exp_need_qs,
Paul E. McKenneyd24209bb2015-01-21 15:26:03 -0800473 t->rcu_read_unlock_special.b.need_qs);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700474 local_irq_restore(flags);
475 return;
476 }
477
478 /* Clean up if blocked during RCU read-side critical section. */
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700479 if (special.b.blocked) {
480 t->rcu_read_unlock_special.b.blocked = false;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700481
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -0700482 /*
Paul E. McKenney0a0ba1c2015-03-08 14:20:30 -0700483 * Remove this task from the list it blocked on. The task
Paul E. McKenney8ba91532015-09-29 07:55:41 -0700484 * now remains queued on the rcu_node corresponding to the
485 * CPU it first blocked on, so there is no longer any need
486 * to loop. Retain a WARN_ON_ONCE() out of sheer paranoia.
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -0700487 */
Paul E. McKenney8ba91532015-09-29 07:55:41 -0700488 rnp = t->rcu_blocked_node;
489 raw_spin_lock_rcu_node(rnp); /* irqs already disabled. */
490 WARN_ON_ONCE(rnp != t->rcu_blocked_node);
Paul E. McKenney2dee9402017-07-11 21:52:31 -0700491 WARN_ON_ONCE(rnp->level != rcu_num_lvls - 1);
Paul E. McKenney74e871ac2014-10-30 21:08:53 -0700492 empty_norm = !rcu_preempt_blocked_readers_cgp(rnp);
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700493 empty_exp = sync_rcu_preempt_exp_done(rnp);
Paul E. McKenneyd9a3da02009-12-02 12:10:15 -0800494 smp_mb(); /* ensure expedited fastpath sees end of RCU c-s. */
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800495 np = rcu_next_node_entry(t, rnp);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700496 list_del_init(&t->rcu_node_entry);
Paul E. McKenney82e78d82011-08-04 07:55:34 -0700497 t->rcu_blocked_node = NULL;
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -0400498 trace_rcu_unlock_preempted_task(TPS("rcu_preempt"),
Paul E. McKenneyd4c08f22011-06-25 06:36:56 -0700499 rnp->gpnum, t->pid);
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800500 if (&t->rcu_node_entry == rnp->gp_tasks)
501 rnp->gp_tasks = np;
502 if (&t->rcu_node_entry == rnp->exp_tasks)
503 rnp->exp_tasks = np;
Paul E. McKenney727b7052015-03-03 14:49:26 -0800504 if (IS_ENABLED(CONFIG_RCU_BOOST)) {
Paul E. McKenney727b7052015-03-03 14:49:26 -0800505 /* Snapshot ->boost_mtx ownership w/rnp->lock held. */
506 drop_boost_mutex = rt_mutex_owner(&rnp->boost_mtx) == t;
Paul E. McKenney2dee9402017-07-11 21:52:31 -0700507 if (&t->rcu_node_entry == rnp->boost_tasks)
508 rnp->boost_tasks = np;
Paul E. McKenney727b7052015-03-03 14:49:26 -0800509 }
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700510
511 /*
512 * If this was the last task on the current list, and if
513 * we aren't waiting on any CPUs, report the quiescent state.
Paul E. McKenney389abd42011-09-21 14:41:37 -0700514 * Note that rcu_report_unblock_qs_rnp() releases rnp->lock,
515 * so we must take a snapshot of the expedited state.
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700516 */
Paul E. McKenney8203d6d02015-08-02 13:53:17 -0700517 empty_exp_now = sync_rcu_preempt_exp_done(rnp);
Paul E. McKenney74e871ac2014-10-30 21:08:53 -0700518 if (!empty_norm && !rcu_preempt_blocked_readers_cgp(rnp)) {
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -0400519 trace_rcu_quiescent_state_report(TPS("preempt_rcu"),
Paul E. McKenneyd4c08f22011-06-25 06:36:56 -0700520 rnp->gpnum,
521 0, rnp->qsmask,
522 rnp->level,
523 rnp->grplo,
524 rnp->grphi,
525 !!rnp->gp_tasks);
Paul E. McKenneye63c8872015-03-03 12:56:43 -0800526 rcu_report_unblock_qs_rnp(rcu_state_p, rnp, flags);
Paul E. McKenneyc701d5d2012-06-28 08:08:25 -0700527 } else {
Boqun Feng67c583a72015-12-29 12:18:47 +0800528 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenneyc701d5d2012-06-28 08:08:25 -0700529 }
Paul E. McKenneyd9a3da02009-12-02 12:10:15 -0800530
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800531 /* Unboost if we were boosted. */
Paul E. McKenney727b7052015-03-03 14:49:26 -0800532 if (IS_ENABLED(CONFIG_RCU_BOOST) && drop_boost_mutex)
Paul E. McKenneyabaa93d2014-06-12 13:30:25 -0700533 rt_mutex_unlock(&rnp->boost_mtx);
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800534
Paul E. McKenneyd9a3da02009-12-02 12:10:15 -0800535 /*
536 * If this was the last task on the expedited lists,
537 * then we need to report up the rcu_node hierarchy.
538 */
Paul E. McKenney389abd42011-09-21 14:41:37 -0700539 if (!empty_exp && empty_exp_now)
Paul E. McKenneye63c8872015-03-03 12:56:43 -0800540 rcu_report_exp_rnp(rcu_state_p, rnp, true);
Paul E. McKenneyb668c9c2009-11-22 08:53:48 -0800541 } else {
542 local_irq_restore(flags);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700543 }
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700544}
545
Paul E. McKenney1ed509a2010-02-22 17:05:05 -0800546/*
547 * Dump detailed information for all tasks blocking the current RCU
548 * grace period on the specified rcu_node structure.
549 */
550static void rcu_print_detail_task_stall_rnp(struct rcu_node *rnp)
551{
552 unsigned long flags;
Paul E. McKenney1ed509a2010-02-22 17:05:05 -0800553 struct task_struct *t;
554
Paul E. McKenney6cf10082015-10-08 15:36:54 -0700555 raw_spin_lock_irqsave_rcu_node(rnp, flags);
Paul E. McKenney5fd4dc02012-08-10 16:00:11 -0700556 if (!rcu_preempt_blocked_readers_cgp(rnp)) {
Boqun Feng67c583a72015-12-29 12:18:47 +0800557 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney5fd4dc02012-08-10 16:00:11 -0700558 return;
559 }
Patrick Daly82efed02015-04-07 15:12:07 -0700560 t = list_entry(rnp->gp_tasks->prev,
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800561 struct task_struct, rcu_node_entry);
562 list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry)
563 sched_show_task(t);
Boqun Feng67c583a72015-12-29 12:18:47 +0800564 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney1ed509a2010-02-22 17:05:05 -0800565}
566
567/*
568 * Dump detailed information for all tasks blocking the current RCU
569 * grace period.
570 */
571static void rcu_print_detail_task_stall(struct rcu_state *rsp)
572{
573 struct rcu_node *rnp = rcu_get_root(rsp);
574
575 rcu_print_detail_task_stall_rnp(rnp);
576 rcu_for_each_leaf_node(rsp, rnp)
577 rcu_print_detail_task_stall_rnp(rnp);
578}
579
Paul E. McKenneya858af22012-01-16 13:29:10 -0800580static void rcu_print_task_stall_begin(struct rcu_node *rnp)
581{
Paul E. McKenneyefc151c2013-03-18 16:24:11 -0700582 pr_err("\tTasks blocked on level-%d rcu_node (CPUs %d-%d):",
Paul E. McKenneya858af22012-01-16 13:29:10 -0800583 rnp->level, rnp->grplo, rnp->grphi);
584}
585
586static void rcu_print_task_stall_end(void)
587{
Paul E. McKenneyefc151c2013-03-18 16:24:11 -0700588 pr_cont("\n");
Paul E. McKenneya858af22012-01-16 13:29:10 -0800589}
590
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700591/*
592 * Scan the current list of tasks blocked within RCU read-side critical
593 * sections, printing out the tid of each.
594 */
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700595static int rcu_print_task_stall(struct rcu_node *rnp)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700596{
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700597 struct task_struct *t;
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700598 int ndetected = 0;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700599
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800600 if (!rcu_preempt_blocked_readers_cgp(rnp))
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700601 return 0;
Paul E. McKenneya858af22012-01-16 13:29:10 -0800602 rcu_print_task_stall_begin(rnp);
Patrick Daly82efed02015-04-07 15:12:07 -0700603 t = list_entry(rnp->gp_tasks->prev,
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800604 struct task_struct, rcu_node_entry);
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700605 list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) {
Paul E. McKenneyefc151c2013-03-18 16:24:11 -0700606 pr_cont(" P%d", t->pid);
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700607 ndetected++;
608 }
Paul E. McKenneya858af22012-01-16 13:29:10 -0800609 rcu_print_task_stall_end();
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700610 return ndetected;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700611}
612
Paul E. McKenney53d84e02010-08-10 14:28:53 -0700613/*
Paul E. McKenney74611ec2015-08-18 10:20:43 -0700614 * Scan the current list of tasks blocked within RCU read-side critical
615 * sections, printing out the tid of each that is blocking the current
616 * expedited grace period.
617 */
618static int rcu_print_task_exp_stall(struct rcu_node *rnp)
619{
620 struct task_struct *t;
621 int ndetected = 0;
622
623 if (!rnp->exp_tasks)
624 return 0;
625 t = list_entry(rnp->exp_tasks->prev,
626 struct task_struct, rcu_node_entry);
627 list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) {
628 pr_cont(" P%d", t->pid);
629 ndetected++;
630 }
631 return ndetected;
632}
633
634/*
Paul E. McKenneyb0e165c02009-09-13 09:15:09 -0700635 * Check that the list of blocked tasks for the newly completed grace
636 * period is in fact empty. It is a serious bug to complete a grace
637 * period that still has RCU readers blocked! This function must be
638 * invoked -before- updating this rnp's ->gpnum, and the rnp's ->lock
639 * must be held by the caller.
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800640 *
641 * Also, if there are blocked tasks on the list, they automatically
642 * block the newly created grace period, so set up ->gp_tasks accordingly.
Paul E. McKenneyb0e165c02009-09-13 09:15:09 -0700643 */
644static void rcu_preempt_check_blocked_tasks(struct rcu_node *rnp)
645{
Paul E. McKenneyc5ebe662017-06-19 10:32:23 -0700646 struct task_struct *t;
647
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -0700648 RCU_LOCKDEP_WARN(preemptible(), "rcu_preempt_check_blocked_tasks() invoked with preemption enabled!!!\n");
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800649 WARN_ON_ONCE(rcu_preempt_blocked_readers_cgp(rnp));
Paul E. McKenneyc5ebe662017-06-19 10:32:23 -0700650 if (rcu_preempt_has_tasks(rnp)) {
Paul E. McKenney12f5f522010-11-29 21:56:39 -0800651 rnp->gp_tasks = rnp->blkd_tasks.next;
Paul E. McKenneyc5ebe662017-06-19 10:32:23 -0700652 t = container_of(rnp->gp_tasks, struct task_struct,
653 rcu_node_entry);
654 trace_rcu_unlock_preempted_task(TPS("rcu_preempt-GPS"),
655 rnp->gpnum, t->pid);
656 }
Paul E. McKenney28ecd582009-09-18 09:50:17 -0700657 WARN_ON_ONCE(rnp->qsmask);
Paul E. McKenneyb0e165c02009-09-13 09:15:09 -0700658}
659
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -0700660/*
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700661 * Check for a quiescent state from the current CPU. When a task blocks,
662 * the task is recorded in the corresponding CPU's rcu_node structure,
663 * which is checked elsewhere.
664 *
665 * Caller must disable hard irqs.
666 */
Paul E. McKenney86aea0e2014-10-21 08:12:00 -0700667static void rcu_preempt_check_callbacks(void)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700668{
669 struct task_struct *t = current;
670
671 if (t->rcu_read_lock_nesting == 0) {
Paul E. McKenney284a8c92014-08-14 16:38:46 -0700672 rcu_preempt_qs();
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700673 return;
674 }
Paul E. McKenney10f39bb2011-07-17 21:14:35 -0700675 if (t->rcu_read_lock_nesting > 0 &&
Paul E. McKenney97c668b2015-08-06 11:31:51 -0700676 __this_cpu_read(rcu_data_p->core_needs_qs) &&
Paul E. McKenney5b74c452015-08-06 15:16:57 -0700677 __this_cpu_read(rcu_data_p->cpu_no_qs.b.norm))
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700678 t->rcu_read_unlock_special.b.need_qs = true;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700679}
680
Paul E. McKenneya46e0892011-06-15 15:47:09 -0700681#ifdef CONFIG_RCU_BOOST
682
Shaohua Li09223372011-06-14 13:26:25 +0800683static void rcu_preempt_do_callbacks(void)
684{
Paul E. McKenney2927a682015-03-04 07:53:04 -0800685 rcu_do_batch(rcu_state_p, this_cpu_ptr(rcu_data_p));
Shaohua Li09223372011-06-14 13:26:25 +0800686}
687
Paul E. McKenneya46e0892011-06-15 15:47:09 -0700688#endif /* #ifdef CONFIG_RCU_BOOST */
689
Paul E. McKenneya68a2bb2017-05-03 08:34:57 -0700690/**
691 * call_rcu() - Queue an RCU callback for invocation after a grace period.
692 * @head: structure to be used for queueing the RCU updates.
693 * @func: actual callback function to be invoked after the grace period
694 *
695 * The callback function will be invoked some time after a full grace
696 * period elapses, in other words after all pre-existing RCU read-side
697 * critical sections have completed. However, the callback function
698 * might well execute concurrently with RCU read-side critical sections
699 * that started after call_rcu() was invoked. RCU read-side critical
700 * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
701 * and may be nested.
702 *
703 * Note that all CPUs must agree that the grace period extended beyond
704 * all pre-existing RCU read-side critical section. On systems with more
705 * than one CPU, this means that when "func()" is invoked, each CPU is
706 * guaranteed to have executed a full memory barrier since the end of its
707 * last RCU read-side critical section whose beginning preceded the call
708 * to call_rcu(). It also means that each CPU executing an RCU read-side
709 * critical section that continues beyond the start of "func()" must have
710 * executed a memory barrier after the call_rcu() but before the beginning
711 * of that RCU read-side critical section. Note that these guarantees
712 * include CPUs that are offline, idle, or executing in user mode, as
713 * well as CPUs that are executing in the kernel.
714 *
715 * Furthermore, if CPU A invoked call_rcu() and CPU B invoked the
716 * resulting RCU callback function "func()", then both CPU A and CPU B are
717 * guaranteed to execute a full memory barrier during the time interval
718 * between the call to call_rcu() and the invocation of "func()" -- even
719 * if CPU A and CPU B are the same CPU (but again only if the system has
720 * more than one CPU).
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700721 */
Boqun Fengb6a4ae72015-07-29 13:29:38 +0800722void call_rcu(struct rcu_head *head, rcu_callback_t func)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700723{
Paul E. McKenneye63c8872015-03-03 12:56:43 -0800724 __call_rcu(head, func, rcu_state_p, -1, 0);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700725}
726EXPORT_SYMBOL_GPL(call_rcu);
727
Paul E. McKenney6ebb2372009-11-22 08:53:50 -0800728/**
729 * synchronize_rcu - wait until a grace period has elapsed.
730 *
731 * Control will return to the caller some time after a full grace
732 * period has elapsed, in other words after all currently executing RCU
Paul E. McKenney77d84852010-07-08 17:38:59 -0700733 * read-side critical sections have completed. Note, however, that
734 * upon return from synchronize_rcu(), the caller might well be executing
735 * concurrently with new RCU read-side critical sections that began while
736 * synchronize_rcu() was waiting. RCU read-side critical sections are
737 * delimited by rcu_read_lock() and rcu_read_unlock(), and may be nested.
Paul E. McKenneyf0a0e6f2012-10-23 13:47:01 -0700738 *
Paul E. McKenneye28371c2017-04-17 09:59:53 -0700739 * See the description of synchronize_sched() for more detailed
740 * information on memory-ordering guarantees. However, please note
741 * that -only- the memory-ordering guarantees apply. For example,
742 * synchronize_rcu() is -not- guaranteed to wait on things like code
743 * protected by preempt_disable(), instead, synchronize_rcu() is -only-
744 * guaranteed to wait on RCU read-side critical sections, that is, sections
745 * of code protected by rcu_read_lock().
Paul E. McKenney6ebb2372009-11-22 08:53:50 -0800746 */
747void synchronize_rcu(void)
748{
Paul E. McKenneyf78f5b92015-06-18 15:50:02 -0700749 RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map) ||
750 lock_is_held(&rcu_lock_map) ||
751 lock_is_held(&rcu_sched_lock_map),
752 "Illegal synchronize_rcu() in RCU read-side critical section");
Paul E. McKenney52d7e482017-01-10 02:28:26 -0800753 if (rcu_scheduler_active == RCU_SCHEDULER_INACTIVE)
Paul E. McKenney6ebb2372009-11-22 08:53:50 -0800754 return;
Paul E. McKenney5afff482015-02-18 16:39:09 -0800755 if (rcu_gp_is_expedited())
Antti P Miettinen3705b882012-10-05 09:59:15 +0300756 synchronize_rcu_expedited();
757 else
758 wait_rcu_gp(call_rcu);
Paul E. McKenney6ebb2372009-11-22 08:53:50 -0800759}
760EXPORT_SYMBOL_GPL(synchronize_rcu);
761
Paul E. McKenneye74f4c42009-10-06 21:48:17 -0700762/**
763 * rcu_barrier - Wait until all in-flight call_rcu() callbacks complete.
Paul E. McKenneyf0a0e6f2012-10-23 13:47:01 -0700764 *
765 * Note that this primitive does not necessarily wait for an RCU grace period
766 * to complete. For example, if there are no RCU callbacks queued anywhere
767 * in the system, then rcu_barrier() is within its rights to return
768 * immediately, without waiting for anything, much less an RCU grace period.
Paul E. McKenneye74f4c42009-10-06 21:48:17 -0700769 */
770void rcu_barrier(void)
771{
Paul E. McKenneye63c8872015-03-03 12:56:43 -0800772 _rcu_barrier(rcu_state_p);
Paul E. McKenneye74f4c42009-10-06 21:48:17 -0700773}
774EXPORT_SYMBOL_GPL(rcu_barrier);
775
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700776/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800777 * Initialize preemptible RCU's state structures.
Paul E. McKenney1eba8f82009-09-23 09:50:42 -0700778 */
779static void __init __rcu_init_preempt(void)
780{
Paul E. McKenneya87f2032015-10-20 12:38:49 -0700781 rcu_init_one(rcu_state_p);
Paul E. McKenney1eba8f82009-09-23 09:50:42 -0700782}
783
Paul E. McKenney2439b692013-04-11 10:15:52 -0700784/*
785 * Check for a task exiting while in a preemptible-RCU read-side
786 * critical section, clean up if so. No need to issue warnings,
787 * as debug_check_no_locks_held() already does this if lockdep
788 * is enabled.
789 */
790void exit_rcu(void)
791{
792 struct task_struct *t = current;
793
794 if (likely(list_empty(&current->rcu_node_entry)))
795 return;
796 t->rcu_read_lock_nesting = 1;
797 barrier();
Paul E. McKenney1d082fd2014-08-14 16:01:53 -0700798 t->rcu_read_unlock_special.b.blocked = true;
Paul E. McKenney2439b692013-04-11 10:15:52 -0700799 __rcu_read_unlock();
800}
801
Pranith Kumar28f65692014-09-22 14:00:48 -0400802#else /* #ifdef CONFIG_PREEMPT_RCU */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700803
Paul E. McKenneyb28a7c02015-03-04 07:39:27 -0800804static struct rcu_state *const rcu_state_p = &rcu_sched_state;
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800805
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700806/*
807 * Tell them what RCU they are running.
808 */
Paul E. McKenney0e0fc1c2009-11-11 11:28:06 -0800809static void __init rcu_bootup_announce(void)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700810{
Paul E. McKenneyefc151c2013-03-18 16:24:11 -0700811 pr_info("Hierarchical RCU implementation.\n");
Paul E. McKenney26845c22010-04-13 14:19:23 -0700812 rcu_bootup_announce_oddness();
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700813}
814
815/*
Paul E. McKenneycba6d0d2012-07-02 07:08:42 -0700816 * Because preemptible RCU does not exist, we never have to check for
817 * CPUs being in quiescent states.
818 */
Paul E. McKenney5b72f962017-04-12 15:29:14 -0700819static void rcu_preempt_note_context_switch(bool preempt)
Paul E. McKenneycba6d0d2012-07-02 07:08:42 -0700820{
821}
822
823/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800824 * Because preemptible RCU does not exist, there are never any preempted
Paul E. McKenneyfc2219d42009-09-23 09:50:41 -0700825 * RCU readers.
826 */
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800827static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp)
Paul E. McKenneyfc2219d42009-09-23 09:50:41 -0700828{
829 return 0;
830}
831
Paul E. McKenney8af3a5e2014-10-31 11:22:37 -0700832/*
833 * Because there is no preemptible RCU, there can be no readers blocked.
834 */
835static bool rcu_preempt_has_tasks(struct rcu_node *rnp)
Paul E. McKenneyb668c9c2009-11-22 08:53:48 -0800836{
Paul E. McKenney8af3a5e2014-10-31 11:22:37 -0700837 return false;
Paul E. McKenneyb668c9c2009-11-22 08:53:48 -0800838}
839
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700840/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800841 * Because preemptible RCU does not exist, we never have to check for
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700842 * tasks blocked within RCU read-side critical sections.
843 */
Paul E. McKenney1ed509a2010-02-22 17:05:05 -0800844static void rcu_print_detail_task_stall(struct rcu_state *rsp)
845{
846}
847
848/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800849 * Because preemptible RCU does not exist, we never have to check for
Paul E. McKenney1ed509a2010-02-22 17:05:05 -0800850 * tasks blocked within RCU read-side critical sections.
851 */
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700852static int rcu_print_task_stall(struct rcu_node *rnp)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700853{
Paul E. McKenney9bc8b552011-08-13 13:31:47 -0700854 return 0;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700855}
856
Paul E. McKenney53d84e02010-08-10 14:28:53 -0700857/*
Paul E. McKenney74611ec2015-08-18 10:20:43 -0700858 * Because preemptible RCU does not exist, we never have to check for
859 * tasks blocked within RCU read-side critical sections that are
860 * blocking the current expedited grace period.
861 */
862static int rcu_print_task_exp_stall(struct rcu_node *rnp)
863{
864 return 0;
865}
866
867/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800868 * Because there is no preemptible RCU, there can be no readers blocked,
Paul E. McKenney49e29122009-09-18 09:50:19 -0700869 * so there is no need to check for blocked tasks. So check only for
870 * bogus qsmask values.
Paul E. McKenneyb0e165c02009-09-13 09:15:09 -0700871 */
872static void rcu_preempt_check_blocked_tasks(struct rcu_node *rnp)
873{
Paul E. McKenney49e29122009-09-18 09:50:19 -0700874 WARN_ON_ONCE(rnp->qsmask);
Paul E. McKenneyb0e165c02009-09-13 09:15:09 -0700875}
876
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -0700877/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800878 * Because preemptible RCU does not exist, it never has any callbacks
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700879 * to check.
880 */
Paul E. McKenney86aea0e2014-10-21 08:12:00 -0700881static void rcu_preempt_check_callbacks(void)
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700882{
883}
884
885/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800886 * Because preemptible RCU does not exist, rcu_barrier() is just
Paul E. McKenneye74f4c42009-10-06 21:48:17 -0700887 * another name for rcu_barrier_sched().
888 */
889void rcu_barrier(void)
890{
891 rcu_barrier_sched();
892}
893EXPORT_SYMBOL_GPL(rcu_barrier);
894
895/*
Paul E. McKenney6cc68792011-03-02 13:15:15 -0800896 * Because preemptible RCU does not exist, it need not be initialized.
Paul E. McKenney1eba8f82009-09-23 09:50:42 -0700897 */
898static void __init __rcu_init_preempt(void)
899{
900}
901
Paul E. McKenney2439b692013-04-11 10:15:52 -0700902/*
903 * Because preemptible RCU does not exist, tasks cannot possibly exit
904 * while in preemptible RCU read-side critical sections.
905 */
906void exit_rcu(void)
907{
908}
909
Pranith Kumar28f65692014-09-22 14:00:48 -0400910#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
Paul E. McKenney8bd93a22010-02-22 17:04:59 -0800911
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800912#ifdef CONFIG_RCU_BOOST
913
Peter Zijlstra1696a8b2013-10-31 18:18:19 +0100914#include "../locking/rtmutex_common.h"
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800915
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +0000916static void rcu_wake_cond(struct task_struct *t, int status)
917{
918 /*
919 * If the thread is yielding, only wake it when this
920 * is invoked from idle
921 */
922 if (status != RCU_KTHREAD_YIELDING || is_idle_task(current))
923 wake_up_process(t);
924}
925
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800926/*
927 * Carry out RCU priority boosting on the task indicated by ->exp_tasks
928 * or ->boost_tasks, advancing the pointer to the next task in the
929 * ->blkd_tasks list.
930 *
931 * Note that irqs must be enabled: boosting the task can block.
932 * Returns 1 if there are more tasks needing to be boosted.
933 */
934static int rcu_boost(struct rcu_node *rnp)
935{
936 unsigned long flags;
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800937 struct task_struct *t;
938 struct list_head *tb;
939
Paul E. McKenney7d0ae802015-03-03 14:57:58 -0800940 if (READ_ONCE(rnp->exp_tasks) == NULL &&
941 READ_ONCE(rnp->boost_tasks) == NULL)
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800942 return 0; /* Nothing left to boost. */
943
Peter Zijlstra2a67e742015-10-08 12:24:23 +0200944 raw_spin_lock_irqsave_rcu_node(rnp, flags);
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800945
946 /*
947 * Recheck under the lock: all tasks in need of boosting
948 * might exit their RCU read-side critical sections on their own.
949 */
950 if (rnp->exp_tasks == NULL && rnp->boost_tasks == NULL) {
Boqun Feng67c583a72015-12-29 12:18:47 +0800951 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800952 return 0;
953 }
954
955 /*
956 * Preferentially boost tasks blocking expedited grace periods.
957 * This cannot starve the normal grace periods because a second
958 * expedited grace period must boost all blocked tasks, including
959 * those blocking the pre-existing normal grace period.
960 */
Paul E. McKenney0ea1f2e2011-02-22 13:42:43 -0800961 if (rnp->exp_tasks != NULL) {
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800962 tb = rnp->exp_tasks;
Paul E. McKenney0ea1f2e2011-02-22 13:42:43 -0800963 rnp->n_exp_boosts++;
964 } else {
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800965 tb = rnp->boost_tasks;
Paul E. McKenney0ea1f2e2011-02-22 13:42:43 -0800966 rnp->n_normal_boosts++;
967 }
968 rnp->n_tasks_boosted++;
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800969
970 /*
971 * We boost task t by manufacturing an rt_mutex that appears to
972 * be held by task t. We leave a pointer to that rt_mutex where
973 * task t can find it, and task t will release the mutex when it
974 * exits its outermost RCU read-side critical section. Then
975 * simply acquiring this artificial rt_mutex will boost task
976 * t's priority. (Thanks to tglx for suggesting this approach!)
977 *
978 * Note that task t must acquire rnp->lock to remove itself from
979 * the ->blkd_tasks list, which it will do from exit() if from
980 * nowhere else. We therefore are guaranteed that task t will
981 * stay around at least until we drop rnp->lock. Note that
982 * rnp->lock also resolves races between our priority boosting
983 * and task t's exiting its outermost RCU read-side critical
984 * section.
985 */
986 t = container_of(tb, struct task_struct, rcu_node_entry);
Paul E. McKenneyabaa93d2014-06-12 13:30:25 -0700987 rt_mutex_init_proxy_locked(&rnp->boost_mtx, t);
Boqun Feng67c583a72015-12-29 12:18:47 +0800988 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenneyabaa93d2014-06-12 13:30:25 -0700989 /* Lock only for side effect: boosts task t's priority. */
990 rt_mutex_lock(&rnp->boost_mtx);
991 rt_mutex_unlock(&rnp->boost_mtx); /* Then keep lockdep happy. */
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800992
Paul E. McKenney7d0ae802015-03-03 14:57:58 -0800993 return READ_ONCE(rnp->exp_tasks) != NULL ||
994 READ_ONCE(rnp->boost_tasks) != NULL;
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800995}
996
997/*
Paul E. McKenneybc17ea12015-06-06 08:11:43 -0700998 * Priority-boosting kthread, one per leaf rcu_node.
Paul E. McKenney27f4d282011-02-07 12:47:15 -0800999 */
1000static int rcu_boost_kthread(void *arg)
1001{
1002 struct rcu_node *rnp = (struct rcu_node *)arg;
1003 int spincnt = 0;
1004 int more2boost;
1005
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001006 trace_rcu_utilization(TPS("Start boost kthread@init"));
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001007 for (;;) {
Paul E. McKenneyd71df902011-03-29 17:48:28 -07001008 rnp->boost_kthread_status = RCU_KTHREAD_WAITING;
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001009 trace_rcu_utilization(TPS("End boost kthread@rcu_wait"));
Peter Zijlstra08bca602011-05-20 16:06:29 -07001010 rcu_wait(rnp->boost_tasks || rnp->exp_tasks);
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001011 trace_rcu_utilization(TPS("Start boost kthread@rcu_wait"));
Paul E. McKenneyd71df902011-03-29 17:48:28 -07001012 rnp->boost_kthread_status = RCU_KTHREAD_RUNNING;
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001013 more2boost = rcu_boost(rnp);
1014 if (more2boost)
1015 spincnt++;
1016 else
1017 spincnt = 0;
1018 if (spincnt > 10) {
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001019 rnp->boost_kthread_status = RCU_KTHREAD_YIELDING;
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001020 trace_rcu_utilization(TPS("End boost kthread@rcu_yield"));
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001021 schedule_timeout_interruptible(2);
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001022 trace_rcu_utilization(TPS("Start boost kthread@rcu_yield"));
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001023 spincnt = 0;
1024 }
1025 }
Paul E. McKenney1217ed12011-05-04 21:43:49 -07001026 /* NOTREACHED */
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001027 trace_rcu_utilization(TPS("End boost kthread@notreached"));
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001028 return 0;
1029}
1030
1031/*
1032 * Check to see if it is time to start boosting RCU readers that are
1033 * blocking the current grace period, and, if so, tell the per-rcu_node
1034 * kthread to start boosting them. If there is an expedited grace
1035 * period in progress, it is always time to boost.
1036 *
Paul E. McKenneyb065a852012-08-01 15:57:54 -07001037 * The caller must hold rnp->lock, which this function releases.
1038 * The ->boost_kthread_task is immortal, so we don't need to worry
1039 * about it going away.
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001040 */
Paul E. McKenney1217ed12011-05-04 21:43:49 -07001041static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags)
Pranith Kumar615e41c2014-06-11 16:39:40 -04001042 __releases(rnp->lock)
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001043{
1044 struct task_struct *t;
1045
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -07001046 lockdep_assert_held(&rnp->lock);
Paul E. McKenney0ea1f2e2011-02-22 13:42:43 -08001047 if (!rcu_preempt_blocked_readers_cgp(rnp) && rnp->exp_tasks == NULL) {
Boqun Feng67c583a72015-12-29 12:18:47 +08001048 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001049 return;
Paul E. McKenney0ea1f2e2011-02-22 13:42:43 -08001050 }
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001051 if (rnp->exp_tasks != NULL ||
1052 (rnp->gp_tasks != NULL &&
1053 rnp->boost_tasks == NULL &&
1054 rnp->qsmask == 0 &&
1055 ULONG_CMP_GE(jiffies, rnp->boost_time))) {
1056 if (rnp->exp_tasks == NULL)
1057 rnp->boost_tasks = rnp->gp_tasks;
Boqun Feng67c583a72015-12-29 12:18:47 +08001058 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001059 t = rnp->boost_kthread_task;
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001060 if (t)
1061 rcu_wake_cond(t, rnp->boost_kthread_status);
Paul E. McKenney1217ed12011-05-04 21:43:49 -07001062 } else {
Boqun Feng67c583a72015-12-29 12:18:47 +08001063 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney1217ed12011-05-04 21:43:49 -07001064 }
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001065}
1066
Paul E. McKenney0f962a52011-04-14 12:13:53 -07001067/*
Paul E. McKenneya46e0892011-06-15 15:47:09 -07001068 * Wake up the per-CPU kthread to invoke RCU callbacks.
1069 */
1070static void invoke_rcu_callbacks_kthread(void)
1071{
1072 unsigned long flags;
1073
1074 local_irq_save(flags);
1075 __this_cpu_write(rcu_cpu_has_work, 1);
Shaohua Li1eb52122011-06-16 16:02:54 -07001076 if (__this_cpu_read(rcu_cpu_kthread_task) != NULL &&
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001077 current != __this_cpu_read(rcu_cpu_kthread_task)) {
1078 rcu_wake_cond(__this_cpu_read(rcu_cpu_kthread_task),
1079 __this_cpu_read(rcu_cpu_kthread_status));
1080 }
Paul E. McKenneya46e0892011-06-15 15:47:09 -07001081 local_irq_restore(flags);
1082}
1083
1084/*
Paul E. McKenneydff16722011-11-29 15:57:13 -08001085 * Is the current CPU running the RCU-callbacks kthread?
1086 * Caller must have preemption disabled.
1087 */
1088static bool rcu_is_callbacks_kthread(void)
1089{
Christoph Lameterc9d4b0a2013-08-31 13:34:10 -07001090 return __this_cpu_read(rcu_cpu_kthread_task) == current;
Paul E. McKenneydff16722011-11-29 15:57:13 -08001091}
1092
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001093#define RCU_BOOST_DELAY_JIFFIES DIV_ROUND_UP(CONFIG_RCU_BOOST_DELAY * HZ, 1000)
1094
1095/*
1096 * Do priority-boost accounting for the start of a new grace period.
1097 */
1098static void rcu_preempt_boost_start_gp(struct rcu_node *rnp)
1099{
1100 rnp->boost_time = jiffies + RCU_BOOST_DELAY_JIFFIES;
1101}
1102
1103/*
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001104 * Create an RCU-boost kthread for the specified node if one does not
1105 * already exist. We only create this kthread for preemptible RCU.
1106 * Returns zero if all is well, a negated errno otherwise.
1107 */
Paul Gortmaker49fb4c62013-06-19 14:52:21 -04001108static int rcu_spawn_one_boost_kthread(struct rcu_state *rsp,
Paul E. McKenney0aa04b02015-01-23 21:52:37 -08001109 struct rcu_node *rnp)
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001110{
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001111 int rnp_index = rnp - &rsp->node[0];
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001112 unsigned long flags;
1113 struct sched_param sp;
1114 struct task_struct *t;
1115
Paul E. McKenneye63c8872015-03-03 12:56:43 -08001116 if (rcu_state_p != rsp)
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001117 return 0;
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001118
Paul E. McKenney0aa04b02015-01-23 21:52:37 -08001119 if (!rcu_scheduler_fully_active || rcu_rnp_online_cpus(rnp) == 0)
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001120 return 0;
1121
Paul E. McKenneya46e0892011-06-15 15:47:09 -07001122 rsp->boost = 1;
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001123 if (rnp->boost_kthread_task != NULL)
1124 return 0;
1125 t = kthread_create(rcu_boost_kthread, (void *)rnp,
Mike Galbraith5b61b0b2011-08-19 11:39:11 -07001126 "rcub/%d", rnp_index);
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001127 if (IS_ERR(t))
1128 return PTR_ERR(t);
Peter Zijlstra2a67e742015-10-08 12:24:23 +02001129 raw_spin_lock_irqsave_rcu_node(rnp, flags);
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001130 rnp->boost_kthread_task = t;
Boqun Feng67c583a72015-12-29 12:18:47 +08001131 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Clark Williams21871d72014-09-12 21:21:09 -05001132 sp.sched_priority = kthread_prio;
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001133 sched_setscheduler_nocheck(t, SCHED_FIFO, &sp);
Paul E. McKenney9a432732011-05-30 20:38:55 -07001134 wake_up_process(t); /* get to TASK_INTERRUPTIBLE quickly. */
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001135 return 0;
1136}
1137
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001138static void rcu_kthread_do_work(void)
1139{
Christoph Lameterc9d4b0a2013-08-31 13:34:10 -07001140 rcu_do_batch(&rcu_sched_state, this_cpu_ptr(&rcu_sched_data));
1141 rcu_do_batch(&rcu_bh_state, this_cpu_ptr(&rcu_bh_data));
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001142 rcu_preempt_do_callbacks();
1143}
1144
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001145static void rcu_cpu_kthread_setup(unsigned int cpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001146{
1147 struct sched_param sp;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001148
Clark Williams21871d72014-09-12 21:21:09 -05001149 sp.sched_priority = kthread_prio;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001150 sched_setscheduler_nocheck(current, SCHED_FIFO, &sp);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001151}
1152
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001153static void rcu_cpu_kthread_park(unsigned int cpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001154{
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001155 per_cpu(rcu_cpu_kthread_status, cpu) = RCU_KTHREAD_OFFCPU;
1156}
1157
1158static int rcu_cpu_kthread_should_run(unsigned int cpu)
1159{
Christoph Lameterc9d4b0a2013-08-31 13:34:10 -07001160 return __this_cpu_read(rcu_cpu_has_work);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001161}
1162
1163/*
1164 * Per-CPU kernel thread that invokes RCU callbacks. This replaces the
Paul E. McKenneye0f23062011-06-21 01:29:39 -07001165 * RCU softirq used in flavors and configurations of RCU that do not
1166 * support RCU priority boosting.
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001167 */
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001168static void rcu_cpu_kthread(unsigned int cpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001169{
Christoph Lameterc9d4b0a2013-08-31 13:34:10 -07001170 unsigned int *statusp = this_cpu_ptr(&rcu_cpu_kthread_status);
1171 char work, *workp = this_cpu_ptr(&rcu_cpu_has_work);
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001172 int spincnt;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001173
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001174 for (spincnt = 0; spincnt < 10; spincnt++) {
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001175 trace_rcu_utilization(TPS("Start CPU kthread@rcu_wait"));
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001176 local_bh_disable();
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001177 *statusp = RCU_KTHREAD_RUNNING;
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001178 this_cpu_inc(rcu_cpu_kthread_loops);
1179 local_irq_disable();
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001180 work = *workp;
1181 *workp = 0;
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001182 local_irq_enable();
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001183 if (work)
1184 rcu_kthread_do_work();
1185 local_bh_enable();
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001186 if (*workp == 0) {
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001187 trace_rcu_utilization(TPS("End CPU kthread@rcu_wait"));
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001188 *statusp = RCU_KTHREAD_WAITING;
1189 return;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001190 }
1191 }
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001192 *statusp = RCU_KTHREAD_YIELDING;
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001193 trace_rcu_utilization(TPS("Start CPU kthread@rcu_yield"));
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001194 schedule_timeout_interruptible(2);
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04001195 trace_rcu_utilization(TPS("End CPU kthread@rcu_yield"));
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001196 *statusp = RCU_KTHREAD_WAITING;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001197}
1198
1199/*
1200 * Set the per-rcu_node kthread's affinity to cover all CPUs that are
1201 * served by the rcu_node in question. The CPU hotplug lock is still
1202 * held, so the value of rnp->qsmaskinit will be stable.
1203 *
1204 * We don't include outgoingcpu in the affinity set, use -1 if there is
1205 * no outgoing CPU. If there are no CPUs left in the affinity set,
1206 * this function allows the kthread to execute on any CPU.
1207 */
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001208static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001209{
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001210 struct task_struct *t = rnp->boost_kthread_task;
Paul E. McKenney0aa04b02015-01-23 21:52:37 -08001211 unsigned long mask = rcu_rnp_online_cpus(rnp);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001212 cpumask_var_t cm;
1213 int cpu;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001214
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001215 if (!t)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001216 return;
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001217 if (!zalloc_cpumask_var(&cm, GFP_KERNEL))
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001218 return;
Mark Rutlandbc75e992016-06-03 15:20:04 +01001219 for_each_leaf_node_possible_cpu(rnp, cpu)
1220 if ((mask & leaf_node_cpu_bit(rnp, cpu)) &&
1221 cpu != outgoingcpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001222 cpumask_set_cpu(cpu, cm);
Paul E. McKenney5d0b0242014-11-10 08:07:08 -08001223 if (cpumask_weight(cm) == 0)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001224 cpumask_setall(cm);
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001225 set_cpus_allowed_ptr(t, cm);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001226 free_cpumask_var(cm);
1227}
1228
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001229static struct smp_hotplug_thread rcu_cpu_thread_spec = {
1230 .store = &rcu_cpu_kthread_task,
1231 .thread_should_run = rcu_cpu_kthread_should_run,
1232 .thread_fn = rcu_cpu_kthread,
1233 .thread_comm = "rcuc/%u",
1234 .setup = rcu_cpu_kthread_setup,
1235 .park = rcu_cpu_kthread_park,
1236};
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001237
1238/*
Paul E. McKenney9386c0b2014-07-13 12:00:53 -07001239 * Spawn boost kthreads -- called as soon as the scheduler is running.
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001240 */
Paul E. McKenney9386c0b2014-07-13 12:00:53 -07001241static void __init rcu_spawn_boost_kthreads(void)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001242{
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001243 struct rcu_node *rnp;
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001244 int cpu;
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001245
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001246 for_each_possible_cpu(cpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001247 per_cpu(rcu_cpu_has_work, cpu) = 0;
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001248 BUG_ON(smpboot_register_percpu_thread(&rcu_cpu_thread_spec));
Paul E. McKenney3e9f5c72014-11-03 18:15:17 -08001249 rcu_for_each_leaf_node(rcu_state_p, rnp)
1250 (void)rcu_spawn_one_boost_kthread(rcu_state_p, rnp);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001251}
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001252
Paul Gortmaker49fb4c62013-06-19 14:52:21 -04001253static void rcu_prepare_kthreads(int cpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001254{
Uma Sharmae5341652014-03-23 22:32:09 -07001255 struct rcu_data *rdp = per_cpu_ptr(rcu_state_p->rda, cpu);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001256 struct rcu_node *rnp = rdp->mynode;
1257
1258 /* Fire up the incoming CPU's kthread and leaf rcu_node kthread. */
Paul E. McKenney62ab7072012-07-16 10:42:38 +00001259 if (rcu_scheduler_fully_active)
Uma Sharmae5341652014-03-23 22:32:09 -07001260 (void)rcu_spawn_one_boost_kthread(rcu_state_p, rnp);
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001261}
1262
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001263#else /* #ifdef CONFIG_RCU_BOOST */
1264
Paul E. McKenney1217ed12011-05-04 21:43:49 -07001265static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags)
Pranith Kumar615e41c2014-06-11 16:39:40 -04001266 __releases(rnp->lock)
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001267{
Boqun Feng67c583a72015-12-29 12:18:47 +08001268 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001269}
1270
Paul E. McKenneya46e0892011-06-15 15:47:09 -07001271static void invoke_rcu_callbacks_kthread(void)
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001272{
Paul E. McKenneya46e0892011-06-15 15:47:09 -07001273 WARN_ON_ONCE(1);
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001274}
1275
Paul E. McKenneydff16722011-11-29 15:57:13 -08001276static bool rcu_is_callbacks_kthread(void)
1277{
1278 return false;
1279}
1280
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001281static void rcu_preempt_boost_start_gp(struct rcu_node *rnp)
1282{
1283}
1284
Thomas Gleixner5d01bbd2012-07-16 10:42:35 +00001285static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001286{
1287}
1288
Paul E. McKenney9386c0b2014-07-13 12:00:53 -07001289static void __init rcu_spawn_boost_kthreads(void)
Paul E. McKenneyb0d30412011-07-10 15:57:35 -07001290{
Paul E. McKenneyb0d30412011-07-10 15:57:35 -07001291}
Paul E. McKenneyb0d30412011-07-10 15:57:35 -07001292
Paul Gortmaker49fb4c62013-06-19 14:52:21 -04001293static void rcu_prepare_kthreads(int cpu)
Paul E. McKenneyf8b7fc62011-06-16 08:26:32 -07001294{
1295}
1296
Paul E. McKenney27f4d282011-02-07 12:47:15 -08001297#endif /* #else #ifdef CONFIG_RCU_BOOST */
1298
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001299#if !defined(CONFIG_RCU_FAST_NO_HZ)
1300
1301/*
1302 * Check to see if any future RCU-related work will need to be done
1303 * by the current CPU, even if none need be done immediately, returning
1304 * 1 if so. This function is part of the RCU implementation; it is -not-
1305 * an exported member of the RCU API.
1306 *
Paul E. McKenney7cb92492011-11-28 12:28:34 -08001307 * Because we not have RCU_FAST_NO_HZ, just check whether this CPU needs
1308 * any flavor of RCU.
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001309 */
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001310int rcu_needs_cpu(u64 basemono, u64 *nextevt)
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001311{
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001312 *nextevt = KTIME_MAX;
Paul E. McKenney44c65ff2017-05-15 16:26:34 -07001313 return rcu_cpu_has_callbacks(NULL);
Paul E. McKenney7cb92492011-11-28 12:28:34 -08001314}
1315
1316/*
1317 * Because we do not have RCU_FAST_NO_HZ, don't bother cleaning up
1318 * after it.
1319 */
Paul E. McKenney8fa78452014-10-22 15:07:37 -07001320static void rcu_cleanup_after_idle(void)
Paul E. McKenney7cb92492011-11-28 12:28:34 -08001321{
1322}
1323
1324/*
Paul E. McKenneya858af22012-01-16 13:29:10 -08001325 * Do the idle-entry grace-period work, which, because CONFIG_RCU_FAST_NO_HZ=n,
Paul E. McKenneyaea1b352011-11-02 06:54:54 -07001326 * is nothing.
1327 */
Paul E. McKenney198bbf82014-10-22 15:03:43 -07001328static void rcu_prepare_for_idle(void)
Paul E. McKenneyaea1b352011-11-02 06:54:54 -07001329{
1330}
1331
Paul E. McKenneyc57afe82012-02-28 11:02:21 -08001332/*
1333 * Don't bother keeping a running count of the number of RCU callbacks
1334 * posted because CONFIG_RCU_FAST_NO_HZ=n.
1335 */
1336static void rcu_idle_count_callbacks_posted(void)
1337{
1338}
1339
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001340#else /* #if !defined(CONFIG_RCU_FAST_NO_HZ) */
1341
Paul E. McKenneyf23f7fa2011-11-30 15:41:14 -08001342/*
1343 * This code is invoked when a CPU goes idle, at which point we want
1344 * to have the CPU do everything required for RCU so that it can enter
1345 * the energy-efficient dyntick-idle mode. This is handled by a
1346 * state machine implemented by rcu_prepare_for_idle() below.
1347 *
1348 * The following three proprocessor symbols control this state machine:
1349 *
Paul E. McKenneyf23f7fa2011-11-30 15:41:14 -08001350 * RCU_IDLE_GP_DELAY gives the number of jiffies that a CPU is permitted
1351 * to sleep in dyntick-idle mode with RCU callbacks pending. This
1352 * is sized to be roughly one RCU grace period. Those energy-efficiency
1353 * benchmarkers who might otherwise be tempted to set this to a large
1354 * number, be warned: Setting RCU_IDLE_GP_DELAY too high can hang your
1355 * system. And if you are -that- concerned about energy efficiency,
1356 * just power the system down and be done with it!
Paul E. McKenney778d2502012-01-10 14:13:24 -08001357 * RCU_IDLE_LAZY_GP_DELAY gives the number of jiffies that a CPU is
1358 * permitted to sleep in dyntick-idle mode with only lazy RCU
1359 * callbacks pending. Setting this too high can OOM your system.
Paul E. McKenneyf23f7fa2011-11-30 15:41:14 -08001360 *
1361 * The values below work well in practice. If future workloads require
1362 * adjustment, they can be converted into kernel config parameters, though
1363 * making the state machine smarter might be a better option.
1364 */
Paul E. McKenneye84c48a2012-06-04 20:45:10 -07001365#define RCU_IDLE_GP_DELAY 4 /* Roughly one grace period. */
Paul E. McKenney778d2502012-01-10 14:13:24 -08001366#define RCU_IDLE_LAZY_GP_DELAY (6 * HZ) /* Roughly six seconds. */
Paul E. McKenneyf23f7fa2011-11-30 15:41:14 -08001367
Paul E. McKenney5e44ce32012-12-12 12:35:29 -08001368static int rcu_idle_gp_delay = RCU_IDLE_GP_DELAY;
1369module_param(rcu_idle_gp_delay, int, 0644);
1370static int rcu_idle_lazy_gp_delay = RCU_IDLE_LAZY_GP_DELAY;
1371module_param(rcu_idle_lazy_gp_delay, int, 0644);
1372
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001373/*
Paul E. McKenneyc2298282013-08-25 21:20:47 -07001374 * Try to advance callbacks for all flavors of RCU on the current CPU, but
1375 * only if it has been awhile since the last time we did so. Afterwards,
1376 * if there are any callbacks ready for immediate invocation, return true.
Paul E. McKenney486e2592012-01-06 14:11:30 -08001377 */
Paul E. McKenneyf1f399d2013-11-17 21:08:07 -08001378static bool __maybe_unused rcu_try_advance_all_cbs(void)
Paul E. McKenney486e2592012-01-06 14:11:30 -08001379{
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001380 bool cbs_ready = false;
1381 struct rcu_data *rdp;
Paul E. McKenneyc2298282013-08-25 21:20:47 -07001382 struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001383 struct rcu_node *rnp;
1384 struct rcu_state *rsp;
Paul E. McKenney486e2592012-01-06 14:11:30 -08001385
Paul E. McKenneyc2298282013-08-25 21:20:47 -07001386 /* Exit early if we advanced recently. */
1387 if (jiffies == rdtp->last_advance_all)
Pranith Kumard0bc90f2014-07-08 18:26:13 -04001388 return false;
Paul E. McKenneyc2298282013-08-25 21:20:47 -07001389 rdtp->last_advance_all = jiffies;
1390
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001391 for_each_rcu_flavor(rsp) {
1392 rdp = this_cpu_ptr(rsp->rda);
1393 rnp = rdp->mynode;
Paul E. McKenney486e2592012-01-06 14:11:30 -08001394
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001395 /*
1396 * Don't bother checking unless a grace period has
1397 * completed since we last checked and there are
1398 * callbacks not yet ready to invoke.
1399 */
Paul E. McKenneye3663b12014-12-08 20:26:55 -08001400 if ((rdp->completed != rnp->completed ||
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001401 unlikely(READ_ONCE(rdp->gpwrap))) &&
Paul E. McKenney15fecf82017-02-08 12:36:42 -08001402 rcu_segcblist_pend_cbs(&rdp->cblist))
Paul E. McKenney470716f2013-03-19 11:32:11 -07001403 note_gp_changes(rsp, rdp);
Paul E. McKenney486e2592012-01-06 14:11:30 -08001404
Paul E. McKenney15fecf82017-02-08 12:36:42 -08001405 if (rcu_segcblist_ready_cbs(&rdp->cblist))
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001406 cbs_ready = true;
1407 }
1408 return cbs_ready;
Paul E. McKenney486e2592012-01-06 14:11:30 -08001409}
1410
1411/*
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001412 * Allow the CPU to enter dyntick-idle mode unless it has callbacks ready
1413 * to invoke. If the CPU has callbacks, try to advance them. Tell the
1414 * caller to set the timeout based on whether or not there are non-lazy
1415 * callbacks.
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001416 *
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001417 * The caller must have disabled interrupts.
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001418 */
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001419int rcu_needs_cpu(u64 basemono, u64 *nextevt)
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001420{
Paul E. McKenneyaa6da512014-10-21 13:23:08 -07001421 struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001422 unsigned long dj;
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001423
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -07001424 RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_needs_cpu() invoked with irqs enabled!!!");
Paul E. McKenney3382adb2015-03-04 15:41:24 -08001425
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001426 /* Snapshot to detect later posting of non-lazy callback. */
1427 rdtp->nonlazy_posted_snap = rdtp->nonlazy_posted;
1428
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001429 /* If no callbacks, RCU doesn't need the CPU. */
Paul E. McKenneyaa6da512014-10-21 13:23:08 -07001430 if (!rcu_cpu_has_callbacks(&rdtp->all_lazy)) {
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001431 *nextevt = KTIME_MAX;
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001432 return 0;
1433 }
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001434
1435 /* Attempt to advance callbacks. */
1436 if (rcu_try_advance_all_cbs()) {
1437 /* Some ready to invoke, so initiate later invocation. */
1438 invoke_rcu_core();
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001439 return 1;
1440 }
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001441 rdtp->last_accelerate = jiffies;
1442
1443 /* Request timer delay depending on laziness, and round. */
Paul E. McKenney6faf7282013-05-13 06:53:37 -07001444 if (!rdtp->all_lazy) {
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001445 dj = round_up(rcu_idle_gp_delay + jiffies,
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001446 rcu_idle_gp_delay) - jiffies;
Paul E. McKenneye84c48a2012-06-04 20:45:10 -07001447 } else {
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001448 dj = round_jiffies(rcu_idle_lazy_gp_delay + jiffies) - jiffies;
Paul E. McKenneye84c48a2012-06-04 20:45:10 -07001449 }
Thomas Gleixnerc1ad3482015-04-14 21:08:58 +00001450 *nextevt = basemono + dj * TICK_NSEC;
Paul E. McKenneyaa9b16302012-05-10 16:41:44 -07001451 return 0;
1452}
1453
1454/*
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001455 * Prepare a CPU for idle from an RCU perspective. The first major task
1456 * is to sense whether nohz mode has been enabled or disabled via sysfs.
1457 * The second major task is to check to see if a non-lazy callback has
1458 * arrived at a CPU that previously had only lazy callbacks. The third
1459 * major task is to accelerate (that is, assign grace-period numbers to)
1460 * any recently arrived callbacks.
Paul E. McKenneyaea1b352011-11-02 06:54:54 -07001461 *
1462 * The caller must have disabled interrupts.
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001463 */
Paul E. McKenney198bbf82014-10-22 15:03:43 -07001464static void rcu_prepare_for_idle(void)
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001465{
Paul E. McKenney48a76392014-03-11 13:02:16 -07001466 bool needwake;
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001467 struct rcu_data *rdp;
Paul E. McKenney198bbf82014-10-22 15:03:43 -07001468 struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001469 struct rcu_node *rnp;
1470 struct rcu_state *rsp;
Paul E. McKenney9d2ad242012-06-24 10:15:02 -07001471 int tne;
1472
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -07001473 RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_prepare_for_idle() invoked with irqs enabled!!!");
Paul E. McKenney44c65ff2017-05-15 16:26:34 -07001474 if (rcu_is_nocb_cpu(smp_processor_id()))
Paul E. McKenney3382adb2015-03-04 15:41:24 -08001475 return;
1476
Paul E. McKenney9d2ad242012-06-24 10:15:02 -07001477 /* Handle nohz enablement switches conservatively. */
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001478 tne = READ_ONCE(tick_nohz_active);
Paul E. McKenney9d2ad242012-06-24 10:15:02 -07001479 if (tne != rdtp->tick_nohz_enabled_snap) {
Paul E. McKenneyaa6da512014-10-21 13:23:08 -07001480 if (rcu_cpu_has_callbacks(NULL))
Paul E. McKenney9d2ad242012-06-24 10:15:02 -07001481 invoke_rcu_core(); /* force nohz to see update. */
1482 rdtp->tick_nohz_enabled_snap = tne;
1483 return;
1484 }
1485 if (!tne)
1486 return;
Paul E. McKenneyf511fc62012-03-15 12:16:26 -07001487
Paul E. McKenney3084f2f2011-11-22 17:07:11 -08001488 /*
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001489 * If a non-lazy callback arrived at a CPU having only lazy
1490 * callbacks, invoke RCU core for the side-effect of recalculating
1491 * idle duration on re-entry to idle.
Paul E. McKenneyc57afe82012-02-28 11:02:21 -08001492 */
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001493 if (rdtp->all_lazy &&
1494 rdtp->nonlazy_posted != rdtp->nonlazy_posted_snap) {
Paul E. McKenneyc337f8f2013-09-05 17:02:11 -07001495 rdtp->all_lazy = false;
1496 rdtp->nonlazy_posted_snap = rdtp->nonlazy_posted;
Paul E. McKenneya46e0892011-06-15 15:47:09 -07001497 invoke_rcu_core();
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001498 return;
1499 }
1500
1501 /*
1502 * If we have not yet accelerated this jiffy, accelerate all
1503 * callbacks on this CPU.
1504 */
1505 if (rdtp->last_accelerate == jiffies)
1506 return;
1507 rdtp->last_accelerate = jiffies;
1508 for_each_rcu_flavor(rsp) {
Paul E. McKenney198bbf82014-10-22 15:03:43 -07001509 rdp = this_cpu_ptr(rsp->rda);
Paul E. McKenney15fecf82017-02-08 12:36:42 -08001510 if (rcu_segcblist_pend_cbs(&rdp->cblist))
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001511 continue;
1512 rnp = rdp->mynode;
Peter Zijlstra2a67e742015-10-08 12:24:23 +02001513 raw_spin_lock_rcu_node(rnp); /* irqs already disabled. */
Paul E. McKenney48a76392014-03-11 13:02:16 -07001514 needwake = rcu_accelerate_cbs(rsp, rnp, rdp);
Boqun Feng67c583a72015-12-29 12:18:47 +08001515 raw_spin_unlock_rcu_node(rnp); /* irqs remain disabled. */
Paul E. McKenney48a76392014-03-11 13:02:16 -07001516 if (needwake)
1517 rcu_gp_kthread_wake(rsp);
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001518 }
1519}
1520
1521/*
1522 * Clean up for exit from idle. Attempt to advance callbacks based on
1523 * any grace periods that elapsed while the CPU was idle, and if any
1524 * callbacks are now ready to invoke, initiate invocation.
1525 */
Paul E. McKenney8fa78452014-10-22 15:07:37 -07001526static void rcu_cleanup_after_idle(void)
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001527{
Paul E. McKenneyea9b0c82017-04-28 13:19:28 -07001528 RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_cleanup_after_idle() invoked with irqs enabled!!!");
Paul E. McKenney44c65ff2017-05-15 16:26:34 -07001529 if (rcu_is_nocb_cpu(smp_processor_id()))
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001530 return;
Paul E. McKenney7a497c92013-08-22 18:16:16 -07001531 if (rcu_try_advance_all_cbs())
1532 invoke_rcu_core();
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001533}
1534
Paul E. McKenneyc57afe82012-02-28 11:02:21 -08001535/*
Paul E. McKenney98248a02012-05-03 15:38:10 -07001536 * Keep a running count of the number of non-lazy callbacks posted
1537 * on this CPU. This running counter (which is never decremented) allows
1538 * rcu_prepare_for_idle() to detect when something out of the idle loop
1539 * posts a callback, even if an equal number of callbacks are invoked.
1540 * Of course, callbacks should only be posted from within a trace event
1541 * designed to be called from idle or from within RCU_NONIDLE().
Paul E. McKenneyc57afe82012-02-28 11:02:21 -08001542 */
1543static void rcu_idle_count_callbacks_posted(void)
1544{
Paul E. McKenney5955f7e2012-05-09 12:07:05 -07001545 __this_cpu_add(rcu_dynticks.nonlazy_posted, 1);
Paul E. McKenneyc57afe82012-02-28 11:02:21 -08001546}
1547
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -07001548/*
1549 * Data for flushing lazy RCU callbacks at OOM time.
1550 */
1551static atomic_t oom_callback_count;
1552static DECLARE_WAIT_QUEUE_HEAD(oom_callback_wq);
1553
1554/*
1555 * RCU OOM callback -- decrement the outstanding count and deliver the
1556 * wake-up if we are the last one.
1557 */
1558static void rcu_oom_callback(struct rcu_head *rhp)
1559{
1560 if (atomic_dec_and_test(&oom_callback_count))
1561 wake_up(&oom_callback_wq);
1562}
1563
1564/*
1565 * Post an rcu_oom_notify callback on the current CPU if it has at
1566 * least one lazy callback. This will unnecessarily post callbacks
1567 * to CPUs that already have a non-lazy callback at the end of their
1568 * callback list, but this is an infrequent operation, so accept some
1569 * extra overhead to keep things simple.
1570 */
1571static void rcu_oom_notify_cpu(void *unused)
1572{
1573 struct rcu_state *rsp;
1574 struct rcu_data *rdp;
1575
1576 for_each_rcu_flavor(rsp) {
Christoph Lameterfa07a582014-04-15 12:20:12 -07001577 rdp = raw_cpu_ptr(rsp->rda);
Paul E. McKenney15fecf82017-02-08 12:36:42 -08001578 if (rcu_segcblist_n_lazy_cbs(&rdp->cblist)) {
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -07001579 atomic_inc(&oom_callback_count);
1580 rsp->call(&rdp->oom_head, rcu_oom_callback);
1581 }
1582 }
1583}
1584
1585/*
1586 * If low on memory, ensure that each CPU has a non-lazy callback.
1587 * This will wake up CPUs that have only lazy callbacks, in turn
1588 * ensuring that they free up the corresponding memory in a timely manner.
1589 * Because an uncertain amount of memory will be freed in some uncertain
1590 * timeframe, we do not claim to have freed anything.
1591 */
1592static int rcu_oom_notify(struct notifier_block *self,
1593 unsigned long notused, void *nfreed)
1594{
1595 int cpu;
1596
1597 /* Wait for callbacks from earlier instance to complete. */
1598 wait_event(oom_callback_wq, atomic_read(&oom_callback_count) == 0);
Paul E. McKenney78e4bc32013-09-24 15:04:06 -07001599 smp_mb(); /* Ensure callback reuse happens after callback invocation. */
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -07001600
1601 /*
1602 * Prevent premature wakeup: ensure that all increments happen
1603 * before there is a chance of the counter reaching zero.
1604 */
1605 atomic_set(&oom_callback_count, 1);
1606
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -07001607 for_each_online_cpu(cpu) {
1608 smp_call_function_single(cpu, rcu_oom_notify_cpu, NULL, 1);
Paul E. McKenneybde6c3a2014-07-01 11:26:57 -07001609 cond_resched_rcu_qs();
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -07001610 }
Paul E. McKenneyb626c1b2012-06-11 17:39:43 -07001611
1612 /* Unconditionally decrement: no need to wake ourselves up. */
1613 atomic_dec(&oom_callback_count);
1614
1615 return NOTIFY_OK;
1616}
1617
1618static struct notifier_block rcu_oom_nb = {
1619 .notifier_call = rcu_oom_notify
1620};
1621
1622static int __init rcu_register_oom_notifier(void)
1623{
1624 register_oom_notifier(&rcu_oom_nb);
1625 return 0;
1626}
1627early_initcall(rcu_register_oom_notifier);
1628
Paul E. McKenney8bd93a22010-02-22 17:04:59 -08001629#endif /* #else #if !defined(CONFIG_RCU_FAST_NO_HZ) */
Paul E. McKenneya858af22012-01-16 13:29:10 -08001630
Paul E. McKenneya858af22012-01-16 13:29:10 -08001631#ifdef CONFIG_RCU_FAST_NO_HZ
1632
1633static void print_cpu_stall_fast_no_hz(char *cp, int cpu)
1634{
Paul E. McKenney5955f7e2012-05-09 12:07:05 -07001635 struct rcu_dynticks *rdtp = &per_cpu(rcu_dynticks, cpu);
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001636 unsigned long nlpd = rdtp->nonlazy_posted - rdtp->nonlazy_posted_snap;
Paul E. McKenneya858af22012-01-16 13:29:10 -08001637
Paul E. McKenneyc0f4dfd2012-12-28 11:30:36 -08001638 sprintf(cp, "last_accelerate: %04lx/%04lx, nonlazy_posted: %ld, %c%c",
1639 rdtp->last_accelerate & 0xffff, jiffies & 0xffff,
1640 ulong2long(nlpd),
1641 rdtp->all_lazy ? 'L' : '.',
1642 rdtp->tick_nohz_enabled_snap ? '.' : 'D');
Paul E. McKenneya858af22012-01-16 13:29:10 -08001643}
1644
1645#else /* #ifdef CONFIG_RCU_FAST_NO_HZ */
1646
1647static void print_cpu_stall_fast_no_hz(char *cp, int cpu)
1648{
Carsten Emde1c17e4d2012-06-19 10:43:16 +02001649 *cp = '\0';
Paul E. McKenneya858af22012-01-16 13:29:10 -08001650}
1651
1652#endif /* #else #ifdef CONFIG_RCU_FAST_NO_HZ */
1653
1654/* Initiate the stall-info list. */
1655static void print_cpu_stall_info_begin(void)
1656{
Paul E. McKenneyefc151c2013-03-18 16:24:11 -07001657 pr_cont("\n");
Paul E. McKenneya858af22012-01-16 13:29:10 -08001658}
1659
1660/*
1661 * Print out diagnostic information for the specified stalled CPU.
1662 *
1663 * If the specified CPU is aware of the current RCU grace period
1664 * (flavor specified by rsp), then print the number of scheduling
1665 * clock interrupts the CPU has taken during the time that it has
1666 * been aware. Otherwise, print the number of RCU grace periods
1667 * that this CPU is ignorant of, for example, "1" if the CPU was
1668 * aware of the previous grace period.
1669 *
1670 * Also print out idle and (if CONFIG_RCU_FAST_NO_HZ) idle-entry info.
1671 */
1672static void print_cpu_stall_info(struct rcu_state *rsp, int cpu)
1673{
1674 char fast_no_hz[72];
1675 struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
1676 struct rcu_dynticks *rdtp = rdp->dynticks;
1677 char *ticks_title;
1678 unsigned long ticks_value;
1679
1680 if (rsp->gpnum == rdp->gpnum) {
1681 ticks_title = "ticks this GP";
1682 ticks_value = rdp->ticks_this_gp;
1683 } else {
1684 ticks_title = "GPs behind";
1685 ticks_value = rsp->gpnum - rdp->gpnum;
1686 }
1687 print_cpu_stall_fast_no_hz(fast_no_hz, cpu);
Paul E. McKenney7f21aee2015-08-15 14:49:50 -07001688 pr_err("\t%d-%c%c%c: (%lu %s) idle=%03x/%llx/%d softirq=%u/%u fqs=%ld %s\n",
1689 cpu,
1690 "O."[!!cpu_online(cpu)],
1691 "o."[!!(rdp->grpmask & rdp->mynode->qsmaskinit)],
1692 "N."[!!(rdp->grpmask & rdp->mynode->qsmaskinitnext)],
1693 ticks_value, ticks_title,
Paul E. McKenney02a5c5502016-11-02 17:25:06 -07001694 rcu_dynticks_snap(rdtp) & 0xfff,
Paul E. McKenneya858af22012-01-16 13:29:10 -08001695 rdtp->dynticks_nesting, rdtp->dynticks_nmi_nesting,
Paul E. McKenney62310692013-03-06 13:37:09 -08001696 rdp->softirq_snap, kstat_softirqs_cpu(RCU_SOFTIRQ, cpu),
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001697 READ_ONCE(rsp->n_force_qs) - rsp->n_force_qs_gpstart,
Paul E. McKenneya858af22012-01-16 13:29:10 -08001698 fast_no_hz);
1699}
1700
1701/* Terminate the stall-info list. */
1702static void print_cpu_stall_info_end(void)
1703{
Paul E. McKenneyefc151c2013-03-18 16:24:11 -07001704 pr_err("\t");
Paul E. McKenneya858af22012-01-16 13:29:10 -08001705}
1706
1707/* Zero ->ticks_this_gp for all flavors of RCU. */
1708static void zero_cpu_stall_ticks(struct rcu_data *rdp)
1709{
1710 rdp->ticks_this_gp = 0;
Paul E. McKenney62310692013-03-06 13:37:09 -08001711 rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id());
Paul E. McKenneya858af22012-01-16 13:29:10 -08001712}
1713
1714/* Increment ->ticks_this_gp for all flavors of RCU. */
1715static void increment_cpu_stall_ticks(void)
1716{
Paul E. McKenney115f7a72012-08-10 13:55:03 -07001717 struct rcu_state *rsp;
1718
1719 for_each_rcu_flavor(rsp)
Christoph Lameterfa07a582014-04-15 12:20:12 -07001720 raw_cpu_inc(rsp->rda->ticks_this_gp);
Paul E. McKenneya858af22012-01-16 13:29:10 -08001721}
1722
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001723#ifdef CONFIG_RCU_NOCB_CPU
1724
1725/*
1726 * Offload callback processing from the boot-time-specified set of CPUs
1727 * specified by rcu_nocb_mask. For each CPU in the set, there is a
1728 * kthread created that pulls the callbacks from the corresponding CPU,
1729 * waits for a grace period to elapse, and invokes the callbacks.
1730 * The no-CBs CPUs do a wake_up() on their kthread when they insert
1731 * a callback into any empty list, unless the rcu_nocb_poll boot parameter
1732 * has been specified, in which case each kthread actively polls its
1733 * CPU. (Which isn't so great for energy efficiency, but which does
1734 * reduce RCU's overhead on that CPU.)
1735 *
1736 * This is intended to be used in conjunction with Frederic Weisbecker's
1737 * adaptive-idle work, which would seriously reduce OS jitter on CPUs
1738 * running CPU-bound user-mode computations.
1739 *
1740 * Offloading of callback processing could also in theory be used as
1741 * an energy-efficiency measure because CPUs with no RCU callbacks
1742 * queued are more aggressive about entering dyntick-idle mode.
1743 */
1744
1745
1746/* Parse the boot-time rcu_nocb_mask CPU list from the kernel parameters. */
1747static int __init rcu_nocb_setup(char *str)
1748{
1749 alloc_bootmem_cpumask_var(&rcu_nocb_mask);
1750 have_rcu_nocb_mask = true;
1751 cpulist_parse(str, rcu_nocb_mask);
1752 return 1;
1753}
1754__setup("rcu_nocbs=", rcu_nocb_setup);
1755
Paul Gortmaker1b0048a2012-12-20 13:19:22 -08001756static int __init parse_rcu_nocb_poll(char *arg)
1757{
Nicholas Mc Guire5455a7f2017-03-25 20:46:02 +01001758 rcu_nocb_poll = true;
Paul Gortmaker1b0048a2012-12-20 13:19:22 -08001759 return 0;
1760}
1761early_param("rcu_nocb_poll", parse_rcu_nocb_poll);
1762
Paul E. McKenney34ed62462013-01-07 13:37:42 -08001763/*
Paul E. McKenney0446be42012-12-30 15:21:01 -08001764 * Wake up any no-CBs CPUs' kthreads that were waiting on the just-ended
1765 * grace period.
Paul E. McKenneydae6e642013-02-10 20:48:58 -08001766 */
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01001767static void rcu_nocb_gp_cleanup(struct swait_queue_head *sq)
Paul E. McKenneydae6e642013-02-10 20:48:58 -08001768{
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01001769 swake_up_all(sq);
Paul E. McKenneydae6e642013-02-10 20:48:58 -08001770}
1771
1772/*
Paul E. McKenney8b425aa82012-12-30 13:06:35 -08001773 * Set the root rcu_node structure's ->need_future_gp field
Paul E. McKenneydae6e642013-02-10 20:48:58 -08001774 * based on the sum of those of all rcu_node structures. This does
1775 * double-count the root rcu_node structure's requests, but this
1776 * is necessary to handle the possibility of a rcu_nocb_kthread()
1777 * having awakened during the time that the rcu_node structures
1778 * were being updated for the end of the previous grace period.
1779 */
1780static void rcu_nocb_gp_set(struct rcu_node *rnp, int nrq)
1781{
Paul E. McKenney8b425aa82012-12-30 13:06:35 -08001782 rnp->need_future_gp[(rnp->completed + 1) & 0x1] += nrq;
Paul E. McKenneydae6e642013-02-10 20:48:58 -08001783}
1784
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01001785static struct swait_queue_head *rcu_nocb_gp_get(struct rcu_node *rnp)
Daniel Wagner065bb782016-02-19 09:46:40 +01001786{
1787 return &rnp->nocb_gp_wq[rnp->completed & 0x1];
1788}
1789
Paul E. McKenneydae6e642013-02-10 20:48:58 -08001790static void rcu_init_one_nocb(struct rcu_node *rnp)
1791{
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01001792 init_swait_queue_head(&rnp->nocb_gp_wq[0]);
1793 init_swait_queue_head(&rnp->nocb_gp_wq[1]);
Paul E. McKenney34ed62462013-01-07 13:37:42 -08001794}
1795
Liu Ping Fan24342c92014-02-24 06:18:09 -08001796/* Is the specified CPU a no-CBs CPU? */
Frederic Weisbeckerd1e43fa2013-03-26 23:47:24 +01001797bool rcu_is_nocb_cpu(int cpu)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001798{
1799 if (have_rcu_nocb_mask)
1800 return cpumask_test_cpu(cpu, rcu_nocb_mask);
1801 return false;
1802}
1803
1804/*
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001805 * Kick the leader kthread for this NOCB group. Caller holds ->nocb_lock
1806 * and this function releases it.
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07001807 */
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001808static void __wake_nocb_leader(struct rcu_data *rdp, bool force,
1809 unsigned long flags)
1810 __releases(rdp->nocb_lock)
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07001811{
1812 struct rcu_data *rdp_leader = rdp->nocb_leader;
1813
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001814 lockdep_assert_held(&rdp->nocb_lock);
1815 if (!READ_ONCE(rdp_leader->nocb_kthread)) {
1816 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07001817 return;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001818 }
1819 if (rdp_leader->nocb_leader_sleep || force) {
Paul E. McKenney39953df2014-08-12 10:47:48 -07001820 /* Prior smp_mb__after_atomic() orders against prior enqueue. */
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001821 WRITE_ONCE(rdp_leader->nocb_leader_sleep, false);
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001822 del_timer(&rdp->nocb_timer);
1823 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
Paul E. McKenney6b5fc3a2017-04-28 20:11:09 -07001824 smp_mb(); /* ->nocb_leader_sleep before swake_up(). */
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01001825 swake_up(&rdp_leader->nocb_wq);
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001826 } else {
1827 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07001828 }
1829}
1830
1831/*
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001832 * Kick the leader kthread for this NOCB group, but caller has not
1833 * acquired locks.
1834 */
1835static void wake_nocb_leader(struct rcu_data *rdp, bool force)
1836{
1837 unsigned long flags;
1838
1839 raw_spin_lock_irqsave(&rdp->nocb_lock, flags);
1840 __wake_nocb_leader(rdp, force, flags);
1841}
1842
1843/*
1844 * Arrange to wake the leader kthread for this NOCB group at some
1845 * future time when it is safe to do so.
1846 */
1847static void wake_nocb_leader_defer(struct rcu_data *rdp, int waketype,
1848 const char *reason)
1849{
1850 unsigned long flags;
1851
1852 raw_spin_lock_irqsave(&rdp->nocb_lock, flags);
1853 if (rdp->nocb_defer_wakeup == RCU_NOCB_WAKE_NOT)
1854 mod_timer(&rdp->nocb_timer, jiffies + 1);
1855 WRITE_ONCE(rdp->nocb_defer_wakeup, waketype);
1856 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, reason);
1857 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
1858}
1859
1860/*
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001861 * Does the specified CPU need an RCU callback for the specified flavor
1862 * of rcu_barrier()?
1863 */
1864static bool rcu_nocb_cpu_needs_barrier(struct rcu_state *rsp, int cpu)
1865{
1866 struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
Paul E. McKenney41050a02014-12-18 12:31:27 -08001867 unsigned long ret;
1868#ifdef CONFIG_PROVE_RCU
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001869 struct rcu_head *rhp;
Paul E. McKenney41050a02014-12-18 12:31:27 -08001870#endif /* #ifdef CONFIG_PROVE_RCU */
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001871
Paul E. McKenney41050a02014-12-18 12:31:27 -08001872 /*
1873 * Check count of all no-CBs callbacks awaiting invocation.
1874 * There needs to be a barrier before this function is called,
1875 * but associated with a prior determination that no more
1876 * callbacks would be posted. In the worst case, the first
1877 * barrier in _rcu_barrier() suffices (but the caller cannot
1878 * necessarily rely on this, not a substitute for the caller
1879 * getting the concurrency design right!). There must also be
1880 * a barrier between the following load an posting of a callback
1881 * (if a callback is in fact needed). This is associated with an
1882 * atomic_inc() in the caller.
1883 */
1884 ret = atomic_long_read(&rdp->nocb_q_count);
1885
1886#ifdef CONFIG_PROVE_RCU
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001887 rhp = READ_ONCE(rdp->nocb_head);
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001888 if (!rhp)
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001889 rhp = READ_ONCE(rdp->nocb_gp_head);
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001890 if (!rhp)
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001891 rhp = READ_ONCE(rdp->nocb_follower_head);
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001892
1893 /* Having no rcuo kthread but CBs after scheduler starts is bad! */
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001894 if (!READ_ONCE(rdp->nocb_kthread) && rhp &&
Paul E. McKenney59f792d2015-01-19 21:43:40 -08001895 rcu_scheduler_fully_active) {
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001896 /* RCU callback enqueued before CPU first came online??? */
1897 pr_err("RCU: Never-onlined no-CBs CPU %d has CB %p\n",
1898 cpu, rhp->func);
1899 WARN_ON_ONCE(1);
1900 }
Paul E. McKenney41050a02014-12-18 12:31:27 -08001901#endif /* #ifdef CONFIG_PROVE_RCU */
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001902
Paul E. McKenney41050a02014-12-18 12:31:27 -08001903 return !!ret;
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07001904}
1905
1906/*
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001907 * Enqueue the specified string of rcu_head structures onto the specified
1908 * CPU's no-CBs lists. The CPU is specified by rdp, the head of the
1909 * string by rhp, and the tail of the string by rhtp. The non-lazy/lazy
1910 * counts are supplied by rhcount and rhcount_lazy.
1911 *
1912 * If warranted, also wake up the kthread servicing this CPUs queues.
1913 */
1914static void __call_rcu_nocb_enqueue(struct rcu_data *rdp,
1915 struct rcu_head *rhp,
1916 struct rcu_head **rhtp,
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07001917 int rhcount, int rhcount_lazy,
1918 unsigned long flags)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001919{
1920 int len;
1921 struct rcu_head **old_rhpp;
1922 struct task_struct *t;
1923
1924 /* Enqueue the callback on the nocb list and update counts. */
Paul E. McKenney41050a02014-12-18 12:31:27 -08001925 atomic_long_add(rhcount, &rdp->nocb_q_count);
1926 /* rcu_barrier() relies on ->nocb_q_count add before xchg. */
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001927 old_rhpp = xchg(&rdp->nocb_tail, rhtp);
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001928 WRITE_ONCE(*old_rhpp, rhp);
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001929 atomic_long_add(rhcount_lazy, &rdp->nocb_q_count_lazy);
Paul E. McKenney39953df2014-08-12 10:47:48 -07001930 smp_mb__after_atomic(); /* Store *old_rhpp before _wake test. */
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001931
1932 /* If we are not being polled and there is a kthread, awaken it ... */
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08001933 t = READ_ONCE(rdp->nocb_kthread);
Paul E. McKenney25e03a72013-10-15 12:47:04 -07001934 if (rcu_nocb_poll || !t) {
Paul E. McKenney9261dd02013-08-14 16:24:26 -07001935 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
1936 TPS("WakeNotPoll"));
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001937 return;
Paul E. McKenney9261dd02013-08-14 16:24:26 -07001938 }
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001939 len = atomic_long_read(&rdp->nocb_q_count);
1940 if (old_rhpp == &rdp->nocb_head) {
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07001941 if (!irqs_disabled_flags(flags)) {
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07001942 /* ... if queue was empty ... */
1943 wake_nocb_leader(rdp, false);
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07001944 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
1945 TPS("WakeEmpty"));
1946 } else {
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001947 wake_nocb_leader_defer(rdp, RCU_NOCB_WAKE,
1948 TPS("WakeEmptyIsDeferred"));
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07001949 }
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001950 rdp->qlen_last_fqs_check = 0;
1951 } else if (len > rdp->qlen_last_fqs_check + qhimark) {
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07001952 /* ... or if many callbacks queued. */
Paul E. McKenney9fdd3bc2014-07-29 14:50:47 -07001953 if (!irqs_disabled_flags(flags)) {
1954 wake_nocb_leader(rdp, true);
1955 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
1956 TPS("WakeOvf"));
1957 } else {
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07001958 wake_nocb_leader_defer(rdp, RCU_NOCB_WAKE,
1959 TPS("WakeOvfIsDeferred"));
Paul E. McKenney9fdd3bc2014-07-29 14:50:47 -07001960 }
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001961 rdp->qlen_last_fqs_check = LONG_MAX / 2;
Paul E. McKenney9261dd02013-08-14 16:24:26 -07001962 } else {
1963 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("WakeNot"));
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001964 }
1965 return;
1966}
1967
1968/*
1969 * This is a helper for __call_rcu(), which invokes this when the normal
1970 * callback queue is inoperable. If this is not a no-CBs CPU, this
1971 * function returns failure back to __call_rcu(), which can complain
1972 * appropriately.
1973 *
1974 * Otherwise, this function queues the callback where the corresponding
1975 * "rcuo" kthread can find it.
1976 */
1977static bool __call_rcu_nocb(struct rcu_data *rdp, struct rcu_head *rhp,
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07001978 bool lazy, unsigned long flags)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07001979{
1980
Frederic Weisbeckerd1e43fa2013-03-26 23:47:24 +01001981 if (!rcu_is_nocb_cpu(rdp->cpu))
Pranith Kumarc271d3a2014-07-08 18:26:14 -04001982 return false;
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07001983 __call_rcu_nocb_enqueue(rdp, rhp, &rhp->next, 1, lazy, flags);
Paul E. McKenney21e7a602013-02-09 17:42:16 -08001984 if (__is_kfree_rcu_offset((unsigned long)rhp->func))
1985 trace_rcu_kfree_callback(rdp->rsp->name, rhp,
1986 (unsigned long)rhp->func,
Paul E. McKenney756cbf62013-08-15 10:12:12 -07001987 -atomic_long_read(&rdp->nocb_q_count_lazy),
1988 -atomic_long_read(&rdp->nocb_q_count));
Paul E. McKenney21e7a602013-02-09 17:42:16 -08001989 else
1990 trace_rcu_callback(rdp->rsp->name, rhp,
Paul E. McKenney756cbf62013-08-15 10:12:12 -07001991 -atomic_long_read(&rdp->nocb_q_count_lazy),
1992 -atomic_long_read(&rdp->nocb_q_count));
Paul E. McKenney1772947bd2014-08-12 11:27:31 -07001993
1994 /*
1995 * If called from an extended quiescent state with interrupts
1996 * disabled, invoke the RCU core in order to allow the idle-entry
1997 * deferred-wakeup check to function.
1998 */
1999 if (irqs_disabled_flags(flags) &&
2000 !rcu_is_watching() &&
2001 cpu_online(smp_processor_id()))
2002 invoke_rcu_core();
2003
Pranith Kumarc271d3a2014-07-08 18:26:14 -04002004 return true;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002005}
2006
2007/*
2008 * Adopt orphaned callbacks on a no-CBs CPU, or return 0 if this is
2009 * not a no-CBs CPU.
2010 */
Paul E. McKenneyb1a2d792017-06-26 12:23:46 -07002011static bool __maybe_unused rcu_nocb_adopt_orphan_cbs(struct rcu_data *my_rdp,
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002012 struct rcu_data *rdp,
2013 unsigned long flags)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002014{
Paul E. McKenneyb1a2d792017-06-26 12:23:46 -07002015 RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_nocb_adopt_orphan_cbs() invoked with irqs enabled!!!");
Frederic Weisbeckerd1e43fa2013-03-26 23:47:24 +01002016 if (!rcu_is_nocb_cpu(smp_processor_id()))
Paul E. McKenneyb1a2d792017-06-26 12:23:46 -07002017 return false; /* Not NOCBs CPU, caller must migrate CBs. */
2018 __call_rcu_nocb_enqueue(my_rdp, rcu_segcblist_head(&rdp->cblist),
2019 rcu_segcblist_tail(&rdp->cblist),
2020 rcu_segcblist_n_cbs(&rdp->cblist),
2021 rcu_segcblist_n_lazy_cbs(&rdp->cblist), flags);
2022 rcu_segcblist_init(&rdp->cblist);
2023 rcu_segcblist_disable(&rdp->cblist);
Pranith Kumar0a9e1e12014-07-08 18:26:15 -04002024 return true;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002025}
2026
2027/*
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002028 * If necessary, kick off a new grace period, and either way wait
2029 * for a subsequent grace period to complete.
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002030 */
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002031static void rcu_nocb_wait_gp(struct rcu_data *rdp)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002032{
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002033 unsigned long c;
Paul E. McKenneydae6e642013-02-10 20:48:58 -08002034 bool d;
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002035 unsigned long flags;
Paul E. McKenney48a76392014-03-11 13:02:16 -07002036 bool needwake;
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002037 struct rcu_node *rnp = rdp->mynode;
2038
Peter Zijlstra2a67e742015-10-08 12:24:23 +02002039 raw_spin_lock_irqsave_rcu_node(rnp, flags);
Paul E. McKenney48a76392014-03-11 13:02:16 -07002040 needwake = rcu_start_future_gp(rnp, rdp, &c);
Boqun Feng67c583a72015-12-29 12:18:47 +08002041 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
Paul E. McKenney48a76392014-03-11 13:02:16 -07002042 if (needwake)
2043 rcu_gp_kthread_wake(rdp->rsp);
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002044
2045 /*
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002046 * Wait for the grace period. Do so interruptibly to avoid messing
2047 * up the load average.
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002048 */
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04002049 trace_rcu_future_gp(rnp, rdp, c, TPS("StartWait"));
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002050 for (;;) {
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01002051 swait_event_interruptible(
Paul E. McKenneydae6e642013-02-10 20:48:58 -08002052 rnp->nocb_gp_wq[c & 0x1],
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002053 (d = ULONG_CMP_GE(READ_ONCE(rnp->completed), c)));
Paul E. McKenneydae6e642013-02-10 20:48:58 -08002054 if (likely(d))
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002055 break;
Paul E. McKenney73a860c2014-08-14 10:28:23 -07002056 WARN_ON(signal_pending(current));
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04002057 trace_rcu_future_gp(rnp, rdp, c, TPS("ResumeWait"));
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002058 }
Steven Rostedt (Red Hat)f7f7bac2013-07-12 17:18:47 -04002059 trace_rcu_future_gp(rnp, rdp, c, TPS("EndWait"));
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002060 smp_mb(); /* Ensure that CB invocation happens after GP end. */
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002061}
2062
2063/*
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002064 * Leaders come here to wait for additional callbacks to show up.
2065 * This function does not return until callbacks appear.
2066 */
2067static void nocb_leader_wait(struct rcu_data *my_rdp)
2068{
2069 bool firsttime = true;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002070 unsigned long flags;
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002071 bool gotcbs;
2072 struct rcu_data *rdp;
2073 struct rcu_head **tail;
2074
2075wait_again:
2076
2077 /* Wait for callbacks to appear. */
2078 if (!rcu_nocb_poll) {
Paul E. McKenneybedbb642017-06-06 15:49:39 -07002079 trace_rcu_nocb_wake(my_rdp->rsp->name, my_rdp->cpu, TPS("Sleep"));
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01002080 swait_event_interruptible(my_rdp->nocb_wq,
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002081 !READ_ONCE(my_rdp->nocb_leader_sleep));
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002082 raw_spin_lock_irqsave(&my_rdp->nocb_lock, flags);
2083 my_rdp->nocb_leader_sleep = true;
2084 WRITE_ONCE(my_rdp->nocb_defer_wakeup, RCU_NOCB_WAKE_NOT);
2085 del_timer(&my_rdp->nocb_timer);
2086 raw_spin_unlock_irqrestore(&my_rdp->nocb_lock, flags);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002087 } else if (firsttime) {
2088 firsttime = false; /* Don't drown trace log with "Poll"! */
Paul E. McKenneybedbb642017-06-06 15:49:39 -07002089 trace_rcu_nocb_wake(my_rdp->rsp->name, my_rdp->cpu, TPS("Poll"));
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002090 }
2091
2092 /*
2093 * Each pass through the following loop checks a follower for CBs.
2094 * We are our own first follower. Any CBs found are moved to
2095 * nocb_gp_head, where they await a grace period.
2096 */
2097 gotcbs = false;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002098 smp_mb(); /* wakeup and _sleep before ->nocb_head reads. */
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002099 for (rdp = my_rdp; rdp; rdp = rdp->nocb_next_follower) {
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002100 rdp->nocb_gp_head = READ_ONCE(rdp->nocb_head);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002101 if (!rdp->nocb_gp_head)
2102 continue; /* No CBs here, try next follower. */
2103
2104 /* Move callbacks to wait-for-GP list, which is empty. */
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002105 WRITE_ONCE(rdp->nocb_head, NULL);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002106 rdp->nocb_gp_tail = xchg(&rdp->nocb_tail, &rdp->nocb_head);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002107 gotcbs = true;
2108 }
2109
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002110 /* No callbacks? Sleep a bit if polling, and go retry. */
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002111 if (unlikely(!gotcbs)) {
Paul E. McKenney73a860c2014-08-14 10:28:23 -07002112 WARN_ON(signal_pending(current));
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002113 if (rcu_nocb_poll) {
2114 schedule_timeout_interruptible(1);
2115 } else {
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002116 trace_rcu_nocb_wake(my_rdp->rsp->name, my_rdp->cpu,
Paul E. McKenneybedbb642017-06-06 15:49:39 -07002117 TPS("WokeEmpty"));
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002118 }
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002119 goto wait_again;
2120 }
2121
2122 /* Wait for one grace period. */
2123 rcu_nocb_wait_gp(my_rdp);
2124
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002125 /* Each pass through the following loop wakes a follower, if needed. */
2126 for (rdp = my_rdp; rdp; rdp = rdp->nocb_next_follower) {
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002127 if (!rcu_nocb_poll &&
2128 READ_ONCE(rdp->nocb_head) &&
2129 READ_ONCE(my_rdp->nocb_leader_sleep)) {
2130 raw_spin_lock_irqsave(&my_rdp->nocb_lock, flags);
Pranith Kumar11ed7f92014-08-27 16:43:40 -04002131 my_rdp->nocb_leader_sleep = false;/* No need to sleep.*/
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002132 raw_spin_unlock_irqrestore(&my_rdp->nocb_lock, flags);
2133 }
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002134 if (!rdp->nocb_gp_head)
2135 continue; /* No CBs, so no need to wake follower. */
2136
2137 /* Append callbacks to follower's "done" list. */
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002138 raw_spin_lock_irqsave(&rdp->nocb_lock, flags);
2139 tail = rdp->nocb_follower_tail;
2140 rdp->nocb_follower_tail = rdp->nocb_gp_tail;
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002141 *tail = rdp->nocb_gp_head;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002142 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002143 if (rdp != my_rdp && tail == &rdp->nocb_follower_head) {
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002144 /* List was empty, so wake up the follower. */
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01002145 swake_up(&rdp->nocb_wq);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002146 }
2147 }
2148
2149 /* If we (the leader) don't have CBs, go wait some more. */
2150 if (!my_rdp->nocb_follower_head)
2151 goto wait_again;
2152}
2153
2154/*
2155 * Followers come here to wait for additional callbacks to show up.
2156 * This function does not return until callbacks appear.
2157 */
2158static void nocb_follower_wait(struct rcu_data *rdp)
2159{
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002160 for (;;) {
Paul E. McKenneybedbb642017-06-06 15:49:39 -07002161 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("FollowerSleep"));
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002162 swait_event_interruptible(rdp->nocb_wq,
2163 READ_ONCE(rdp->nocb_follower_head));
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002164 if (smp_load_acquire(&rdp->nocb_follower_head)) {
2165 /* ^^^ Ensure CB invocation follows _head test. */
2166 return;
2167 }
Paul E. McKenney73a860c2014-08-14 10:28:23 -07002168 WARN_ON(signal_pending(current));
Paul E. McKenneybedbb642017-06-06 15:49:39 -07002169 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("WokeEmpty"));
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002170 }
2171}
2172
2173/*
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002174 * Per-rcu_data kthread, but only for no-CBs CPUs. Each kthread invokes
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002175 * callbacks queued by the corresponding no-CBs CPU, however, there is
2176 * an optional leader-follower relationship so that the grace-period
2177 * kthreads don't have to do quite so many wakeups.
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002178 */
2179static int rcu_nocb_kthread(void *arg)
2180{
2181 int c, cl;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002182 unsigned long flags;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002183 struct rcu_head *list;
2184 struct rcu_head *next;
2185 struct rcu_head **tail;
2186 struct rcu_data *rdp = arg;
2187
2188 /* Each pass through this loop invokes one batch of callbacks */
2189 for (;;) {
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002190 /* Wait for callbacks. */
2191 if (rdp->nocb_leader == rdp)
2192 nocb_leader_wait(rdp);
2193 else
2194 nocb_follower_wait(rdp);
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002195
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002196 /* Pull the ready-to-invoke callbacks onto local list. */
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002197 raw_spin_lock_irqsave(&rdp->nocb_lock, flags);
2198 list = rdp->nocb_follower_head;
2199 rdp->nocb_follower_head = NULL;
2200 tail = rdp->nocb_follower_tail;
2201 rdp->nocb_follower_tail = &rdp->nocb_follower_head;
2202 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002203 BUG_ON(!list);
Paul E. McKenneybedbb642017-06-06 15:49:39 -07002204 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("WokeNonEmpty"));
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002205
2206 /* Each pass through the following loop invokes a callback. */
Paul E. McKenney41050a02014-12-18 12:31:27 -08002207 trace_rcu_batch_start(rdp->rsp->name,
2208 atomic_long_read(&rdp->nocb_q_count_lazy),
2209 atomic_long_read(&rdp->nocb_q_count), -1);
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002210 c = cl = 0;
2211 while (list) {
2212 next = list->next;
2213 /* Wait for enqueuing to complete, if needed. */
2214 while (next == NULL && &list->next != tail) {
Paul E. McKenney69a79bb2013-08-15 13:23:23 -07002215 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
2216 TPS("WaitQueue"));
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002217 schedule_timeout_interruptible(1);
Paul E. McKenney69a79bb2013-08-15 13:23:23 -07002218 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
2219 TPS("WokeQueue"));
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002220 next = list->next;
2221 }
2222 debug_rcu_head_unqueue(list);
2223 local_bh_disable();
2224 if (__rcu_reclaim(rdp->rsp->name, list))
2225 cl++;
2226 c++;
2227 local_bh_enable();
Ding Tianhongbedc1962016-06-15 15:27:36 +08002228 cond_resched_rcu_qs();
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002229 list = next;
2230 }
2231 trace_rcu_batch_end(rdp->rsp->name, c, !!list, 0, 0, 1);
Paul E. McKenney41050a02014-12-18 12:31:27 -08002232 smp_mb__before_atomic(); /* _add after CB invocation. */
2233 atomic_long_add(-c, &rdp->nocb_q_count);
2234 atomic_long_add(-cl, &rdp->nocb_q_count_lazy);
Paul E. McKenneyc635a4e12012-10-29 07:29:20 -07002235 rdp->n_nocbs_invoked += c;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002236 }
2237 return 0;
2238}
2239
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002240/* Is a deferred wakeup of rcu_nocb_kthread() required? */
Paul E. McKenney9fdd3bc2014-07-29 14:50:47 -07002241static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp)
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002242{
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002243 return READ_ONCE(rdp->nocb_defer_wakeup);
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002244}
2245
2246/* Do a deferred wakeup of rcu_nocb_kthread(). */
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002247static void do_nocb_deferred_wakeup_common(struct rcu_data *rdp)
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002248{
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002249 unsigned long flags;
Paul E. McKenney9fdd3bc2014-07-29 14:50:47 -07002250 int ndw;
2251
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002252 raw_spin_lock_irqsave(&rdp->nocb_lock, flags);
2253 if (!rcu_nocb_need_deferred_wakeup(rdp)) {
2254 raw_spin_unlock_irqrestore(&rdp->nocb_lock, flags);
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002255 return;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002256 }
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002257 ndw = READ_ONCE(rdp->nocb_defer_wakeup);
Paul E. McKenney511324e2017-04-28 17:04:09 -07002258 WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOCB_WAKE_NOT);
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002259 __wake_nocb_leader(rdp, ndw == RCU_NOCB_WAKE_FORCE, flags);
Paul E. McKenney9fdd3bc2014-07-29 14:50:47 -07002260 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("DeferredWake"));
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002261}
2262
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002263/* Do a deferred wakeup of rcu_nocb_kthread() from a timer handler. */
2264static void do_nocb_deferred_wakeup_timer(unsigned long x)
2265{
2266 do_nocb_deferred_wakeup_common((struct rcu_data *)x);
2267}
2268
2269/*
2270 * Do a deferred wakeup of rcu_nocb_kthread() from fastpath.
2271 * This means we do an inexact common-case check. Note that if
2272 * we miss, ->nocb_timer will eventually clean things up.
2273 */
2274static void do_nocb_deferred_wakeup(struct rcu_data *rdp)
2275{
2276 if (rcu_nocb_need_deferred_wakeup(rdp))
2277 do_nocb_deferred_wakeup_common(rdp);
2278}
2279
Paul E. McKenneyf4579fc2014-07-25 11:21:47 -07002280void __init rcu_init_nohz(void)
2281{
2282 int cpu;
2283 bool need_rcu_nocb_mask = true;
2284 struct rcu_state *rsp;
2285
Paul E. McKenneyf4579fc2014-07-25 11:21:47 -07002286#if defined(CONFIG_NO_HZ_FULL)
2287 if (tick_nohz_full_running && cpumask_weight(tick_nohz_full_mask))
2288 need_rcu_nocb_mask = true;
2289#endif /* #if defined(CONFIG_NO_HZ_FULL) */
2290
2291 if (!have_rcu_nocb_mask && need_rcu_nocb_mask) {
Pranith Kumar949cccd2014-07-25 16:02:07 -07002292 if (!zalloc_cpumask_var(&rcu_nocb_mask, GFP_KERNEL)) {
2293 pr_info("rcu_nocb_mask allocation failed, callback offloading disabled.\n");
2294 return;
2295 }
Paul E. McKenneyf4579fc2014-07-25 11:21:47 -07002296 have_rcu_nocb_mask = true;
2297 }
2298 if (!have_rcu_nocb_mask)
2299 return;
2300
Paul E. McKenneyf4579fc2014-07-25 11:21:47 -07002301#if defined(CONFIG_NO_HZ_FULL)
2302 if (tick_nohz_full_running)
2303 cpumask_or(rcu_nocb_mask, rcu_nocb_mask, tick_nohz_full_mask);
2304#endif /* #if defined(CONFIG_NO_HZ_FULL) */
2305
2306 if (!cpumask_subset(rcu_nocb_mask, cpu_possible_mask)) {
2307 pr_info("\tNote: kernel parameter 'rcu_nocbs=' contains nonexistent CPUs.\n");
2308 cpumask_and(rcu_nocb_mask, cpu_possible_mask,
2309 rcu_nocb_mask);
2310 }
Tejun Heoad853b42015-02-13 14:37:25 -08002311 pr_info("\tOffload RCU callbacks from CPUs: %*pbl.\n",
2312 cpumask_pr_args(rcu_nocb_mask));
Paul E. McKenneyf4579fc2014-07-25 11:21:47 -07002313 if (rcu_nocb_poll)
2314 pr_info("\tPoll for callbacks from no-CBs CPUs.\n");
2315
2316 for_each_rcu_flavor(rsp) {
Paul E. McKenney34404ca2015-01-19 20:39:20 -08002317 for_each_cpu(cpu, rcu_nocb_mask)
2318 init_nocb_callback_list(per_cpu_ptr(rsp->rda, cpu));
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002319 rcu_organize_nocb_kthreads(rsp);
Paul E. McKenneyf4579fc2014-07-25 11:21:47 -07002320 }
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002321}
2322
2323/* Initialize per-rcu_data variables for no-CBs CPUs. */
2324static void __init rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp)
2325{
2326 rdp->nocb_tail = &rdp->nocb_head;
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01002327 init_swait_queue_head(&rdp->nocb_wq);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002328 rdp->nocb_follower_tail = &rdp->nocb_follower_head;
Paul E. McKenney8be6e1b2017-04-29 20:03:20 -07002329 raw_spin_lock_init(&rdp->nocb_lock);
2330 setup_timer(&rdp->nocb_timer, do_nocb_deferred_wakeup_timer,
2331 (unsigned long)rdp);
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002332}
2333
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002334/*
2335 * If the specified CPU is a no-CBs CPU that does not already have its
2336 * rcuo kthread for the specified RCU flavor, spawn it. If the CPUs are
2337 * brought online out of order, this can require re-organizing the
2338 * leader-follower relationships.
2339 */
2340static void rcu_spawn_one_nocb_kthread(struct rcu_state *rsp, int cpu)
2341{
2342 struct rcu_data *rdp;
2343 struct rcu_data *rdp_last;
2344 struct rcu_data *rdp_old_leader;
2345 struct rcu_data *rdp_spawn = per_cpu_ptr(rsp->rda, cpu);
2346 struct task_struct *t;
2347
2348 /*
2349 * If this isn't a no-CBs CPU or if it already has an rcuo kthread,
2350 * then nothing to do.
2351 */
2352 if (!rcu_is_nocb_cpu(cpu) || rdp_spawn->nocb_kthread)
2353 return;
2354
2355 /* If we didn't spawn the leader first, reorganize! */
2356 rdp_old_leader = rdp_spawn->nocb_leader;
2357 if (rdp_old_leader != rdp_spawn && !rdp_old_leader->nocb_kthread) {
2358 rdp_last = NULL;
2359 rdp = rdp_old_leader;
2360 do {
2361 rdp->nocb_leader = rdp_spawn;
2362 if (rdp_last && rdp != rdp_spawn)
2363 rdp_last->nocb_next_follower = rdp;
Paul E. McKenneybbe5d7a2014-10-24 11:11:08 -07002364 if (rdp == rdp_spawn) {
2365 rdp = rdp->nocb_next_follower;
2366 } else {
2367 rdp_last = rdp;
2368 rdp = rdp->nocb_next_follower;
2369 rdp_last->nocb_next_follower = NULL;
2370 }
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002371 } while (rdp);
2372 rdp_spawn->nocb_next_follower = rdp_old_leader;
2373 }
2374
2375 /* Spawn the kthread for this CPU and RCU flavor. */
2376 t = kthread_run(rcu_nocb_kthread, rdp_spawn,
2377 "rcuo%c/%d", rsp->abbr, cpu);
2378 BUG_ON(IS_ERR(t));
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002379 WRITE_ONCE(rdp_spawn->nocb_kthread, t);
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002380}
2381
2382/*
2383 * If the specified CPU is a no-CBs CPU that does not already have its
2384 * rcuo kthreads, spawn them.
2385 */
2386static void rcu_spawn_all_nocb_kthreads(int cpu)
2387{
2388 struct rcu_state *rsp;
2389
2390 if (rcu_scheduler_fully_active)
2391 for_each_rcu_flavor(rsp)
2392 rcu_spawn_one_nocb_kthread(rsp, cpu);
2393}
2394
2395/*
2396 * Once the scheduler is running, spawn rcuo kthreads for all online
2397 * no-CBs CPUs. This assumes that the early_initcall()s happen before
2398 * non-boot CPUs come online -- if this changes, we will need to add
2399 * some mutual exclusion.
2400 */
2401static void __init rcu_spawn_nocb_kthreads(void)
2402{
2403 int cpu;
2404
2405 for_each_online_cpu(cpu)
2406 rcu_spawn_all_nocb_kthreads(cpu);
2407}
2408
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002409/* How many follower CPU IDs per leader? Default of -1 for sqrt(nr_cpu_ids). */
2410static int rcu_nocb_leader_stride = -1;
2411module_param(rcu_nocb_leader_stride, int, 0444);
2412
2413/*
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002414 * Initialize leader-follower relationships for all no-CBs CPU.
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002415 */
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002416static void __init rcu_organize_nocb_kthreads(struct rcu_state *rsp)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002417{
2418 int cpu;
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002419 int ls = rcu_nocb_leader_stride;
2420 int nl = 0; /* Next leader. */
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002421 struct rcu_data *rdp;
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002422 struct rcu_data *rdp_leader = NULL; /* Suppress misguided gcc warn. */
2423 struct rcu_data *rdp_prev = NULL;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002424
Pranith Kumar22c2f662014-07-17 20:11:01 -04002425 if (!have_rcu_nocb_mask)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002426 return;
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002427 if (ls == -1) {
2428 ls = int_sqrt(nr_cpu_ids);
2429 rcu_nocb_leader_stride = ls;
2430 }
2431
2432 /*
Paul E. McKenney9831ce32017-01-02 14:24:24 -08002433 * Each pass through this loop sets up one rcu_data structure.
2434 * Should the corresponding CPU come online in the future, then
2435 * we will spawn the needed set of rcu_nocb_kthread() kthreads.
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002436 */
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002437 for_each_cpu(cpu, rcu_nocb_mask) {
2438 rdp = per_cpu_ptr(rsp->rda, cpu);
Paul E. McKenneyfbce7492014-06-24 09:26:11 -07002439 if (rdp->cpu >= nl) {
2440 /* New leader, set up for followers & next leader. */
2441 nl = DIV_ROUND_UP(rdp->cpu + 1, ls) * ls;
2442 rdp->nocb_leader = rdp;
2443 rdp_leader = rdp;
2444 } else {
2445 /* Another follower, link to previous leader. */
2446 rdp->nocb_leader = rdp_leader;
2447 rdp_prev->nocb_next_follower = rdp;
2448 }
2449 rdp_prev = rdp;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002450 }
2451}
2452
2453/* Prevent __call_rcu() from enqueuing callbacks on no-CBs CPUs */
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002454static bool init_nocb_callback_list(struct rcu_data *rdp)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002455{
Pranith Kumar22c2f662014-07-17 20:11:01 -04002456 if (!rcu_is_nocb_cpu(rdp->cpu))
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002457 return false;
Pranith Kumar22c2f662014-07-17 20:11:01 -04002458
Paul E. McKenney34404ca2015-01-19 20:39:20 -08002459 /* If there are early-boot callbacks, move them to nocb lists. */
Paul E. McKenney15fecf82017-02-08 12:36:42 -08002460 if (!rcu_segcblist_empty(&rdp->cblist)) {
2461 rdp->nocb_head = rcu_segcblist_head(&rdp->cblist);
2462 rdp->nocb_tail = rcu_segcblist_tail(&rdp->cblist);
2463 atomic_long_set(&rdp->nocb_q_count,
2464 rcu_segcblist_n_cbs(&rdp->cblist));
2465 atomic_long_set(&rdp->nocb_q_count_lazy,
2466 rcu_segcblist_n_lazy_cbs(&rdp->cblist));
2467 rcu_segcblist_init(&rdp->cblist);
Paul E. McKenney34404ca2015-01-19 20:39:20 -08002468 }
Paul E. McKenney15fecf82017-02-08 12:36:42 -08002469 rcu_segcblist_disable(&rdp->cblist);
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002470 return true;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002471}
2472
2473#else /* #ifdef CONFIG_RCU_NOCB_CPU */
2474
Paul E. McKenneyd7e29932014-10-27 09:15:54 -07002475static bool rcu_nocb_cpu_needs_barrier(struct rcu_state *rsp, int cpu)
2476{
2477 WARN_ON_ONCE(1); /* Should be dead code. */
2478 return false;
2479}
2480
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01002481static void rcu_nocb_gp_cleanup(struct swait_queue_head *sq)
Paul E. McKenneydae6e642013-02-10 20:48:58 -08002482{
Paul E. McKenneydae6e642013-02-10 20:48:58 -08002483}
2484
2485static void rcu_nocb_gp_set(struct rcu_node *rnp, int nrq)
2486{
2487}
2488
Paul Gortmakerabedf8e2016-02-19 09:46:41 +01002489static struct swait_queue_head *rcu_nocb_gp_get(struct rcu_node *rnp)
Daniel Wagner065bb782016-02-19 09:46:40 +01002490{
2491 return NULL;
2492}
2493
Paul E. McKenneydae6e642013-02-10 20:48:58 -08002494static void rcu_init_one_nocb(struct rcu_node *rnp)
2495{
2496}
2497
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002498static bool __call_rcu_nocb(struct rcu_data *rdp, struct rcu_head *rhp,
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002499 bool lazy, unsigned long flags)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002500{
Pranith Kumar4afc7e22014-07-08 18:26:16 -04002501 return false;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002502}
2503
Paul E. McKenneyb1a2d792017-06-26 12:23:46 -07002504static bool __maybe_unused rcu_nocb_adopt_orphan_cbs(struct rcu_data *my_rdp,
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002505 struct rcu_data *rdp,
2506 unsigned long flags)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002507{
Pranith Kumarf4aa84b2014-07-08 18:26:17 -04002508 return false;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002509}
2510
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002511static void __init rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp)
2512{
2513}
2514
Paul E. McKenney9fdd3bc2014-07-29 14:50:47 -07002515static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp)
Paul E. McKenney96d3fd02013-10-04 14:33:34 -07002516{
2517 return false;
2518}
2519
2520static void do_nocb_deferred_wakeup(struct rcu_data *rdp)
2521{
2522}
2523
Paul E. McKenney35ce7f22014-07-11 11:30:24 -07002524static void rcu_spawn_all_nocb_kthreads(int cpu)
2525{
2526}
2527
2528static void __init rcu_spawn_nocb_kthreads(void)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002529{
2530}
2531
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002532static bool init_nocb_callback_list(struct rcu_data *rdp)
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002533{
Paul E. McKenney34ed62462013-01-07 13:37:42 -08002534 return false;
Paul E. McKenney3fbfbf72012-08-19 21:35:53 -07002535}
2536
2537#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
Paul E. McKenney65d798f2013-04-12 16:19:10 -07002538
2539/*
2540 * An adaptive-ticks CPU can potentially execute in kernel mode for an
2541 * arbitrarily long period of time with the scheduling-clock tick turned
2542 * off. RCU will be paying attention to this CPU because it is in the
2543 * kernel, but the CPU cannot be guaranteed to be executing the RCU state
2544 * machine because the scheduling-clock tick has been disabled. Therefore,
2545 * if an adaptive-ticks CPU is failing to respond to the current grace
2546 * period and has not be idle from an RCU perspective, kick it.
2547 */
Paul E. McKenney4a81e832014-06-20 16:49:01 -07002548static void __maybe_unused rcu_kick_nohz_cpu(int cpu)
Paul E. McKenney65d798f2013-04-12 16:19:10 -07002549{
2550#ifdef CONFIG_NO_HZ_FULL
2551 if (tick_nohz_full_cpu(cpu))
2552 smp_send_reschedule(cpu);
2553#endif /* #ifdef CONFIG_NO_HZ_FULL */
2554}
Paul E. McKenney23332102013-06-21 12:34:33 -07002555
Paul E. McKenneya0969322013-11-08 09:03:10 -08002556/*
2557 * Is this CPU a NO_HZ_FULL CPU that should ignore RCU so that the
2558 * grace-period kthread will do force_quiescent_state() processing?
2559 * The idea is to avoid waking up RCU core processing on such a
2560 * CPU unless the grace period has extended for too long.
2561 *
2562 * This code relies on the fact that all NO_HZ_FULL CPUs are also
Paul Bolle52e2bb92014-02-09 14:35:11 +01002563 * CONFIG_RCU_NOCB_CPU CPUs.
Paul E. McKenneya0969322013-11-08 09:03:10 -08002564 */
2565static bool rcu_nohz_full_cpu(struct rcu_state *rsp)
2566{
2567#ifdef CONFIG_NO_HZ_FULL
2568 if (tick_nohz_full_cpu(smp_processor_id()) &&
2569 (!rcu_gp_in_progress(rsp) ||
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002570 ULONG_CMP_LT(jiffies, READ_ONCE(rsp->gp_start) + HZ)))
Joe Perches5ce035f2015-03-30 16:46:16 -07002571 return true;
Paul E. McKenneya0969322013-11-08 09:03:10 -08002572#endif /* #ifdef CONFIG_NO_HZ_FULL */
Joe Perches5ce035f2015-03-30 16:46:16 -07002573 return false;
Paul E. McKenneya0969322013-11-08 09:03:10 -08002574}
Paul E. McKenney5057f55e52014-04-01 11:20:36 -07002575
2576/*
2577 * Bind the grace-period kthread for the sysidle flavor of RCU to the
2578 * timekeeping CPU.
2579 */
2580static void rcu_bind_gp_kthread(void)
2581{
Paul E. McKenneyc0f489d2014-06-04 13:46:03 -07002582 int __maybe_unused cpu;
Paul E. McKenney5057f55e52014-04-01 11:20:36 -07002583
Paul E. McKenneyc0f489d2014-06-04 13:46:03 -07002584 if (!tick_nohz_full_enabled())
Paul E. McKenney5057f55e52014-04-01 11:20:36 -07002585 return;
Paul E. McKenney58719682015-02-24 11:05:36 -08002586 housekeeping_affine(current);
Paul E. McKenney5057f55e52014-04-01 11:20:36 -07002587}
Paul E. McKenney176f8f72014-08-04 17:43:50 -07002588
2589/* Record the current task on dyntick-idle entry. */
2590static void rcu_dynticks_task_enter(void)
2591{
2592#if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL)
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002593 WRITE_ONCE(current->rcu_tasks_idle_cpu, smp_processor_id());
Paul E. McKenney176f8f72014-08-04 17:43:50 -07002594#endif /* #if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL) */
2595}
2596
2597/* Record no current task on dyntick-idle exit. */
2598static void rcu_dynticks_task_exit(void)
2599{
2600#if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL)
Paul E. McKenney7d0ae802015-03-03 14:57:58 -08002601 WRITE_ONCE(current->rcu_tasks_idle_cpu, -1);
Paul E. McKenney176f8f72014-08-04 17:43:50 -07002602#endif /* #if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL) */
2603}