Blame view
kernel/rcutree.c
98.3 KB
64db4cfff "Tree RCU": scala... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
/* * Read-Copy Update mechanism for mutual exclusion * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * Copyright IBM Corporation, 2008 * * Authors: Dipankar Sarma <dipankar@in.ibm.com> * Manfred Spraul <manfred@colorfullife.com> * Paul E. McKenney <paulmck@linux.vnet.ibm.com> Hierarchical version * * Based on the original work by Paul McKenney <paulmck@us.ibm.com> * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen. * * For detailed explanation of Read-Copy Update mechanism see - |
a71fca58b rcu: Fix whitespa... |
28 |
* Documentation/RCU |
64db4cfff "Tree RCU": scala... |
29 30 31 32 33 34 35 36 37 |
*/ #include <linux/types.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/spinlock.h> #include <linux/smp.h> #include <linux/rcupdate.h> #include <linux/interrupt.h> #include <linux/sched.h> |
c1dc0b9c0 debug lockups: Im... |
38 |
#include <linux/nmi.h> |
8826f3b03 rcu: Avoid acquir... |
39 |
#include <linux/atomic.h> |
64db4cfff "Tree RCU": scala... |
40 |
#include <linux/bitops.h> |
9984de1a5 kernel: Map most ... |
41 |
#include <linux/export.h> |
64db4cfff "Tree RCU": scala... |
42 43 44 45 46 47 48 |
#include <linux/completion.h> #include <linux/moduleparam.h> #include <linux/percpu.h> #include <linux/notifier.h> #include <linux/cpu.h> #include <linux/mutex.h> #include <linux/time.h> |
bbad93798 rcu: slim down rc... |
49 |
#include <linux/kernel_stat.h> |
a26ac2455 rcu: move TREE_RC... |
50 51 |
#include <linux/wait.h> #include <linux/kthread.h> |
268bb0ce3 sanitize <linux/p... |
52 |
#include <linux/prefetch.h> |
3d3b7db0a rcu: Move synchro... |
53 54 |
#include <linux/delay.h> #include <linux/stop_machine.h> |
661a85dc0 rcu: Add random P... |
55 |
#include <linux/random.h> |
64db4cfff "Tree RCU": scala... |
56 |
|
9f77da9f4 rcu: Move private... |
57 |
#include "rcutree.h" |
29c00b4a1 rcu: Add event-tr... |
58 59 60 |
#include <trace/events/rcu.h> #include "rcu.h" |
9f77da9f4 rcu: Move private... |
61 |
|
64db4cfff "Tree RCU": scala... |
62 |
/* Data structures. */ |
f885b7f2b rcu: Control RCU_... |
63 |
static struct lock_class_key rcu_node_class[RCU_NUM_LVLS]; |
394f2769a rcu: Prevent forc... |
64 |
static struct lock_class_key rcu_fqs_class[RCU_NUM_LVLS]; |
88b91c7ca rcu: Simplify cre... |
65 |
|
037b64ed0 rcu: Place pointe... |
66 |
#define RCU_STATE_INITIALIZER(sname, cr) { \ |
6c90cc7bf rcu: Prevent exce... |
67 |
.level = { &sname##_state.node[0] }, \ |
037b64ed0 rcu: Place pointe... |
68 |
.call = cr, \ |
af446b702 rcu: ->signaled b... |
69 |
.fqs_state = RCU_GP_IDLE, \ |
42c3533ee rcu: Fix tracing ... |
70 71 |
.gpnum = 0UL - 300UL, \ .completed = 0UL - 300UL, \ |
7b2e6011f rcu: Rename ->ono... |
72 |
.orphan_lock = __RAW_SPIN_LOCK_UNLOCKED(&sname##_state.orphan_lock), \ |
6c90cc7bf rcu: Prevent exce... |
73 74 |
.orphan_nxttail = &sname##_state.orphan_nxtlist, \ .orphan_donetail = &sname##_state.orphan_donelist, \ |
7be7f0be9 rcu: Move rcu_bar... |
75 |
.barrier_mutex = __MUTEX_INITIALIZER(sname##_state.barrier_mutex), \ |
a4fbe35a1 rcu: Grace-period... |
76 |
.onoff_mutex = __MUTEX_INITIALIZER(sname##_state.onoff_mutex), \ |
6c90cc7bf rcu: Prevent exce... |
77 |
.name = #sname, \ |
64db4cfff "Tree RCU": scala... |
78 |
} |
037b64ed0 rcu: Place pointe... |
79 80 |
struct rcu_state rcu_sched_state = RCU_STATE_INITIALIZER(rcu_sched, call_rcu_sched); |
d6714c22b rcu: Renamings to... |
81 |
DEFINE_PER_CPU(struct rcu_data, rcu_sched_data); |
64db4cfff "Tree RCU": scala... |
82 |
|
037b64ed0 rcu: Place pointe... |
83 |
struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh, call_rcu_bh); |
6258c4fb5 kmemtrace, rcu: f... |
84 |
DEFINE_PER_CPU(struct rcu_data, rcu_bh_data); |
b1f77b058 kmemtrace, rcu: f... |
85 |
|
27f4d2805 rcu: priority boo... |
86 |
static struct rcu_state *rcu_state; |
6ce75a232 rcu: Introduce fo... |
87 |
LIST_HEAD(rcu_struct_flavors); |
27f4d2805 rcu: priority boo... |
88 |
|
f885b7f2b rcu: Control RCU_... |
89 90 |
/* Increase (but not decrease) the CONFIG_RCU_FANOUT_LEAF at boot time. */ static int rcu_fanout_leaf = CONFIG_RCU_FANOUT_LEAF; |
7e5c2dfb4 rcu: Make rcutree... |
91 |
module_param(rcu_fanout_leaf, int, 0444); |
f885b7f2b rcu: Control RCU_... |
92 93 94 95 96 97 98 99 100 |
int rcu_num_lvls __read_mostly = RCU_NUM_LVLS; static int num_rcu_lvl[] = { /* Number of rcu_nodes at specified level. */ NUM_RCU_LVL_0, NUM_RCU_LVL_1, NUM_RCU_LVL_2, NUM_RCU_LVL_3, NUM_RCU_LVL_4, }; int rcu_num_nodes __read_mostly = NUM_RCU_NODES; /* Total # rcu_nodes in use. */ |
b0d304172 rcu: Prevent RCU ... |
101 102 103 104 |
/* * The rcu_scheduler_active variable transitions from zero to one just * before the first task is spawned. So when this variable is zero, RCU * can assume that there is but one task, allowing RCU to (for example) |
b44f66562 rcu: Correct 'opt... |
105 |
* optimize synchronize_sched() to a simple barrier(). When this variable |
b0d304172 rcu: Prevent RCU ... |
106 107 108 109 |
* is one, RCU must actually do all the hard work required to detect real * grace periods. This variable is also used to suppress boot-time false * positives from lockdep-RCU error checking. */ |
bbad93798 rcu: slim down rc... |
110 111 |
int rcu_scheduler_active __read_mostly; EXPORT_SYMBOL_GPL(rcu_scheduler_active); |
b0d304172 rcu: Prevent RCU ... |
112 113 114 115 116 117 118 119 120 121 122 123 124 |
/* * The rcu_scheduler_fully_active variable transitions from zero to one * during the early_initcall() processing, which is after the scheduler * is capable of creating new tasks. So RCU processing (for example, * creating tasks for RCU priority boosting) must be delayed until after * rcu_scheduler_fully_active transitions from zero to one. We also * currently delay invocation of any RCU callbacks until after this point. * * It might later prove better for people registering RCU callbacks during * early boot to take responsibility for these callbacks, but one step at * a time. */ static int rcu_scheduler_fully_active __read_mostly; |
a46e0899e rcu: use softirq ... |
125 |
#ifdef CONFIG_RCU_BOOST |
b1f77b058 kmemtrace, rcu: f... |
126 |
/* |
a26ac2455 rcu: move TREE_RC... |
127 128 129 130 |
* Control variables for per-CPU and per-rcu_node kthreads. These * handle all flavors of RCU. */ static DEFINE_PER_CPU(struct task_struct *, rcu_cpu_kthread_task); |
d71df90ea rcu: add tracing ... |
131 |
DEFINE_PER_CPU(unsigned int, rcu_cpu_kthread_status); |
5ece5bab3 rcu: Add forward-... |
132 |
DEFINE_PER_CPU(unsigned int, rcu_cpu_kthread_loops); |
d71df90ea rcu: add tracing ... |
133 |
DEFINE_PER_CPU(char, rcu_cpu_has_work); |
a26ac2455 rcu: move TREE_RC... |
134 |
|
a46e0899e rcu: use softirq ... |
135 |
#endif /* #ifdef CONFIG_RCU_BOOST */ |
5d01bbd11 rcu: Yield simpler |
136 |
static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu); |
a46e0899e rcu: use softirq ... |
137 138 |
static void invoke_rcu_core(void); static void invoke_rcu_callbacks(struct rcu_state *rsp, struct rcu_data *rdp); |
a26ac2455 rcu: move TREE_RC... |
139 |
|
a26ac2455 rcu: move TREE_RC... |
140 |
/* |
4a2986568 rcu: make rcutort... |
141 142 143 144 145 146 147 148 149 150 151 152 |
* Track the rcutorture test sequence number and the update version * number within a given test. The rcutorture_testseq is incremented * on every rcutorture module load and unload, so has an odd value * when a test is running. The rcutorture_vernum is set to zero * when rcutorture starts and is incremented on each rcutorture update. * These variables enable correlating rcutorture output with the * RCU tracing information. */ unsigned long rcutorture_testseq; unsigned long rcutorture_vernum; /* |
fc2219d49 rcu: Clean up cod... |
153 154 155 156 157 158 159 160 161 162 |
* Return true if an RCU grace period is in progress. The ACCESS_ONCE()s * permit this function to be invoked without holding the root rcu_node * structure's ->lock, but of course results can be subject to change. */ static int rcu_gp_in_progress(struct rcu_state *rsp) { return ACCESS_ONCE(rsp->completed) != ACCESS_ONCE(rsp->gpnum); } /* |
d6714c22b rcu: Renamings to... |
163 |
* Note a quiescent state. Because we do not need to know |
b1f77b058 kmemtrace, rcu: f... |
164 |
* how many quiescent states passed, just if there was at least |
d6714c22b rcu: Renamings to... |
165 |
* one since the start of the grace period, this just sets a flag. |
e4cc1f22b rcu: Simplify qui... |
166 |
* The caller must have disabled preemption. |
b1f77b058 kmemtrace, rcu: f... |
167 |
*/ |
d6714c22b rcu: Renamings to... |
168 |
void rcu_sched_qs(int cpu) |
b1f77b058 kmemtrace, rcu: f... |
169 |
{ |
25502a6c1 rcu: refactor RCU... |
170 |
struct rcu_data *rdp = &per_cpu(rcu_sched_data, cpu); |
f41d911f8 rcu: Merge preemp... |
171 |
|
e4cc1f22b rcu: Simplify qui... |
172 |
if (rdp->passed_quiesce == 0) |
d4c08f2ac rcu: Add grace-pe... |
173 |
trace_rcu_grace_period("rcu_sched", rdp->gpnum, "cpuqs"); |
e4cc1f22b rcu: Simplify qui... |
174 |
rdp->passed_quiesce = 1; |
b1f77b058 kmemtrace, rcu: f... |
175 |
} |
d6714c22b rcu: Renamings to... |
176 |
void rcu_bh_qs(int cpu) |
b1f77b058 kmemtrace, rcu: f... |
177 |
{ |
25502a6c1 rcu: refactor RCU... |
178 |
struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu); |
f41d911f8 rcu: Merge preemp... |
179 |
|
e4cc1f22b rcu: Simplify qui... |
180 |
if (rdp->passed_quiesce == 0) |
d4c08f2ac rcu: Add grace-pe... |
181 |
trace_rcu_grace_period("rcu_bh", rdp->gpnum, "cpuqs"); |
e4cc1f22b rcu: Simplify qui... |
182 |
rdp->passed_quiesce = 1; |
b1f77b058 kmemtrace, rcu: f... |
183 |
} |
64db4cfff "Tree RCU": scala... |
184 |
|
25502a6c1 rcu: refactor RCU... |
185 186 187 |
/* * Note a context switch. This is a quiescent state for RCU-sched, * and requires special handling for preemptible RCU. |
e4cc1f22b rcu: Simplify qui... |
188 |
* The caller must have disabled preemption. |
25502a6c1 rcu: refactor RCU... |
189 190 191 |
*/ void rcu_note_context_switch(int cpu) { |
300df91ca rcu: Event-trace ... |
192 |
trace_rcu_utilization("Start context switch"); |
25502a6c1 rcu: refactor RCU... |
193 |
rcu_sched_qs(cpu); |
cba6d0d64 Revert "rcu: Move... |
194 |
rcu_preempt_note_context_switch(cpu); |
300df91ca rcu: Event-trace ... |
195 |
trace_rcu_utilization("End context switch"); |
25502a6c1 rcu: refactor RCU... |
196 |
} |
29ce83100 rcu: provide rcu_... |
197 |
EXPORT_SYMBOL_GPL(rcu_note_context_switch); |
25502a6c1 rcu: refactor RCU... |
198 |
|
90a4d2c01 rcu: make treercu... |
199 |
DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = { |
29e37d814 rcu: Allow nestin... |
200 |
.dynticks_nesting = DYNTICK_TASK_EXIT_IDLE, |
23b5c8fa0 rcu: Decrease mem... |
201 |
.dynticks = ATOMIC_INIT(1), |
90a4d2c01 rcu: make treercu... |
202 |
}; |
64db4cfff "Tree RCU": scala... |
203 |
|
878d7439d rcu: Fix batch-li... |
204 205 206 |
static long blimit = 10; /* Maximum callbacks per rcu_do_batch. */ static long qhimark = 10000; /* If this many pending, ignore blimit. */ static long qlowmark = 100; /* Once only this many pending, use blimit. */ |
64db4cfff "Tree RCU": scala... |
207 |
|
878d7439d rcu: Fix batch-li... |
208 209 210 |
module_param(blimit, long, 0444); module_param(qhimark, long, 0444); module_param(qlowmark, long, 0444); |
3d76c0829 rcu: Clean up cod... |
211 |
|
d40011f60 rcu: Control grac... |
212 213 214 215 216 |
static ulong jiffies_till_first_fqs = RCU_JIFFIES_TILL_FORCE_QS; static ulong jiffies_till_next_fqs = RCU_JIFFIES_TILL_FORCE_QS; module_param(jiffies_till_first_fqs, ulong, 0644); module_param(jiffies_till_next_fqs, ulong, 0644); |
4cdfc175c rcu: Move quiesce... |
217 218 |
static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *)); static void force_quiescent_state(struct rcu_state *rsp); |
a157229ca rcu: Simplify rcu... |
219 |
static int rcu_pending(int cpu); |
64db4cfff "Tree RCU": scala... |
220 221 |
/* |
d6714c22b rcu: Renamings to... |
222 |
* Return the number of RCU-sched batches processed thus far for debug & stats. |
64db4cfff "Tree RCU": scala... |
223 |
*/ |
d6714c22b rcu: Renamings to... |
224 |
long rcu_batches_completed_sched(void) |
64db4cfff "Tree RCU": scala... |
225 |
{ |
d6714c22b rcu: Renamings to... |
226 |
return rcu_sched_state.completed; |
64db4cfff "Tree RCU": scala... |
227 |
} |
d6714c22b rcu: Renamings to... |
228 |
EXPORT_SYMBOL_GPL(rcu_batches_completed_sched); |
64db4cfff "Tree RCU": scala... |
229 230 231 232 233 234 235 236 237 238 239 |
/* * Return the number of RCU BH batches processed thus far for debug & stats. */ long rcu_batches_completed_bh(void) { return rcu_bh_state.completed; } EXPORT_SYMBOL_GPL(rcu_batches_completed_bh); /* |
bf66f18e7 rcu: Add force_qu... |
240 241 242 243 |
* Force a quiescent state for RCU BH. */ void rcu_bh_force_quiescent_state(void) { |
4cdfc175c rcu: Move quiesce... |
244 |
force_quiescent_state(&rcu_bh_state); |
bf66f18e7 rcu: Add force_qu... |
245 246 247 248 |
} EXPORT_SYMBOL_GPL(rcu_bh_force_quiescent_state); /* |
4a2986568 rcu: make rcutort... |
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 |
* Record the number of times rcutorture tests have been initiated and * terminated. This information allows the debugfs tracing stats to be * correlated to the rcutorture messages, even when the rcutorture module * is being repeatedly loaded and unloaded. In other words, we cannot * store this state in rcutorture itself. */ void rcutorture_record_test_transition(void) { rcutorture_testseq++; rcutorture_vernum = 0; } EXPORT_SYMBOL_GPL(rcutorture_record_test_transition); /* * Record the number of writer passes through the current rcutorture test. * This is also used to correlate debugfs tracing stats with the rcutorture * messages. */ void rcutorture_record_progress(unsigned long vernum) { rcutorture_vernum++; } EXPORT_SYMBOL_GPL(rcutorture_record_progress); /* |
bf66f18e7 rcu: Add force_qu... |
274 275 276 277 |
* Force a quiescent state for RCU-sched. */ void rcu_sched_force_quiescent_state(void) { |
4cdfc175c rcu: Move quiesce... |
278 |
force_quiescent_state(&rcu_sched_state); |
bf66f18e7 rcu: Add force_qu... |
279 280 281 282 |
} EXPORT_SYMBOL_GPL(rcu_sched_force_quiescent_state); /* |
64db4cfff "Tree RCU": scala... |
283 284 285 286 287 |
* Does the CPU have callbacks ready to be invoked? */ static int cpu_has_callbacks_ready_to_invoke(struct rcu_data *rdp) { |
3fbfbf7a3 rcu: Add callback... |
288 289 |
return &rdp->nxtlist != rdp->nxttail[RCU_DONE_TAIL] && rdp->nxttail[RCU_DONE_TAIL] != NULL; |
64db4cfff "Tree RCU": scala... |
290 291 292 |
} /* |
dc35c8934 rcu: Tag callback... |
293 294 295 |
* Does the current CPU require a not-yet-started grace period? * The caller must have disabled interrupts to prevent races with * normal callback registry. |
64db4cfff "Tree RCU": scala... |
296 297 298 299 |
*/ static int cpu_needs_another_gp(struct rcu_state *rsp, struct rcu_data *rdp) { |
dc35c8934 rcu: Tag callback... |
300 |
int i; |
3fbfbf7a3 rcu: Add callback... |
301 |
|
dc35c8934 rcu: Tag callback... |
302 303 304 305 306 307 308 309 310 311 312 313 |
if (rcu_gp_in_progress(rsp)) return 0; /* No, a grace period is already in progress. */ if (!rdp->nxttail[RCU_NEXT_TAIL]) return 0; /* No, this is a no-CBs (or offline) CPU. */ if (*rdp->nxttail[RCU_NEXT_READY_TAIL]) return 1; /* Yes, this CPU has newly registered callbacks. */ for (i = RCU_WAIT_TAIL; i < RCU_NEXT_TAIL; i++) if (rdp->nxttail[i - 1] != rdp->nxttail[i] && ULONG_CMP_LT(ACCESS_ONCE(rsp->completed), rdp->nxtcompleted[i])) return 1; /* Yes, CBs for future grace period. */ return 0; /* No grace period needed. */ |
64db4cfff "Tree RCU": scala... |
314 315 316 317 318 319 320 321 322 |
} /* * Return the root node of the specified rcu_state structure. */ static struct rcu_node *rcu_get_root(struct rcu_state *rsp) { return &rsp->node[0]; } |
64db4cfff "Tree RCU": scala... |
323 |
/* |
adf5091e6 rcu: New rcu_user... |
324 |
* rcu_eqs_enter_common - current CPU is moving towards extended quiescent state |
9b2e4f188 rcu: Track idlene... |
325 326 327 328 329 |
* * If the new value of the ->dynticks_nesting counter now is zero, * we really have entered idle, and must do the appropriate accounting. * The caller must have disabled interrupts. */ |
adf5091e6 rcu: New rcu_user... |
330 331 |
static void rcu_eqs_enter_common(struct rcu_dynticks *rdtp, long long oldval, bool user) |
9b2e4f188 rcu: Track idlene... |
332 |
{ |
1bdc2b7d2 rcu: Use new nest... |
333 |
trace_rcu_dyntick("Start", oldval, rdtp->dynticks_nesting); |
cb349ca95 rcu: Apply micro-... |
334 |
if (!user && !is_idle_task(current)) { |
0989cb467 rcu: Add more inf... |
335 |
struct task_struct *idle = idle_task(smp_processor_id()); |
facc4e159 rcu: Irq nesting ... |
336 |
trace_rcu_dyntick("Error on entry: not idle task", oldval, 0); |
bf1304e9c rcu: Dump only th... |
337 |
ftrace_dump(DUMP_ORIG); |
0989cb467 rcu: Add more inf... |
338 339 340 |
WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); /* must be idle task! */ |
9b2e4f188 rcu: Track idlene... |
341 |
} |
aea1b35e2 rcu: Allow dyntic... |
342 |
rcu_prepare_for_idle(smp_processor_id()); |
9b2e4f188 rcu: Track idlene... |
343 344 345 346 347 |
/* CPUs seeing atomic_inc() must see prior RCU read-side crit sects */ smp_mb__before_atomic_inc(); /* See above. */ atomic_inc(&rdtp->dynticks); smp_mb__after_atomic_inc(); /* Force ordering with next sojourn. */ WARN_ON_ONCE(atomic_read(&rdtp->dynticks) & 0x1); |
c44e2cdda rcu: Check for id... |
348 349 |
/* |
adf5091e6 rcu: New rcu_user... |
350 |
* It is illegal to enter an extended quiescent state while |
c44e2cdda rcu: Check for id... |
351 352 353 354 355 356 357 358 |
* in an RCU read-side critical section. */ rcu_lockdep_assert(!lock_is_held(&rcu_lock_map), "Illegal idle entry in RCU read-side critical section."); rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map), "Illegal idle entry in RCU-bh read-side critical section."); rcu_lockdep_assert(!lock_is_held(&rcu_sched_lock_map), "Illegal idle entry in RCU-sched read-side critical section."); |
9b2e4f188 rcu: Track idlene... |
359 |
} |
64db4cfff "Tree RCU": scala... |
360 |
|
adf5091e6 rcu: New rcu_user... |
361 362 363 |
/* * Enter an RCU extended quiescent state, which can be either the * idle loop or adaptive-tickless usermode execution. |
64db4cfff "Tree RCU": scala... |
364 |
*/ |
adf5091e6 rcu: New rcu_user... |
365 |
static void rcu_eqs_enter(bool user) |
64db4cfff "Tree RCU": scala... |
366 |
{ |
4145fa7fb rcu: Deconfuse dy... |
367 |
long long oldval; |
64db4cfff "Tree RCU": scala... |
368 |
struct rcu_dynticks *rdtp; |
64db4cfff "Tree RCU": scala... |
369 |
rdtp = &__get_cpu_var(rcu_dynticks); |
4145fa7fb rcu: Deconfuse dy... |
370 |
oldval = rdtp->dynticks_nesting; |
29e37d814 rcu: Allow nestin... |
371 372 373 374 375 |
WARN_ON_ONCE((oldval & DYNTICK_TASK_NEST_MASK) == 0); if ((oldval & DYNTICK_TASK_NEST_MASK) == DYNTICK_TASK_NEST_VALUE) rdtp->dynticks_nesting = 0; else rdtp->dynticks_nesting -= DYNTICK_TASK_NEST_VALUE; |
adf5091e6 rcu: New rcu_user... |
376 |
rcu_eqs_enter_common(rdtp, oldval, user); |
64db4cfff "Tree RCU": scala... |
377 |
} |
adf5091e6 rcu: New rcu_user... |
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 |
/** * rcu_idle_enter - inform RCU that current CPU is entering idle * * Enter idle mode, in other words, -leave- the mode in which RCU * read-side critical sections can occur. (Though RCU read-side * critical sections can occur in irq handlers in idle, a possibility * handled by irq_enter() and irq_exit().) * * We crowbar the ->dynticks_nesting field to zero to allow for * the possibility of usermode upcalls having messed up our count * of interrupt nesting level during the prior busy period. */ void rcu_idle_enter(void) { |
c5d900bf6 rcu: Allow rcu_us... |
393 394 395 |
unsigned long flags; local_irq_save(flags); |
cb349ca95 rcu: Apply micro-... |
396 |
rcu_eqs_enter(false); |
c5d900bf6 rcu: Allow rcu_us... |
397 |
local_irq_restore(flags); |
adf5091e6 rcu: New rcu_user... |
398 |
} |
8a2ecf474 rcu: Add RCU_NONI... |
399 |
EXPORT_SYMBOL_GPL(rcu_idle_enter); |
64db4cfff "Tree RCU": scala... |
400 |
|
2b1d5024e rcu: Settle confi... |
401 |
#ifdef CONFIG_RCU_USER_QS |
9b2e4f188 rcu: Track idlene... |
402 |
/** |
adf5091e6 rcu: New rcu_user... |
403 404 405 406 407 408 409 410 411 |
* rcu_user_enter - inform RCU that we are resuming userspace. * * Enter RCU idle mode right before resuming userspace. No use of RCU * is permitted between this call and rcu_user_exit(). This way the * CPU doesn't need to maintain the tick for RCU maintenance purposes * when the CPU runs in userspace. */ void rcu_user_enter(void) { |
91d1aa43d context_tracking:... |
412 |
rcu_eqs_enter(1); |
adf5091e6 rcu: New rcu_user... |
413 |
} |
adf5091e6 rcu: New rcu_user... |
414 |
/** |
19dd1591f rcu: New rcu_user... |
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 |
* rcu_user_enter_after_irq - inform RCU that we are going to resume userspace * after the current irq returns. * * This is similar to rcu_user_enter() but in the context of a non-nesting * irq. After this call, RCU enters into idle mode when the interrupt * returns. */ void rcu_user_enter_after_irq(void) { unsigned long flags; struct rcu_dynticks *rdtp; local_irq_save(flags); rdtp = &__get_cpu_var(rcu_dynticks); /* Ensure this irq is interrupting a non-idle RCU state. */ WARN_ON_ONCE(!(rdtp->dynticks_nesting & DYNTICK_TASK_MASK)); rdtp->dynticks_nesting = 1; local_irq_restore(flags); } |
2b1d5024e rcu: Settle confi... |
434 |
#endif /* CONFIG_RCU_USER_QS */ |
19dd1591f rcu: New rcu_user... |
435 436 |
/** |
9b2e4f188 rcu: Track idlene... |
437 438 439 440 441 |
* rcu_irq_exit - inform RCU that current CPU is exiting irq towards idle * * Exit from an interrupt handler, which might possibly result in entering * idle mode, in other words, leaving the mode in which read-side critical * sections can occur. |
64db4cfff "Tree RCU": scala... |
442 |
* |
9b2e4f188 rcu: Track idlene... |
443 444 445 446 447 448 449 450 |
* This code assumes that the idle loop never does anything that might * result in unbalanced calls to irq_enter() and irq_exit(). If your * architecture violates this assumption, RCU will give you what you * deserve, good and hard. But very infrequently and irreproducibly. * * Use things like work queues to work around this limitation. * * You have been warned. |
64db4cfff "Tree RCU": scala... |
451 |
*/ |
9b2e4f188 rcu: Track idlene... |
452 |
void rcu_irq_exit(void) |
64db4cfff "Tree RCU": scala... |
453 454 |
{ unsigned long flags; |
4145fa7fb rcu: Deconfuse dy... |
455 |
long long oldval; |
64db4cfff "Tree RCU": scala... |
456 457 458 459 |
struct rcu_dynticks *rdtp; local_irq_save(flags); rdtp = &__get_cpu_var(rcu_dynticks); |
4145fa7fb rcu: Deconfuse dy... |
460 |
oldval = rdtp->dynticks_nesting; |
9b2e4f188 rcu: Track idlene... |
461 462 |
rdtp->dynticks_nesting--; WARN_ON_ONCE(rdtp->dynticks_nesting < 0); |
b6fc60201 rcu: Don't check ... |
463 464 465 |
if (rdtp->dynticks_nesting) trace_rcu_dyntick("--=", oldval, rdtp->dynticks_nesting); else |
cb349ca95 rcu: Apply micro-... |
466 |
rcu_eqs_enter_common(rdtp, oldval, true); |
9b2e4f188 rcu: Track idlene... |
467 468 469 470 |
local_irq_restore(flags); } /* |
adf5091e6 rcu: New rcu_user... |
471 |
* rcu_eqs_exit_common - current CPU moving away from extended quiescent state |
9b2e4f188 rcu: Track idlene... |
472 473 474 475 476 |
* * If the new value of the ->dynticks_nesting counter was previously zero, * we really have exited idle, and must do the appropriate accounting. * The caller must have disabled interrupts. */ |
adf5091e6 rcu: New rcu_user... |
477 478 |
static void rcu_eqs_exit_common(struct rcu_dynticks *rdtp, long long oldval, int user) |
9b2e4f188 rcu: Track idlene... |
479 |
{ |
23b5c8fa0 rcu: Decrease mem... |
480 481 482 483 484 |
smp_mb__before_atomic_inc(); /* Force ordering w/previous sojourn. */ atomic_inc(&rdtp->dynticks); /* CPUs seeing atomic_inc() must see later RCU read-side crit sects */ smp_mb__after_atomic_inc(); /* See above. */ WARN_ON_ONCE(!(atomic_read(&rdtp->dynticks) & 0x1)); |
7cb924990 rcu: Permit dynti... |
485 |
rcu_cleanup_after_idle(smp_processor_id()); |
4145fa7fb rcu: Deconfuse dy... |
486 |
trace_rcu_dyntick("End", oldval, rdtp->dynticks_nesting); |
cb349ca95 rcu: Apply micro-... |
487 |
if (!user && !is_idle_task(current)) { |
0989cb467 rcu: Add more inf... |
488 |
struct task_struct *idle = idle_task(smp_processor_id()); |
4145fa7fb rcu: Deconfuse dy... |
489 490 |
trace_rcu_dyntick("Error on exit: not idle task", oldval, rdtp->dynticks_nesting); |
bf1304e9c rcu: Dump only th... |
491 |
ftrace_dump(DUMP_ORIG); |
0989cb467 rcu: Add more inf... |
492 493 494 |
WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); /* must be idle task! */ |
9b2e4f188 rcu: Track idlene... |
495 496 |
} } |
adf5091e6 rcu: New rcu_user... |
497 498 499 |
/* * Exit an RCU extended quiescent state, which can be either the * idle loop or adaptive-tickless usermode execution. |
9b2e4f188 rcu: Track idlene... |
500 |
*/ |
adf5091e6 rcu: New rcu_user... |
501 |
static void rcu_eqs_exit(bool user) |
9b2e4f188 rcu: Track idlene... |
502 |
{ |
9b2e4f188 rcu: Track idlene... |
503 504 |
struct rcu_dynticks *rdtp; long long oldval; |
9b2e4f188 rcu: Track idlene... |
505 506 |
rdtp = &__get_cpu_var(rcu_dynticks); oldval = rdtp->dynticks_nesting; |
29e37d814 rcu: Allow nestin... |
507 508 509 510 511 |
WARN_ON_ONCE(oldval < 0); if (oldval & DYNTICK_TASK_NEST_MASK) rdtp->dynticks_nesting += DYNTICK_TASK_NEST_VALUE; else rdtp->dynticks_nesting = DYNTICK_TASK_EXIT_IDLE; |
adf5091e6 rcu: New rcu_user... |
512 |
rcu_eqs_exit_common(rdtp, oldval, user); |
9b2e4f188 rcu: Track idlene... |
513 |
} |
adf5091e6 rcu: New rcu_user... |
514 515 516 517 518 519 520 521 522 523 524 525 526 527 |
/** * rcu_idle_exit - inform RCU that current CPU is leaving idle * * Exit idle mode, in other words, -enter- the mode in which RCU * read-side critical sections can occur. * * We crowbar the ->dynticks_nesting field to DYNTICK_TASK_NEST to * allow for the possibility of usermode upcalls messing up our count * of interrupt nesting level during the busy period that is just * now starting. */ void rcu_idle_exit(void) { |
c5d900bf6 rcu: Allow rcu_us... |
528 529 530 |
unsigned long flags; local_irq_save(flags); |
cb349ca95 rcu: Apply micro-... |
531 |
rcu_eqs_exit(false); |
c5d900bf6 rcu: Allow rcu_us... |
532 |
local_irq_restore(flags); |
adf5091e6 rcu: New rcu_user... |
533 |
} |
8a2ecf474 rcu: Add RCU_NONI... |
534 |
EXPORT_SYMBOL_GPL(rcu_idle_exit); |
9b2e4f188 rcu: Track idlene... |
535 |
|
2b1d5024e rcu: Settle confi... |
536 |
#ifdef CONFIG_RCU_USER_QS |
9b2e4f188 rcu: Track idlene... |
537 |
/** |
adf5091e6 rcu: New rcu_user... |
538 539 540 541 542 543 544 |
* rcu_user_exit - inform RCU that we are exiting userspace. * * Exit RCU idle mode while entering the kernel because it can * run a RCU read side critical section anytime. */ void rcu_user_exit(void) { |
91d1aa43d context_tracking:... |
545 |
rcu_eqs_exit(1); |
adf5091e6 rcu: New rcu_user... |
546 547 548 |
} /** |
19dd1591f rcu: New rcu_user... |
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 |
* rcu_user_exit_after_irq - inform RCU that we won't resume to userspace * idle mode after the current non-nesting irq returns. * * This is similar to rcu_user_exit() but in the context of an irq. * This is called when the irq has interrupted a userspace RCU idle mode * context. When the current non-nesting interrupt returns after this call, * the CPU won't restore the RCU idle mode. */ void rcu_user_exit_after_irq(void) { unsigned long flags; struct rcu_dynticks *rdtp; local_irq_save(flags); rdtp = &__get_cpu_var(rcu_dynticks); /* Ensure we are interrupting an RCU idle mode. */ WARN_ON_ONCE(rdtp->dynticks_nesting & DYNTICK_TASK_NEST_MASK); rdtp->dynticks_nesting += DYNTICK_TASK_EXIT_IDLE; local_irq_restore(flags); } |
2b1d5024e rcu: Settle confi... |
569 |
#endif /* CONFIG_RCU_USER_QS */ |
19dd1591f rcu: New rcu_user... |
570 571 |
/** |
9b2e4f188 rcu: Track idlene... |
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 |
* rcu_irq_enter - inform RCU that current CPU is entering irq away from idle * * Enter an interrupt handler, which might possibly result in exiting * idle mode, in other words, entering the mode in which read-side critical * sections can occur. * * Note that the Linux kernel is fully capable of entering an interrupt * handler that it never exits, for example when doing upcalls to * user mode! This code assumes that the idle loop never does upcalls to * user mode. If your architecture does do upcalls from the idle loop (or * does anything else that results in unbalanced calls to the irq_enter() * and irq_exit() functions), RCU will give you what you deserve, good * and hard. But very infrequently and irreproducibly. * * Use things like work queues to work around this limitation. * * You have been warned. */ void rcu_irq_enter(void) { unsigned long flags; struct rcu_dynticks *rdtp; long long oldval; local_irq_save(flags); rdtp = &__get_cpu_var(rcu_dynticks); oldval = rdtp->dynticks_nesting; rdtp->dynticks_nesting++; WARN_ON_ONCE(rdtp->dynticks_nesting == 0); |
b6fc60201 rcu: Don't check ... |
601 602 603 |
if (oldval) trace_rcu_dyntick("++=", oldval, rdtp->dynticks_nesting); else |
cb349ca95 rcu: Apply micro-... |
604 |
rcu_eqs_exit_common(rdtp, oldval, true); |
64db4cfff "Tree RCU": scala... |
605 |
local_irq_restore(flags); |
64db4cfff "Tree RCU": scala... |
606 607 608 609 610 611 612 613 614 615 616 617 |
} /** * rcu_nmi_enter - inform RCU of entry to NMI context * * If the CPU was idle with dynamic ticks active, and there is no * irq handler running, this updates rdtp->dynticks_nmi to let the * RCU grace-period handling know that the CPU is active. */ void rcu_nmi_enter(void) { struct rcu_dynticks *rdtp = &__get_cpu_var(rcu_dynticks); |
23b5c8fa0 rcu: Decrease mem... |
618 619 |
if (rdtp->dynticks_nmi_nesting == 0 && (atomic_read(&rdtp->dynticks) & 0x1)) |
64db4cfff "Tree RCU": scala... |
620 |
return; |
23b5c8fa0 rcu: Decrease mem... |
621 622 623 624 625 626 |
rdtp->dynticks_nmi_nesting++; smp_mb__before_atomic_inc(); /* Force delay from prior write. */ atomic_inc(&rdtp->dynticks); /* CPUs seeing atomic_inc() must see later RCU read-side crit sects */ smp_mb__after_atomic_inc(); /* See above. */ WARN_ON_ONCE(!(atomic_read(&rdtp->dynticks) & 0x1)); |
64db4cfff "Tree RCU": scala... |
627 628 629 630 631 632 633 634 635 636 637 638 |
} /** * rcu_nmi_exit - inform RCU of exit from NMI context * * If the CPU was idle with dynamic ticks active, and there is no * irq handler running, this updates rdtp->dynticks_nmi to let the * RCU grace-period handling know that the CPU is no longer active. */ void rcu_nmi_exit(void) { struct rcu_dynticks *rdtp = &__get_cpu_var(rcu_dynticks); |
23b5c8fa0 rcu: Decrease mem... |
639 640 |
if (rdtp->dynticks_nmi_nesting == 0 || --rdtp->dynticks_nmi_nesting != 0) |
64db4cfff "Tree RCU": scala... |
641 |
return; |
23b5c8fa0 rcu: Decrease mem... |
642 643 644 645 646 |
/* CPUs seeing atomic_inc() must see prior RCU read-side crit sects */ smp_mb__before_atomic_inc(); /* See above. */ atomic_inc(&rdtp->dynticks); smp_mb__after_atomic_inc(); /* Force delay to next write. */ WARN_ON_ONCE(atomic_read(&rdtp->dynticks) & 0x1); |
64db4cfff "Tree RCU": scala... |
647 648 649 |
} /** |
9b2e4f188 rcu: Track idlene... |
650 |
* rcu_is_cpu_idle - see if RCU thinks that the current CPU is idle |
64db4cfff "Tree RCU": scala... |
651 |
* |
9b2e4f188 rcu: Track idlene... |
652 |
* If the current CPU is in its idle loop and is neither in an interrupt |
34240697d rcu: Disable pree... |
653 |
* or NMI handler, return true. |
64db4cfff "Tree RCU": scala... |
654 |
*/ |
9b2e4f188 rcu: Track idlene... |
655 |
int rcu_is_cpu_idle(void) |
64db4cfff "Tree RCU": scala... |
656 |
{ |
34240697d rcu: Disable pree... |
657 658 659 660 661 662 |
int ret; preempt_disable(); ret = (atomic_read(&__get_cpu_var(rcu_dynticks).dynticks) & 0x1) == 0; preempt_enable(); return ret; |
64db4cfff "Tree RCU": scala... |
663 |
} |
e6b80a3b0 rcu: Detect illeg... |
664 |
EXPORT_SYMBOL(rcu_is_cpu_idle); |
64db4cfff "Tree RCU": scala... |
665 |
|
62fde6edf rcu: Make __call_... |
666 |
#if defined(CONFIG_PROVE_RCU) && defined(CONFIG_HOTPLUG_CPU) |
c0d6d01bf rcu: Check for il... |
667 668 669 670 671 672 673 |
/* * Is the current CPU online? Disable preemption to avoid false positives * that could otherwise happen due to the current CPU number being sampled, * this task being preempted, its old CPU being taken offline, resuming * on some other CPU, then determining that its old CPU is now offline. * It is OK to use RCU on an offline processor during initial boot, hence |
2036d94a7 rcu: Rework detec... |
674 675 676 677 678 679 680 681 682 683 684 |
* the check for rcu_scheduler_fully_active. Note also that it is OK * for a CPU coming online to use RCU for one jiffy prior to marking itself * online in the cpu_online_mask. Similarly, it is OK for a CPU going * offline to continue to use RCU for one jiffy after marking itself * offline in the cpu_online_mask. This leniency is necessary given the * non-atomic nature of the online and offline processing, for example, * the fact that a CPU enters the scheduler after completing the CPU_DYING * notifiers. * * This is also why RCU internally marks CPUs online during the * CPU_UP_PREPARE phase and offline during the CPU_DEAD phase. |
c0d6d01bf rcu: Check for il... |
685 686 687 688 689 690 |
* * Disable checking if in an NMI handler because we cannot safely report * errors from NMI handlers anyway. */ bool rcu_lockdep_current_cpu_online(void) { |
2036d94a7 rcu: Rework detec... |
691 692 |
struct rcu_data *rdp; struct rcu_node *rnp; |
c0d6d01bf rcu: Check for il... |
693 694 695 696 697 |
bool ret; if (in_nmi()) return 1; preempt_disable(); |
2036d94a7 rcu: Rework detec... |
698 699 700 |
rdp = &__get_cpu_var(rcu_sched_data); rnp = rdp->mynode; ret = (rdp->grpmask & rnp->qsmaskinit) || |
c0d6d01bf rcu: Check for il... |
701 702 703 704 705 |
!rcu_scheduler_fully_active; preempt_enable(); return ret; } EXPORT_SYMBOL_GPL(rcu_lockdep_current_cpu_online); |
62fde6edf rcu: Make __call_... |
706 |
#endif /* #if defined(CONFIG_PROVE_RCU) && defined(CONFIG_HOTPLUG_CPU) */ |
9b2e4f188 rcu: Track idlene... |
707 |
|
64db4cfff "Tree RCU": scala... |
708 |
/** |
9b2e4f188 rcu: Track idlene... |
709 |
* rcu_is_cpu_rrupt_from_idle - see if idle or immediately interrupted from idle |
64db4cfff "Tree RCU": scala... |
710 |
* |
9b2e4f188 rcu: Track idlene... |
711 712 713 |
* If the current CPU is idle or running at a first-level (not nested) * interrupt from idle, return true. The caller must have at least * disabled preemption. |
64db4cfff "Tree RCU": scala... |
714 |
*/ |
62e3cb143 rcu: Make rcu_is_... |
715 |
static int rcu_is_cpu_rrupt_from_idle(void) |
64db4cfff "Tree RCU": scala... |
716 |
{ |
9b2e4f188 rcu: Track idlene... |
717 |
return __get_cpu_var(rcu_dynticks).dynticks_nesting <= 1; |
64db4cfff "Tree RCU": scala... |
718 |
} |
64db4cfff "Tree RCU": scala... |
719 |
/* |
64db4cfff "Tree RCU": scala... |
720 721 |
* Snapshot the specified CPU's dynticks counter so that we can later * credit them with an implicit quiescent state. Return 1 if this CPU |
1eba8f843 rcu: Clean up cod... |
722 |
* is in dynticks idle mode, which is an extended quiescent state. |
64db4cfff "Tree RCU": scala... |
723 724 725 |
*/ static int dyntick_save_progress_counter(struct rcu_data *rdp) { |
23b5c8fa0 rcu: Decrease mem... |
726 |
rdp->dynticks_snap = atomic_add_return(0, &rdp->dynticks->dynticks); |
f0e7c19db rcu: Identify dyn... |
727 |
return (rdp->dynticks_snap & 0x1) == 0; |
64db4cfff "Tree RCU": scala... |
728 729 730 731 732 733 |
} /* * Return true if the specified CPU has passed through a quiescent * state by virtue of being in or having passed through an dynticks * idle state since the last call to dyntick_save_progress_counter() |
a82dcc760 rcu: Make offline... |
734 |
* for this same CPU, or by virtue of having been offline. |
64db4cfff "Tree RCU": scala... |
735 736 737 |
*/ static int rcu_implicit_dynticks_qs(struct rcu_data *rdp) { |
7eb4f4553 rcu: Make rcu_imp... |
738 739 |
unsigned int curr; unsigned int snap; |
64db4cfff "Tree RCU": scala... |
740 |
|
7eb4f4553 rcu: Make rcu_imp... |
741 742 |
curr = (unsigned int)atomic_add_return(0, &rdp->dynticks->dynticks); snap = (unsigned int)rdp->dynticks_snap; |
64db4cfff "Tree RCU": scala... |
743 744 745 746 747 748 749 750 751 |
/* * If the CPU passed through or entered a dynticks idle phase with * no active irq/NMI handlers, then we can safely pretend that the CPU * already acknowledged the request to pass through a quiescent * state. Either way, that CPU cannot possibly be in an RCU * read-side critical section that started before the beginning * of the current RCU grace period. */ |
7eb4f4553 rcu: Make rcu_imp... |
752 |
if ((curr & 0x1) == 0 || UINT_CMP_GE(curr, snap + 2)) { |
d4c08f2ac rcu: Add grace-pe... |
753 |
trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, "dti"); |
64db4cfff "Tree RCU": scala... |
754 755 756 |
rdp->dynticks_fqs++; return 1; } |
a82dcc760 rcu: Make offline... |
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 |
/* * Check for the CPU being offline, but only if the grace period * is old enough. We don't need to worry about the CPU changing * state: If we see it offline even once, it has been through a * quiescent state. * * The reason for insisting that the grace period be at least * one jiffy old is that CPUs that are not quite online and that * have just gone offline can still execute RCU read-side critical * sections. */ if (ULONG_CMP_GE(rdp->rsp->gp_start + 2, jiffies)) return 0; /* Grace period is not old enough. */ barrier(); if (cpu_is_offline(rdp->cpu)) { trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, "ofl"); rdp->offline_fqs++; return 1; } return 0; |
64db4cfff "Tree RCU": scala... |
777 |
} |
64db4cfff "Tree RCU": scala... |
778 779 780 |
static void record_gp_stall_check_time(struct rcu_state *rsp) { rsp->gp_start = jiffies; |
6bfc09e23 rcu: Provide RCU ... |
781 |
rsp->jiffies_stall = jiffies + rcu_jiffies_till_stall_check(); |
64db4cfff "Tree RCU": scala... |
782 |
} |
b637a328b rcu: Print remote... |
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 |
/* * Dump stacks of all tasks running on stalled CPUs. This is a fallback * for architectures that do not implement trigger_all_cpu_backtrace(). * The NMI-triggered stack traces are more accurate because they are * printed by the target CPU. */ static void rcu_dump_cpu_stacks(struct rcu_state *rsp) { int cpu; unsigned long flags; struct rcu_node *rnp; rcu_for_each_leaf_node(rsp, rnp) { raw_spin_lock_irqsave(&rnp->lock, flags); if (rnp->qsmask != 0) { for (cpu = 0; cpu <= rnp->grphi - rnp->grplo; cpu++) if (rnp->qsmask & (1UL << cpu)) dump_cpu_task(rnp->grplo + cpu); } raw_spin_unlock_irqrestore(&rnp->lock, flags); } } |
64db4cfff "Tree RCU": scala... |
805 806 807 808 809 |
static void print_other_cpu_stall(struct rcu_state *rsp) { int cpu; long delta; unsigned long flags; |
285fe2948 rcu: Fix detectio... |
810 |
int ndetected = 0; |
64db4cfff "Tree RCU": scala... |
811 |
struct rcu_node *rnp = rcu_get_root(rsp); |
53bb857c3 rcu: Dump number ... |
812 |
long totqlen = 0; |
64db4cfff "Tree RCU": scala... |
813 814 |
/* Only let one CPU complain about others per time interval. */ |
1304afb22 rcu: Convert to r... |
815 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
816 |
delta = jiffies - rsp->jiffies_stall; |
fc2219d49 rcu: Clean up cod... |
817 |
if (delta < RCU_STALL_RAT_DELAY || !rcu_gp_in_progress(rsp)) { |
1304afb22 rcu: Convert to r... |
818 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
819 820 |
return; } |
6bfc09e23 rcu: Provide RCU ... |
821 |
rsp->jiffies_stall = jiffies + 3 * rcu_jiffies_till_stall_check() + 3; |
1304afb22 rcu: Convert to r... |
822 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
823 |
|
8cdd32a91 rcu: refer RCU CP... |
824 825 826 827 828 |
/* * OK, time to rat on our buddy... * See Documentation/RCU/stallwarn.txt for info on how to debug * RCU CPU stall warnings. */ |
a858af287 rcu: Print schedu... |
829 |
printk(KERN_ERR "INFO: %s detected stalls on CPUs/tasks:", |
4300aa642 rcu: improve RCU ... |
830 |
rsp->name); |
a858af287 rcu: Print schedu... |
831 |
print_cpu_stall_info_begin(); |
a0b6c9a78 rcu: Clean up cod... |
832 |
rcu_for_each_leaf_node(rsp, rnp) { |
3acd9eb31 rcu: Fix deadlock... |
833 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
9bc8b5586 rcu: Suppress NMI... |
834 |
ndetected += rcu_print_task_stall(rnp); |
c8020a67e rcu: Protect rcu_... |
835 836 837 838 839 840 841 842 |
if (rnp->qsmask != 0) { for (cpu = 0; cpu <= rnp->grphi - rnp->grplo; cpu++) if (rnp->qsmask & (1UL << cpu)) { print_cpu_stall_info(rsp, rnp->grplo + cpu); ndetected++; } } |
3acd9eb31 rcu: Fix deadlock... |
843 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
844 |
} |
a858af287 rcu: Print schedu... |
845 846 847 848 849 850 851 |
/* * Now rat on any tasks that got kicked up to the root rcu_node * due to CPU offlining. */ rnp = rcu_get_root(rsp); raw_spin_lock_irqsave(&rnp->lock, flags); |
285fe2948 rcu: Fix detectio... |
852 |
ndetected += rcu_print_task_stall(rnp); |
a858af287 rcu: Print schedu... |
853 854 855 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); print_cpu_stall_info_end(); |
53bb857c3 rcu: Dump number ... |
856 857 858 859 |
for_each_possible_cpu(cpu) totqlen += per_cpu_ptr(rsp->rda, cpu)->qlen; pr_cont("(detected by %d, t=%ld jiffies, g=%lu, c=%lu, q=%lu) ", |
eee058826 rcu: Add grace-pe... |
860 |
smp_processor_id(), (long)(jiffies - rsp->gp_start), |
53bb857c3 rcu: Dump number ... |
861 |
rsp->gpnum, rsp->completed, totqlen); |
9bc8b5586 rcu: Suppress NMI... |
862 863 864 865 |
if (ndetected == 0) printk(KERN_ERR "INFO: Stall ended before state dump start "); else if (!trigger_all_cpu_backtrace()) |
b637a328b rcu: Print remote... |
866 |
rcu_dump_cpu_stacks(rsp); |
c1dc0b9c0 debug lockups: Im... |
867 |
|
4cdfc175c rcu: Move quiesce... |
868 |
/* Complain about tasks blocking the grace period. */ |
1ed509a22 rcu: Add RCU_CPU_... |
869 870 |
rcu_print_detail_task_stall(rsp); |
4cdfc175c rcu: Move quiesce... |
871 |
force_quiescent_state(rsp); /* Kick them all. */ |
64db4cfff "Tree RCU": scala... |
872 873 874 875 |
} static void print_cpu_stall(struct rcu_state *rsp) { |
53bb857c3 rcu: Dump number ... |
876 |
int cpu; |
64db4cfff "Tree RCU": scala... |
877 878 |
unsigned long flags; struct rcu_node *rnp = rcu_get_root(rsp); |
53bb857c3 rcu: Dump number ... |
879 |
long totqlen = 0; |
64db4cfff "Tree RCU": scala... |
880 |
|
8cdd32a91 rcu: refer RCU CP... |
881 882 883 884 885 |
/* * OK, time to rat on ourselves... * See Documentation/RCU/stallwarn.txt for info on how to debug * RCU CPU stall warnings. */ |
a858af287 rcu: Print schedu... |
886 887 888 889 |
printk(KERN_ERR "INFO: %s self-detected stall on CPU", rsp->name); print_cpu_stall_info_begin(); print_cpu_stall_info(rsp, smp_processor_id()); print_cpu_stall_info_end(); |
53bb857c3 rcu: Dump number ... |
890 891 892 893 894 |
for_each_possible_cpu(cpu) totqlen += per_cpu_ptr(rsp->rda, cpu)->qlen; pr_cont(" (t=%lu jiffies g=%lu c=%lu q=%lu) ", jiffies - rsp->gp_start, rsp->gpnum, rsp->completed, totqlen); |
4627e240d rcu: Dump local s... |
895 896 |
if (!trigger_all_cpu_backtrace()) dump_stack(); |
c1dc0b9c0 debug lockups: Im... |
897 |
|
1304afb22 rcu: Convert to r... |
898 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
20133cfce rcu: Stop overflo... |
899 |
if (ULONG_CMP_GE(jiffies, rsp->jiffies_stall)) |
13cfcca0e rcu: Set RCU CPU ... |
900 |
rsp->jiffies_stall = jiffies + |
6bfc09e23 rcu: Provide RCU ... |
901 |
3 * rcu_jiffies_till_stall_check() + 3; |
1304afb22 rcu: Convert to r... |
902 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
c1dc0b9c0 debug lockups: Im... |
903 |
|
64db4cfff "Tree RCU": scala... |
904 905 906 907 908 |
set_need_resched(); /* kick ourselves to get things going. */ } static void check_cpu_stall(struct rcu_state *rsp, struct rcu_data *rdp) { |
bad6e1393 rcu: get rid of s... |
909 910 |
unsigned long j; unsigned long js; |
64db4cfff "Tree RCU": scala... |
911 |
struct rcu_node *rnp; |
742734eea rcu: add boot par... |
912 |
if (rcu_cpu_stall_suppress) |
c68de2097 rcu: disable CPU ... |
913 |
return; |
bad6e1393 rcu: get rid of s... |
914 915 |
j = ACCESS_ONCE(jiffies); js = ACCESS_ONCE(rsp->jiffies_stall); |
64db4cfff "Tree RCU": scala... |
916 |
rnp = rdp->mynode; |
c96ea7cfd rcu: Avoid spurio... |
917 918 |
if (rcu_gp_in_progress(rsp) && (ACCESS_ONCE(rnp->qsmask) & rdp->grpmask) && ULONG_CMP_GE(j, js)) { |
64db4cfff "Tree RCU": scala... |
919 920 921 |
/* We haven't checked in, so go dump stack. */ print_cpu_stall(rsp); |
bad6e1393 rcu: get rid of s... |
922 923 |
} else if (rcu_gp_in_progress(rsp) && ULONG_CMP_GE(j, js + RCU_STALL_RAT_DELAY)) { |
64db4cfff "Tree RCU": scala... |
924 |
|
bad6e1393 rcu: get rid of s... |
925 |
/* They had a few time units to dump stack, so complain. */ |
64db4cfff "Tree RCU": scala... |
926 927 928 |
print_other_cpu_stall(rsp); } } |
53d84e004 rcu: permit suppr... |
929 930 931 932 933 934 935 936 937 938 939 |
/** * rcu_cpu_stall_reset - prevent further stall warnings in current grace period * * Set the stall-warning timeout way off into the future, thus preventing * any RCU CPU stall-warning messages from appearing in the current set of * RCU grace periods. * * The caller must disable hard irqs. */ void rcu_cpu_stall_reset(void) { |
6ce75a232 rcu: Introduce fo... |
940 941 942 943 |
struct rcu_state *rsp; for_each_rcu_flavor(rsp) rsp->jiffies_stall = jiffies + ULONG_MAX / 2; |
53d84e004 rcu: permit suppr... |
944 |
} |
64db4cfff "Tree RCU": scala... |
945 946 947 |
/* * Update CPU-local rcu_data state to record the newly noticed grace period. * This is used both when we started the grace period and when we notice |
9160306e6 rcu: Fix note_new... |
948 949 950 |
* that someone else started the grace period. The caller must hold the * ->lock of the leaf rcu_node structure corresponding to the current CPU, * and must have irqs disabled. |
64db4cfff "Tree RCU": scala... |
951 |
*/ |
9160306e6 rcu: Fix note_new... |
952 953 954 |
static void __note_new_gpnum(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp) { if (rdp->gpnum != rnp->gpnum) { |
121dfc4b3 rcu: fine-tune gr... |
955 956 957 958 959 |
/* * If the current grace period is waiting for this CPU, * set up to detect a quiescent state, otherwise don't * go looking for one. */ |
9160306e6 rcu: Fix note_new... |
960 |
rdp->gpnum = rnp->gpnum; |
d4c08f2ac rcu: Add grace-pe... |
961 |
trace_rcu_grace_period(rsp->name, rdp->gpnum, "cpustart"); |
d7d6a11e8 rcu: Simplify qui... |
962 963 |
rdp->passed_quiesce = 0; rdp->qs_pending = !!(rnp->qsmask & rdp->grpmask); |
a858af287 rcu: Print schedu... |
964 |
zero_cpu_stall_ticks(rdp); |
9160306e6 rcu: Fix note_new... |
965 966 |
} } |
64db4cfff "Tree RCU": scala... |
967 968 |
static void note_new_gpnum(struct rcu_state *rsp, struct rcu_data *rdp) { |
9160306e6 rcu: Fix note_new... |
969 970 971 972 973 974 |
unsigned long flags; struct rcu_node *rnp; local_irq_save(flags); rnp = rdp->mynode; if (rdp->gpnum == ACCESS_ONCE(rnp->gpnum) || /* outside lock. */ |
1304afb22 rcu: Convert to r... |
975 |
!raw_spin_trylock(&rnp->lock)) { /* irqs already off, so later. */ |
9160306e6 rcu: Fix note_new... |
976 977 978 979 |
local_irq_restore(flags); return; } __note_new_gpnum(rsp, rnp, rdp); |
1304afb22 rcu: Convert to r... |
980 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 |
} /* * Did someone else start a new RCU grace period start since we last * checked? Update local state appropriately if so. Must be called * on the CPU corresponding to rdp. */ static int check_for_new_grace_period(struct rcu_state *rsp, struct rcu_data *rdp) { unsigned long flags; int ret = 0; local_irq_save(flags); if (rdp->gpnum != rsp->gpnum) { note_new_gpnum(rsp, rdp); ret = 1; } local_irq_restore(flags); return ret; } /* |
3f5d3ea64 rcu: Consolidate ... |
1004 1005 1006 1007 1008 1009 1010 1011 1012 |
* Initialize the specified rcu_data structure's callback list to empty. */ static void init_callback_list(struct rcu_data *rdp) { int i; rdp->nxtlist = NULL; for (i = 0; i < RCU_NEXT_SIZE; i++) rdp->nxttail[i] = &rdp->nxtlist; |
3fbfbf7a3 rcu: Add callback... |
1013 |
init_nocb_callback_list(rdp); |
3f5d3ea64 rcu: Consolidate ... |
1014 1015 1016 |
} /* |
dc35c8934 rcu: Tag callback... |
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 |
* Determine the value that ->completed will have at the end of the * next subsequent grace period. This is used to tag callbacks so that * a CPU can invoke callbacks in a timely fashion even if that CPU has * been dyntick-idle for an extended period with callbacks under the * influence of RCU_FAST_NO_HZ. * * The caller must hold rnp->lock with interrupts disabled. */ static unsigned long rcu_cbs_completed(struct rcu_state *rsp, struct rcu_node *rnp) { /* * If RCU is idle, we just wait for the next grace period. * But we can only be sure that RCU is idle if we are looking * at the root rcu_node structure -- otherwise, a new grace * period might have started, but just not yet gotten around * to initializing the current non-root rcu_node structure. */ if (rcu_get_root(rsp) == rnp && rnp->gpnum == rnp->completed) return rnp->completed + 1; /* * Otherwise, wait for a possible partial grace period and * then the subsequent full grace period. */ return rnp->completed + 2; } /* * If there is room, assign a ->completed number to any callbacks on * this CPU that have not already been assigned. Also accelerate any * callbacks that were previously assigned a ->completed number that has * since proven to be too conservative, which can happen if callbacks get * assigned a ->completed number while RCU is idle, but with reference to * a non-root rcu_node structure. This function is idempotent, so it does * not hurt to call it repeatedly. * * The caller must hold rnp->lock with interrupts disabled. */ static void rcu_accelerate_cbs(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp) { unsigned long c; int i; /* If the CPU has no callbacks, nothing to do. */ if (!rdp->nxttail[RCU_NEXT_TAIL] || !*rdp->nxttail[RCU_DONE_TAIL]) return; /* * Starting from the sublist containing the callbacks most * recently assigned a ->completed number and working down, find the * first sublist that is not assignable to an upcoming grace period. * Such a sublist has something in it (first two tests) and has * a ->completed number assigned that will complete sooner than * the ->completed number for newly arrived callbacks (last test). * * The key point is that any later sublist can be assigned the * same ->completed number as the newly arrived callbacks, which * means that the callbacks in any of these later sublist can be * grouped into a single sublist, whether or not they have already * been assigned a ->completed number. */ c = rcu_cbs_completed(rsp, rnp); for (i = RCU_NEXT_TAIL - 1; i > RCU_DONE_TAIL; i--) if (rdp->nxttail[i] != rdp->nxttail[i - 1] && !ULONG_CMP_GE(rdp->nxtcompleted[i], c)) break; /* * If there are no sublist for unassigned callbacks, leave. * At the same time, advance "i" one sublist, so that "i" will * index into the sublist where all the remaining callbacks should * be grouped into. */ if (++i >= RCU_NEXT_TAIL) return; /* * Assign all subsequent callbacks' ->completed number to the next * full grace period and group them all in the sublist initially * indexed by "i". */ for (; i <= RCU_NEXT_TAIL; i++) { rdp->nxttail[i] = rdp->nxttail[RCU_NEXT_TAIL]; rdp->nxtcompleted[i] = c; } |
6d4b418c7 rcu: Trace callba... |
1104 1105 1106 1107 1108 1109 |
/* Trace depending on how much we were able to accelerate. */ if (!*rdp->nxttail[RCU_WAIT_TAIL]) trace_rcu_grace_period(rsp->name, rdp->gpnum, "AccWaitCB"); else trace_rcu_grace_period(rsp->name, rdp->gpnum, "AccReadyCB"); |
dc35c8934 rcu: Tag callback... |
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 |
} /* * Move any callbacks whose grace period has completed to the * RCU_DONE_TAIL sublist, then compact the remaining sublists and * assign ->completed numbers to any callbacks in the RCU_NEXT_TAIL * sublist. This function is idempotent, so it does not hurt to * invoke it repeatedly. As long as it is not invoked -too- often... * * The caller must hold rnp->lock with interrupts disabled. */ static void rcu_advance_cbs(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp) { int i, j; /* If the CPU has no callbacks, nothing to do. */ if (!rdp->nxttail[RCU_NEXT_TAIL] || !*rdp->nxttail[RCU_DONE_TAIL]) return; /* * Find all callbacks whose ->completed numbers indicate that they * are ready to invoke, and put them into the RCU_DONE_TAIL sublist. */ for (i = RCU_WAIT_TAIL; i < RCU_NEXT_TAIL; i++) { if (ULONG_CMP_LT(rnp->completed, rdp->nxtcompleted[i])) break; rdp->nxttail[RCU_DONE_TAIL] = rdp->nxttail[i]; } /* Clean up any sublist tail pointers that were misordered above. */ for (j = RCU_WAIT_TAIL; j < i; j++) rdp->nxttail[j] = rdp->nxttail[RCU_DONE_TAIL]; /* Copy down callbacks to fill in empty sublists. */ for (j = RCU_WAIT_TAIL; i < RCU_NEXT_TAIL; i++, j++) { if (rdp->nxttail[j] == rdp->nxttail[RCU_NEXT_TAIL]) break; rdp->nxttail[j] = rdp->nxttail[i]; rdp->nxtcompleted[j] = rdp->nxtcompleted[i]; } /* Classify any remaining callbacks. */ rcu_accelerate_cbs(rsp, rnp, rdp); } /* |
d09b62dfa rcu: Fix synchron... |
1156 1157 1158 1159 1160 1161 1162 1163 1164 |
* Advance this CPU's callbacks, but only if the current grace period * has ended. This may be called only from the CPU to whom the rdp * belongs. In addition, the corresponding leaf rcu_node structure's * ->lock must be held by the caller, with irqs disabled. */ static void __rcu_process_gp_end(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp) { /* Did another grace period end? */ |
dc35c8934 rcu: Tag callback... |
1165 |
if (rdp->completed == rnp->completed) { |
d09b62dfa rcu: Fix synchron... |
1166 |
|
dc35c8934 rcu: Tag callback... |
1167 1168 |
/* No, so just accelerate recent callbacks. */ rcu_accelerate_cbs(rsp, rnp, rdp); |
d09b62dfa rcu: Fix synchron... |
1169 |
|
dc35c8934 rcu: Tag callback... |
1170 1171 1172 1173 |
} else { /* Advance callbacks. */ rcu_advance_cbs(rsp, rnp, rdp); |
d09b62dfa rcu: Fix synchron... |
1174 1175 1176 |
/* Remember that we saw this grace-period completion. */ rdp->completed = rnp->completed; |
d4c08f2ac rcu: Add grace-pe... |
1177 |
trace_rcu_grace_period(rsp->name, rdp->gpnum, "cpuend"); |
20377f32d rcu: Stop chasing... |
1178 1179 |
/* |
5ff8e6f05 rcu: Keep gpnum a... |
1180 |
* If we were in an extended quiescent state, we may have |
121dfc4b3 rcu: fine-tune gr... |
1181 |
* missed some grace periods that others CPUs handled on |
5ff8e6f05 rcu: Keep gpnum a... |
1182 |
* our behalf. Catch up with this state to avoid noting |
121dfc4b3 rcu: fine-tune gr... |
1183 1184 |
* spurious new grace periods. If another grace period * has started, then rnp->gpnum will have advanced, so |
d7d6a11e8 rcu: Simplify qui... |
1185 1186 |
* we will detect this later on. Of course, any quiescent * states we found for the old GP are now invalid. |
5ff8e6f05 rcu: Keep gpnum a... |
1187 |
*/ |
d7d6a11e8 rcu: Simplify qui... |
1188 |
if (ULONG_CMP_LT(rdp->gpnum, rdp->completed)) { |
5ff8e6f05 rcu: Keep gpnum a... |
1189 |
rdp->gpnum = rdp->completed; |
d7d6a11e8 rcu: Simplify qui... |
1190 1191 |
rdp->passed_quiesce = 0; } |
5ff8e6f05 rcu: Keep gpnum a... |
1192 1193 |
/* |
121dfc4b3 rcu: fine-tune gr... |
1194 1195 |
* If RCU does not need a quiescent state from this CPU, * then make sure that this CPU doesn't go looking for one. |
20377f32d rcu: Stop chasing... |
1196 |
*/ |
121dfc4b3 rcu: fine-tune gr... |
1197 |
if ((rnp->qsmask & rdp->grpmask) == 0) |
20377f32d rcu: Stop chasing... |
1198 |
rdp->qs_pending = 0; |
d09b62dfa rcu: Fix synchron... |
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 |
} } /* * Advance this CPU's callbacks, but only if the current grace period * has ended. This may be called only from the CPU to whom the rdp * belongs. */ static void rcu_process_gp_end(struct rcu_state *rsp, struct rcu_data *rdp) { unsigned long flags; struct rcu_node *rnp; local_irq_save(flags); rnp = rdp->mynode; if (rdp->completed == ACCESS_ONCE(rnp->completed) || /* outside lock. */ |
1304afb22 rcu: Convert to r... |
1216 |
!raw_spin_trylock(&rnp->lock)) { /* irqs already off, so later. */ |
d09b62dfa rcu: Fix synchron... |
1217 1218 1219 1220 |
local_irq_restore(flags); return; } __rcu_process_gp_end(rsp, rnp, rdp); |
1304afb22 rcu: Convert to r... |
1221 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
d09b62dfa rcu: Fix synchron... |
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 |
} /* * Do per-CPU grace-period initialization for running CPU. The caller * must hold the lock of the leaf rcu_node structure corresponding to * this CPU. */ static void rcu_start_gp_per_cpu(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp) { /* Prior grace period ended, so advance callbacks for current CPU. */ __rcu_process_gp_end(rsp, rnp, rdp); |
9160306e6 rcu: Fix note_new... |
1234 1235 |
/* Set state so that this CPU will detect the next quiescent state. */ __note_new_gpnum(rsp, rnp, rdp); |
d09b62dfa rcu: Fix synchron... |
1236 1237 1238 |
} /* |
7fdefc10e rcu: Break up rcu... |
1239 |
* Initialize a new grace period. |
b3dbec76e rcu: Move RCU gra... |
1240 |
*/ |
7fdefc10e rcu: Break up rcu... |
1241 |
static int rcu_gp_init(struct rcu_state *rsp) |
b3dbec76e rcu: Move RCU gra... |
1242 1243 |
{ struct rcu_data *rdp; |
7fdefc10e rcu: Break up rcu... |
1244 |
struct rcu_node *rnp = rcu_get_root(rsp); |
b3dbec76e rcu: Move RCU gra... |
1245 |
|
7fdefc10e rcu: Break up rcu... |
1246 |
raw_spin_lock_irq(&rnp->lock); |
4cdfc175c rcu: Move quiesce... |
1247 |
rsp->gp_flags = 0; /* Clear all flags: New grace period. */ |
b3dbec76e rcu: Move RCU gra... |
1248 |
|
7fdefc10e rcu: Break up rcu... |
1249 1250 1251 1252 1253 |
if (rcu_gp_in_progress(rsp)) { /* Grace period already in progress, don't start another. */ raw_spin_unlock_irq(&rnp->lock); return 0; } |
7fdefc10e rcu: Break up rcu... |
1254 1255 1256 |
/* Advance to a new grace period and initialize state. */ rsp->gpnum++; trace_rcu_grace_period(rsp->name, rsp->gpnum, "start"); |
7fdefc10e rcu: Break up rcu... |
1257 1258 1259 1260 |
record_gp_stall_check_time(rsp); raw_spin_unlock_irq(&rnp->lock); /* Exclude any concurrent CPU-hotplug operations. */ |
a4fbe35a1 rcu: Grace-period... |
1261 |
mutex_lock(&rsp->onoff_mutex); |
7fdefc10e rcu: Break up rcu... |
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 |
/* * Set the quiescent-state-needed bits in all the rcu_node * structures for all currently online CPUs in breadth-first order, * starting from the root rcu_node structure, relying on the layout * of the tree within the rsp->node[] array. Note that other CPUs * will access only the leaves of the hierarchy, thus seeing that no * grace period is in progress, at least until the corresponding * leaf node has been initialized. In addition, we have excluded * CPU-hotplug operations. * * The grace period cannot complete until the initialization * process finishes, because this kthread handles both. */ rcu_for_each_node_breadth_first(rsp, rnp) { |
b3dbec76e rcu: Move RCU gra... |
1277 |
raw_spin_lock_irq(&rnp->lock); |
b3dbec76e rcu: Move RCU gra... |
1278 |
rdp = this_cpu_ptr(rsp->rda); |
7fdefc10e rcu: Break up rcu... |
1279 1280 1281 |
rcu_preempt_check_blocked_tasks(rnp); rnp->qsmask = rnp->qsmaskinit; rnp->gpnum = rsp->gpnum; |
25d30cf42 rcu: Adjust for u... |
1282 |
WARN_ON_ONCE(rnp->completed != rsp->completed); |
7fdefc10e rcu: Break up rcu... |
1283 1284 1285 1286 1287 1288 1289 1290 |
rnp->completed = rsp->completed; if (rnp == rdp->mynode) rcu_start_gp_per_cpu(rsp, rnp, rdp); rcu_preempt_boost_start_gp(rnp); trace_rcu_grace_period_init(rsp->name, rnp->gpnum, rnp->level, rnp->grplo, rnp->grphi, rnp->qsmask); raw_spin_unlock_irq(&rnp->lock); |
661a85dc0 rcu: Add random P... |
1291 1292 1293 1294 |
#ifdef CONFIG_PROVE_RCU_DELAY if ((random32() % (rcu_num_nodes * 8)) == 0) schedule_timeout_uninterruptible(2); #endif /* #ifdef CONFIG_PROVE_RCU_DELAY */ |
7fdefc10e rcu: Break up rcu... |
1295 1296 |
cond_resched(); } |
b3dbec76e rcu: Move RCU gra... |
1297 |
|
a4fbe35a1 rcu: Grace-period... |
1298 |
mutex_unlock(&rsp->onoff_mutex); |
7fdefc10e rcu: Break up rcu... |
1299 1300 |
return 1; } |
b3dbec76e rcu: Move RCU gra... |
1301 |
|
7fdefc10e rcu: Break up rcu... |
1302 |
/* |
4cdfc175c rcu: Move quiesce... |
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 |
* Do one round of quiescent-state forcing. */ int rcu_gp_fqs(struct rcu_state *rsp, int fqs_state_in) { int fqs_state = fqs_state_in; struct rcu_node *rnp = rcu_get_root(rsp); rsp->n_force_qs++; if (fqs_state == RCU_SAVE_DYNTICK) { /* Collect dyntick-idle snapshots. */ force_qs_rnp(rsp, dyntick_save_progress_counter); fqs_state = RCU_FORCE_QS; } else { /* Handle dyntick-idle and offline CPUs. */ force_qs_rnp(rsp, rcu_implicit_dynticks_qs); } /* Clear flag to prevent immediate re-entry. */ if (ACCESS_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) { raw_spin_lock_irq(&rnp->lock); rsp->gp_flags &= ~RCU_GP_FLAG_FQS; raw_spin_unlock_irq(&rnp->lock); } return fqs_state; } /* |
7fdefc10e rcu: Break up rcu... |
1329 1330 |
* Clean up after the old grace period. */ |
4cdfc175c rcu: Move quiesce... |
1331 |
static void rcu_gp_cleanup(struct rcu_state *rsp) |
7fdefc10e rcu: Break up rcu... |
1332 1333 1334 1335 |
{ unsigned long gp_duration; struct rcu_data *rdp; struct rcu_node *rnp = rcu_get_root(rsp); |
b3dbec76e rcu: Move RCU gra... |
1336 |
|
7fdefc10e rcu: Break up rcu... |
1337 1338 1339 1340 |
raw_spin_lock_irq(&rnp->lock); gp_duration = jiffies - rsp->gp_start; if (gp_duration > rsp->gp_max) rsp->gp_max = gp_duration; |
b3dbec76e rcu: Move RCU gra... |
1341 |
|
7fdefc10e rcu: Break up rcu... |
1342 1343 1344 1345 1346 1347 1348 |
/* * We know the grace period is complete, but to everyone else * it appears to still be ongoing. But it is also the case * that to everyone else it looks like there is nothing that * they can do to advance the grace period. It is therefore * safe for us to drop the lock in order to mark the grace * period as completed in all of the rcu_node structures. |
7fdefc10e rcu: Break up rcu... |
1349 |
*/ |
5d4b86594 rcu: Fix day-zero... |
1350 |
raw_spin_unlock_irq(&rnp->lock); |
b3dbec76e rcu: Move RCU gra... |
1351 |
|
5d4b86594 rcu: Fix day-zero... |
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 |
/* * Propagate new ->completed value to rcu_node structures so * that other CPUs don't have to wait until the start of the next * grace period to process their callbacks. This also avoids * some nasty RCU grace-period initialization races by forcing * the end of the current grace period to be completely recorded in * all of the rcu_node structures before the beginning of the next * grace period is recorded in any of the rcu_node structures. */ rcu_for_each_node_breadth_first(rsp, rnp) { |
755609a90 rcu: Allow RCU gr... |
1362 |
raw_spin_lock_irq(&rnp->lock); |
5d4b86594 rcu: Fix day-zero... |
1363 1364 1365 |
rnp->completed = rsp->gpnum; raw_spin_unlock_irq(&rnp->lock); cond_resched(); |
7fdefc10e rcu: Break up rcu... |
1366 |
} |
5d4b86594 rcu: Fix day-zero... |
1367 1368 |
rnp = rcu_get_root(rsp); raw_spin_lock_irq(&rnp->lock); |
7fdefc10e rcu: Break up rcu... |
1369 1370 1371 1372 |
rsp->completed = rsp->gpnum; /* Declare grace period done. */ trace_rcu_grace_period(rsp->name, rsp->completed, "end"); rsp->fqs_state = RCU_GP_IDLE; |
5d4b86594 rcu: Fix day-zero... |
1373 |
rdp = this_cpu_ptr(rsp->rda); |
7fdefc10e rcu: Break up rcu... |
1374 1375 1376 |
if (cpu_needs_another_gp(rsp, rdp)) rsp->gp_flags = 1; raw_spin_unlock_irq(&rnp->lock); |
7fdefc10e rcu: Break up rcu... |
1377 1378 1379 1380 1381 1382 1383 |
} /* * Body of kthread that handles grace periods. */ static int __noreturn rcu_gp_kthread(void *arg) { |
4cdfc175c rcu: Move quiesce... |
1384 |
int fqs_state; |
d40011f60 rcu: Control grac... |
1385 |
unsigned long j; |
4cdfc175c rcu: Move quiesce... |
1386 |
int ret; |
7fdefc10e rcu: Break up rcu... |
1387 1388 1389 1390 1391 1392 1393 |
struct rcu_state *rsp = arg; struct rcu_node *rnp = rcu_get_root(rsp); for (;;) { /* Handle grace-period start. */ for (;;) { |
4cdfc175c rcu: Move quiesce... |
1394 1395 1396 1397 1398 |
wait_event_interruptible(rsp->gp_wq, rsp->gp_flags & RCU_GP_FLAG_INIT); if ((rsp->gp_flags & RCU_GP_FLAG_INIT) && rcu_gp_init(rsp)) |
7fdefc10e rcu: Break up rcu... |
1399 1400 1401 1402 |
break; cond_resched(); flush_signals(current); } |
cabc49c1f rcu: Move RCU gra... |
1403 |
|
4cdfc175c rcu: Move quiesce... |
1404 1405 |
/* Handle quiescent-state forcing. */ fqs_state = RCU_SAVE_DYNTICK; |
d40011f60 rcu: Control grac... |
1406 1407 1408 1409 1410 |
j = jiffies_till_first_fqs; if (j > HZ) { j = HZ; jiffies_till_first_fqs = HZ; } |
cabc49c1f rcu: Move RCU gra... |
1411 |
for (;;) { |
d40011f60 rcu: Control grac... |
1412 |
rsp->jiffies_force_qs = jiffies + j; |
4cdfc175c rcu: Move quiesce... |
1413 1414 1415 1416 |
ret = wait_event_interruptible_timeout(rsp->gp_wq, (rsp->gp_flags & RCU_GP_FLAG_FQS) || (!ACCESS_ONCE(rnp->qsmask) && !rcu_preempt_blocked_readers_cgp(rnp)), |
d40011f60 rcu: Control grac... |
1417 |
j); |
4cdfc175c rcu: Move quiesce... |
1418 |
/* If grace period done, leave loop. */ |
cabc49c1f rcu: Move RCU gra... |
1419 |
if (!ACCESS_ONCE(rnp->qsmask) && |
4cdfc175c rcu: Move quiesce... |
1420 |
!rcu_preempt_blocked_readers_cgp(rnp)) |
cabc49c1f rcu: Move RCU gra... |
1421 |
break; |
4cdfc175c rcu: Move quiesce... |
1422 1423 1424 1425 1426 1427 1428 1429 1430 |
/* If time for quiescent-state forcing, do it. */ if (ret == 0 || (rsp->gp_flags & RCU_GP_FLAG_FQS)) { fqs_state = rcu_gp_fqs(rsp, fqs_state); cond_resched(); } else { /* Deal with stray signal. */ cond_resched(); flush_signals(current); } |
d40011f60 rcu: Control grac... |
1431 1432 1433 1434 1435 1436 1437 1438 |
j = jiffies_till_next_fqs; if (j > HZ) { j = HZ; jiffies_till_next_fqs = HZ; } else if (j < 1) { j = 1; jiffies_till_next_fqs = 1; } |
cabc49c1f rcu: Move RCU gra... |
1439 |
} |
4cdfc175c rcu: Move quiesce... |
1440 1441 1442 |
/* Handle grace-period end. */ rcu_gp_cleanup(rsp); |
b3dbec76e rcu: Move RCU gra... |
1443 |
} |
b3dbec76e rcu: Move RCU gra... |
1444 1445 1446 |
} /* |
64db4cfff "Tree RCU": scala... |
1447 1448 1449 1450 |
* Start a new RCU grace period if warranted, re-initializing the hierarchy * in preparation for detecting the next grace period. The caller must hold * the root node's ->lock, which is released before return. Hard irqs must * be disabled. |
e56014000 rcu: Simplify off... |
1451 1452 1453 1454 |
* * Note that it is legal for a dying CPU (which is marked as offline) to * invoke this function. This can happen when the dying CPU reports its * quiescent state. |
64db4cfff "Tree RCU": scala... |
1455 1456 1457 1458 1459 |
*/ static void rcu_start_gp(struct rcu_state *rsp, unsigned long flags) __releases(rcu_get_root(rsp)->lock) { |
394f99a90 rcu: simplify the... |
1460 |
struct rcu_data *rdp = this_cpu_ptr(rsp->rda); |
64db4cfff "Tree RCU": scala... |
1461 |
struct rcu_node *rnp = rcu_get_root(rsp); |
64db4cfff "Tree RCU": scala... |
1462 |
|
b3dbec76e rcu: Move RCU gra... |
1463 |
if (!rsp->gp_kthread || |
afe24b122 rcu: Move propaga... |
1464 1465 |
!cpu_needs_another_gp(rsp, rdp)) { /* |
b3dbec76e rcu: Move RCU gra... |
1466 |
* Either we have not yet spawned the grace-period |
62da19212 rcu: Accelerate c... |
1467 1468 |
* task, this CPU does not need another grace period, * or a grace period is already in progress. |
b3dbec76e rcu: Move RCU gra... |
1469 |
* Either way, don't start a new grace period. |
afe24b122 rcu: Move propaga... |
1470 1471 1472 1473 |
*/ raw_spin_unlock_irqrestore(&rnp->lock, flags); return; } |
b32e9eb6a rcu: Accelerate c... |
1474 |
|
62da19212 rcu: Accelerate c... |
1475 1476 1477 |
/* * Because there is no grace period in progress right now, * any callbacks we have up to this point will be satisfied |
dc35c8934 rcu: Tag callback... |
1478 1479 |
* by the next grace period. So this is a good place to * assign a grace period number to recently posted callbacks. |
62da19212 rcu: Accelerate c... |
1480 |
*/ |
dc35c8934 rcu: Tag callback... |
1481 |
rcu_accelerate_cbs(rsp, rnp, rdp); |
62da19212 rcu: Accelerate c... |
1482 |
|
4cdfc175c rcu: Move quiesce... |
1483 |
rsp->gp_flags = RCU_GP_FLAG_INIT; |
62da19212 rcu: Accelerate c... |
1484 1485 1486 1487 1488 1489 1490 |
raw_spin_unlock(&rnp->lock); /* Interrupts remain disabled. */ /* Ensure that CPU is aware of completion of last grace period. */ rcu_process_gp_end(rsp, rdp); local_irq_restore(flags); /* Wake up rcu_gp_kthread() to start the grace period. */ |
b3dbec76e rcu: Move RCU gra... |
1491 |
wake_up(&rsp->gp_wq); |
64db4cfff "Tree RCU": scala... |
1492 1493 1494 |
} /* |
d3f6bad39 rcu: Rename "quie... |
1495 1496 1497 1498 1499 |
* Report a full set of quiescent states to the specified rcu_state * data structure. This involves cleaning up after the prior grace * period and letting rcu_start_gp() start up the next grace period * if one is needed. Note that the caller must hold rnp->lock, as * required by rcu_start_gp(), which will release it. |
f41d911f8 rcu: Merge preemp... |
1500 |
*/ |
d3f6bad39 rcu: Rename "quie... |
1501 |
static void rcu_report_qs_rsp(struct rcu_state *rsp, unsigned long flags) |
fc2219d49 rcu: Clean up cod... |
1502 |
__releases(rcu_get_root(rsp)->lock) |
f41d911f8 rcu: Merge preemp... |
1503 |
{ |
fc2219d49 rcu: Clean up cod... |
1504 |
WARN_ON_ONCE(!rcu_gp_in_progress(rsp)); |
cabc49c1f rcu: Move RCU gra... |
1505 1506 |
raw_spin_unlock_irqrestore(&rcu_get_root(rsp)->lock, flags); wake_up(&rsp->gp_wq); /* Memory barrier implied by wake_up() path. */ |
f41d911f8 rcu: Merge preemp... |
1507 1508 1509 |
} /* |
d3f6bad39 rcu: Rename "quie... |
1510 1511 1512 1513 1514 1515 |
* Similar to rcu_report_qs_rdp(), for which it is a helper function. * Allows quiescent states for a group of CPUs to be reported at one go * to the specified rcu_node structure, though all the CPUs in the group * must be represented by the same rcu_node structure (which need not be * a leaf rcu_node structure, though it often will be). That structure's * lock must be held upon entry, and it is released before return. |
64db4cfff "Tree RCU": scala... |
1516 1517 |
*/ static void |
d3f6bad39 rcu: Rename "quie... |
1518 1519 |
rcu_report_qs_rnp(unsigned long mask, struct rcu_state *rsp, struct rcu_node *rnp, unsigned long flags) |
64db4cfff "Tree RCU": scala... |
1520 1521 |
__releases(rnp->lock) { |
28ecd5802 rcu: Add WARN_ON_... |
1522 |
struct rcu_node *rnp_c; |
64db4cfff "Tree RCU": scala... |
1523 1524 1525 1526 1527 |
/* Walk up the rcu_node hierarchy. */ for (;;) { if (!(rnp->qsmask & mask)) { /* Our bit has already been cleared, so done. */ |
1304afb22 rcu: Convert to r... |
1528 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
1529 1530 1531 |
return; } rnp->qsmask &= ~mask; |
d4c08f2ac rcu: Add grace-pe... |
1532 1533 1534 1535 |
trace_rcu_quiescent_state_report(rsp->name, rnp->gpnum, mask, rnp->qsmask, rnp->level, rnp->grplo, rnp->grphi, !!rnp->gp_tasks); |
27f4d2805 rcu: priority boo... |
1536 |
if (rnp->qsmask != 0 || rcu_preempt_blocked_readers_cgp(rnp)) { |
64db4cfff "Tree RCU": scala... |
1537 1538 |
/* Other bits still set at this level, so done. */ |
1304afb22 rcu: Convert to r... |
1539 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
1540 1541 1542 1543 1544 1545 1546 1547 1548 |
return; } mask = rnp->grpmask; if (rnp->parent == NULL) { /* No more levels. Exit loop holding root lock. */ break; } |
1304afb22 rcu: Convert to r... |
1549 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
28ecd5802 rcu: Add WARN_ON_... |
1550 |
rnp_c = rnp; |
64db4cfff "Tree RCU": scala... |
1551 |
rnp = rnp->parent; |
1304afb22 rcu: Convert to r... |
1552 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
28ecd5802 rcu: Add WARN_ON_... |
1553 |
WARN_ON_ONCE(rnp_c->qsmask); |
64db4cfff "Tree RCU": scala... |
1554 1555 1556 1557 |
} /* * Get here if we are the last CPU to pass through a quiescent |
d3f6bad39 rcu: Rename "quie... |
1558 |
* state for this grace period. Invoke rcu_report_qs_rsp() |
f41d911f8 rcu: Merge preemp... |
1559 |
* to clean up and start the next grace period if one is needed. |
64db4cfff "Tree RCU": scala... |
1560 |
*/ |
d3f6bad39 rcu: Rename "quie... |
1561 |
rcu_report_qs_rsp(rsp, flags); /* releases rnp->lock. */ |
64db4cfff "Tree RCU": scala... |
1562 1563 1564 |
} /* |
d3f6bad39 rcu: Rename "quie... |
1565 1566 1567 1568 1569 1570 1571 |
* Record a quiescent state for the specified CPU to that CPU's rcu_data * structure. This must be either called from the specified CPU, or * called when the specified CPU is known to be offline (and when it is * also known that no other CPU is concurrently trying to help the offline * CPU). The lastcomp argument is used to make sure we are still in the * grace period of interest. We don't want to end the current grace period * based on quiescent states detected in an earlier grace period! |
64db4cfff "Tree RCU": scala... |
1572 1573 |
*/ static void |
d7d6a11e8 rcu: Simplify qui... |
1574 |
rcu_report_qs_rdp(int cpu, struct rcu_state *rsp, struct rcu_data *rdp) |
64db4cfff "Tree RCU": scala... |
1575 1576 1577 1578 1579 1580 |
{ unsigned long flags; unsigned long mask; struct rcu_node *rnp; rnp = rdp->mynode; |
1304afb22 rcu: Convert to r... |
1581 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
d7d6a11e8 rcu: Simplify qui... |
1582 1583 |
if (rdp->passed_quiesce == 0 || rdp->gpnum != rnp->gpnum || rnp->completed == rnp->gpnum) { |
64db4cfff "Tree RCU": scala... |
1584 1585 |
/* |
e4cc1f22b rcu: Simplify qui... |
1586 1587 1588 1589 |
* The grace period in which this quiescent state was * recorded has ended, so don't report it upwards. * We will instead need a new quiescent state that lies * within the current grace period. |
64db4cfff "Tree RCU": scala... |
1590 |
*/ |
e4cc1f22b rcu: Simplify qui... |
1591 |
rdp->passed_quiesce = 0; /* need qs for new gp. */ |
1304afb22 rcu: Convert to r... |
1592 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
1593 1594 1595 1596 |
return; } mask = rdp->grpmask; if ((rnp->qsmask & mask) == 0) { |
1304afb22 rcu: Convert to r... |
1597 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
1598 1599 1600 1601 1602 1603 1604 |
} else { rdp->qs_pending = 0; /* * This GP can't end until cpu checks in, so all of our * callbacks can be processed during the next GP. */ |
dc35c8934 rcu: Tag callback... |
1605 |
rcu_accelerate_cbs(rsp, rnp, rdp); |
64db4cfff "Tree RCU": scala... |
1606 |
|
d3f6bad39 rcu: Rename "quie... |
1607 |
rcu_report_qs_rnp(mask, rsp, rnp, flags); /* rlses rnp->lock */ |
64db4cfff "Tree RCU": scala... |
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 |
} } /* * Check to see if there is a new grace period of which this CPU * is not yet aware, and if so, set up local rcu_data state for it. * Otherwise, see if this CPU has just passed through its first * quiescent state for this grace period, and record that fact if so. */ static void rcu_check_quiescent_state(struct rcu_state *rsp, struct rcu_data *rdp) { /* If there is now a new grace period, record and return. */ if (check_for_new_grace_period(rsp, rdp)) return; /* * Does this CPU still need to do its part for current grace period? * If no, return and let the other CPUs do their part as well. */ if (!rdp->qs_pending) return; /* * Was there a quiescent state since the beginning of the grace * period? If no, then exit and wait for the next call. */ |
e4cc1f22b rcu: Simplify qui... |
1635 |
if (!rdp->passed_quiesce) |
64db4cfff "Tree RCU": scala... |
1636 |
return; |
d3f6bad39 rcu: Rename "quie... |
1637 1638 1639 1640 |
/* * Tell RCU we are done (but rcu_report_qs_rdp() will be the * judge of that). */ |
d7d6a11e8 rcu: Simplify qui... |
1641 |
rcu_report_qs_rdp(rdp->cpu, rsp, rdp); |
64db4cfff "Tree RCU": scala... |
1642 1643 1644 1645 1646 |
} #ifdef CONFIG_HOTPLUG_CPU /* |
b1420f1c8 rcu: Make rcu_bar... |
1647 1648 |
* Send the specified CPU's RCU callbacks to the orphanage. The * specified CPU must be offline, and the caller must hold the |
7b2e6011f rcu: Rename ->ono... |
1649 |
* ->orphan_lock. |
e74f4c456 rcu: Make hot-unp... |
1650 |
*/ |
b1420f1c8 rcu: Make rcu_bar... |
1651 1652 1653 |
static void rcu_send_cbs_to_orphanage(int cpu, struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp) |
e74f4c456 rcu: Make hot-unp... |
1654 |
{ |
3fbfbf7a3 rcu: Add callback... |
1655 1656 1657 |
/* No-CBs CPUs do not have orphanable callbacks. */ if (is_nocb_cpu(rdp->cpu)) return; |
b1420f1c8 rcu: Make rcu_bar... |
1658 1659 |
/* * Orphan the callbacks. First adjust the counts. This is safe |
abfd6e58a rcu: Fix comment ... |
1660 1661 |
* because _rcu_barrier() excludes CPU-hotplug operations, so it * cannot be running now. Thus no memory barrier is required. |
b1420f1c8 rcu: Make rcu_bar... |
1662 |
*/ |
a50c3af91 rcu: Don't make c... |
1663 |
if (rdp->nxtlist != NULL) { |
b1420f1c8 rcu: Make rcu_bar... |
1664 1665 1666 |
rsp->qlen_lazy += rdp->qlen_lazy; rsp->qlen += rdp->qlen; rdp->n_cbs_orphaned += rdp->qlen; |
a50c3af91 rcu: Don't make c... |
1667 |
rdp->qlen_lazy = 0; |
1d1fb395f rcu: Add ACCESS_O... |
1668 |
ACCESS_ONCE(rdp->qlen) = 0; |
a50c3af91 rcu: Don't make c... |
1669 1670 1671 |
} /* |
b1420f1c8 rcu: Make rcu_bar... |
1672 1673 1674 1675 1676 1677 1678 |
* Next, move those callbacks still needing a grace period to * the orphanage, where some other CPU will pick them up. * Some of the callbacks might have gone partway through a grace * period, but that is too bad. They get to start over because we * cannot assume that grace periods are synchronized across CPUs. * We don't bother updating the ->nxttail[] array yet, instead * we just reset the whole thing later on. |
a50c3af91 rcu: Don't make c... |
1679 |
*/ |
b1420f1c8 rcu: Make rcu_bar... |
1680 1681 1682 1683 |
if (*rdp->nxttail[RCU_DONE_TAIL] != NULL) { *rsp->orphan_nxttail = *rdp->nxttail[RCU_DONE_TAIL]; rsp->orphan_nxttail = rdp->nxttail[RCU_NEXT_TAIL]; *rdp->nxttail[RCU_DONE_TAIL] = NULL; |
a50c3af91 rcu: Don't make c... |
1684 1685 1686 |
} /* |
b1420f1c8 rcu: Make rcu_bar... |
1687 1688 1689 |
* Then move the ready-to-invoke callbacks to the orphanage, * where some other CPU will pick them up. These will not be * required to pass though another grace period: They are done. |
a50c3af91 rcu: Don't make c... |
1690 |
*/ |
e56014000 rcu: Simplify off... |
1691 |
if (rdp->nxtlist != NULL) { |
b1420f1c8 rcu: Make rcu_bar... |
1692 1693 |
*rsp->orphan_donetail = rdp->nxtlist; rsp->orphan_donetail = rdp->nxttail[RCU_DONE_TAIL]; |
e56014000 rcu: Simplify off... |
1694 |
} |
e74f4c456 rcu: Make hot-unp... |
1695 |
|
b1420f1c8 rcu: Make rcu_bar... |
1696 |
/* Finally, initialize the rcu_data structure's list to empty. */ |
3f5d3ea64 rcu: Consolidate ... |
1697 |
init_callback_list(rdp); |
b1420f1c8 rcu: Make rcu_bar... |
1698 1699 1700 1701 |
} /* * Adopt the RCU callbacks from the specified rcu_state structure's |
7b2e6011f rcu: Rename ->ono... |
1702 |
* orphanage. The caller must hold the ->orphan_lock. |
b1420f1c8 rcu: Make rcu_bar... |
1703 1704 1705 1706 1707 |
*/ static void rcu_adopt_orphan_cbs(struct rcu_state *rsp) { int i; struct rcu_data *rdp = __this_cpu_ptr(rsp->rda); |
3fbfbf7a3 rcu: Add callback... |
1708 1709 1710 |
/* No-CBs CPUs are handled specially. */ if (rcu_nocb_adopt_orphan_cbs(rsp, rdp)) return; |
b1420f1c8 rcu: Make rcu_bar... |
1711 1712 1713 1714 |
/* Do the accounting first. */ rdp->qlen_lazy += rsp->qlen_lazy; rdp->qlen += rsp->qlen; rdp->n_cbs_adopted += rsp->qlen; |
8f5af6f1f rcu: RCU_FAST_NO_... |
1715 1716 |
if (rsp->qlen_lazy != rsp->qlen) rcu_idle_count_callbacks_posted(); |
b1420f1c8 rcu: Make rcu_bar... |
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 |
rsp->qlen_lazy = 0; rsp->qlen = 0; /* * We do not need a memory barrier here because the only way we * can get here if there is an rcu_barrier() in flight is if * we are the task doing the rcu_barrier(). */ /* First adopt the ready-to-invoke callbacks. */ if (rsp->orphan_donelist != NULL) { *rsp->orphan_donetail = *rdp->nxttail[RCU_DONE_TAIL]; *rdp->nxttail[RCU_DONE_TAIL] = rsp->orphan_donelist; for (i = RCU_NEXT_SIZE - 1; i >= RCU_DONE_TAIL; i--) if (rdp->nxttail[i] == rdp->nxttail[RCU_DONE_TAIL]) rdp->nxttail[i] = rsp->orphan_donetail; rsp->orphan_donelist = NULL; rsp->orphan_donetail = &rsp->orphan_donelist; } /* And then adopt the callbacks that still need a grace period. */ if (rsp->orphan_nxtlist != NULL) { *rdp->nxttail[RCU_NEXT_TAIL] = rsp->orphan_nxtlist; rdp->nxttail[RCU_NEXT_TAIL] = rsp->orphan_nxttail; rsp->orphan_nxtlist = NULL; rsp->orphan_nxttail = &rsp->orphan_nxtlist; } } /* * Trace the fact that this CPU is going offline. */ static void rcu_cleanup_dying_cpu(struct rcu_state *rsp) { RCU_TRACE(unsigned long mask); RCU_TRACE(struct rcu_data *rdp = this_cpu_ptr(rsp->rda)); RCU_TRACE(struct rcu_node *rnp = rdp->mynode); RCU_TRACE(mask = rdp->grpmask); |
e56014000 rcu: Simplify off... |
1756 1757 1758 |
trace_rcu_grace_period(rsp->name, rnp->gpnum + 1 - !!(rnp->qsmask & mask), "cpuofl"); |
64db4cfff "Tree RCU": scala... |
1759 1760 1761 |
} /* |
e56014000 rcu: Simplify off... |
1762 |
* The CPU has been completely removed, and some other CPU is reporting |
b1420f1c8 rcu: Make rcu_bar... |
1763 1764 |
* this fact from process context. Do the remainder of the cleanup, * including orphaning the outgoing CPU's RCU callbacks, and also |
1331e7a1b rcu: Remove _rcu_... |
1765 1766 |
* adopting them. There can only be one CPU hotplug operation at a time, * so no other CPU can be attempting to update rcu_cpu_kthread_task. |
64db4cfff "Tree RCU": scala... |
1767 |
*/ |
e56014000 rcu: Simplify off... |
1768 |
static void rcu_cleanup_dead_cpu(int cpu, struct rcu_state *rsp) |
64db4cfff "Tree RCU": scala... |
1769 |
{ |
2036d94a7 rcu: Rework detec... |
1770 1771 1772 |
unsigned long flags; unsigned long mask; int need_report = 0; |
e56014000 rcu: Simplify off... |
1773 |
struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu); |
b1420f1c8 rcu: Make rcu_bar... |
1774 |
struct rcu_node *rnp = rdp->mynode; /* Outgoing CPU's rdp & rnp. */ |
e56014000 rcu: Simplify off... |
1775 |
|
2036d94a7 rcu: Rework detec... |
1776 |
/* Adjust any no-longer-needed kthreads. */ |
5d01bbd11 rcu: Yield simpler |
1777 |
rcu_boost_kthread_setaffinity(rnp, -1); |
2036d94a7 rcu: Rework detec... |
1778 |
|
b1420f1c8 rcu: Make rcu_bar... |
1779 |
/* Remove the dead CPU from the bitmasks in the rcu_node hierarchy. */ |
2036d94a7 rcu: Rework detec... |
1780 1781 |
/* Exclude any attempts to start a new grace period. */ |
a4fbe35a1 rcu: Grace-period... |
1782 |
mutex_lock(&rsp->onoff_mutex); |
7b2e6011f rcu: Rename ->ono... |
1783 |
raw_spin_lock_irqsave(&rsp->orphan_lock, flags); |
2036d94a7 rcu: Rework detec... |
1784 |
|
b1420f1c8 rcu: Make rcu_bar... |
1785 1786 1787 |
/* Orphan the dead CPU's callbacks, and adopt them if appropriate. */ rcu_send_cbs_to_orphanage(cpu, rsp, rnp, rdp); rcu_adopt_orphan_cbs(rsp); |
2036d94a7 rcu: Rework detec... |
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 |
/* Remove the outgoing CPU from the masks in the rcu_node hierarchy. */ mask = rdp->grpmask; /* rnp->grplo is constant. */ do { raw_spin_lock(&rnp->lock); /* irqs already disabled. */ rnp->qsmaskinit &= ~mask; if (rnp->qsmaskinit != 0) { if (rnp != rdp->mynode) raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */ break; } if (rnp == rdp->mynode) need_report = rcu_preempt_offline_tasks(rsp, rnp, rdp); else raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */ mask = rnp->grpmask; rnp = rnp->parent; } while (rnp != NULL); /* * We still hold the leaf rcu_node structure lock here, and * irqs are still disabled. The reason for this subterfuge is |
7b2e6011f rcu: Rename ->ono... |
1809 |
* because invoking rcu_report_unblock_qs_rnp() with ->orphan_lock |
2036d94a7 rcu: Rework detec... |
1810 1811 |
* held leads to deadlock. */ |
7b2e6011f rcu: Rename ->ono... |
1812 |
raw_spin_unlock(&rsp->orphan_lock); /* irqs remain disabled. */ |
2036d94a7 rcu: Rework detec... |
1813 1814 1815 1816 1817 1818 1819 |
rnp = rdp->mynode; if (need_report & RCU_OFL_TASKS_NORM_GP) rcu_report_unblock_qs_rnp(rnp, flags); else raw_spin_unlock_irqrestore(&rnp->lock, flags); if (need_report & RCU_OFL_TASKS_EXP_GP) rcu_report_exp_rnp(rsp, rnp, true); |
cf01537ec rcu: Add check fo... |
1820 1821 1822 1823 |
WARN_ONCE(rdp->qlen != 0 || rdp->nxtlist != NULL, "rcu_cleanup_dead_cpu: Callbacks on offline CPU %d: qlen=%lu, nxtlist=%p ", cpu, rdp->qlen, rdp->nxtlist); |
0d8ee37e2 rcu: Disallow cal... |
1824 1825 1826 |
init_callback_list(rdp); /* Disallow further callbacks on this CPU. */ rdp->nxttail[RCU_NEXT_TAIL] = NULL; |
a4fbe35a1 rcu: Grace-period... |
1827 |
mutex_unlock(&rsp->onoff_mutex); |
64db4cfff "Tree RCU": scala... |
1828 1829 1830 |
} #else /* #ifdef CONFIG_HOTPLUG_CPU */ |
e56014000 rcu: Simplify off... |
1831 |
static void rcu_cleanup_dying_cpu(struct rcu_state *rsp) |
e74f4c456 rcu: Make hot-unp... |
1832 1833 |
{ } |
e56014000 rcu: Simplify off... |
1834 |
static void rcu_cleanup_dead_cpu(int cpu, struct rcu_state *rsp) |
64db4cfff "Tree RCU": scala... |
1835 1836 1837 1838 1839 1840 1841 1842 1843 |
{ } #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */ /* * Invoke any RCU callbacks that have made it to the end of their grace * period. Thottle as specified by rdp->blimit. */ |
37c72e56f rcu: Prevent RCU ... |
1844 |
static void rcu_do_batch(struct rcu_state *rsp, struct rcu_data *rdp) |
64db4cfff "Tree RCU": scala... |
1845 1846 1847 |
{ unsigned long flags; struct rcu_head *next, *list, **tail; |
878d7439d rcu: Fix batch-li... |
1848 1849 |
long bl, count, count_lazy; int i; |
64db4cfff "Tree RCU": scala... |
1850 |
|
dc35c8934 rcu: Tag callback... |
1851 |
/* If no callbacks are ready, just return. */ |
29c00b4a1 rcu: Add event-tr... |
1852 |
if (!cpu_has_callbacks_ready_to_invoke(rdp)) { |
486e25934 rcu: Avoid waking... |
1853 |
trace_rcu_batch_start(rsp->name, rdp->qlen_lazy, rdp->qlen, 0); |
4968c300e rcu: Augment rcu_... |
1854 1855 1856 |
trace_rcu_batch_end(rsp->name, 0, !!ACCESS_ONCE(rdp->nxtlist), need_resched(), is_idle_task(current), rcu_is_callbacks_kthread()); |
64db4cfff "Tree RCU": scala... |
1857 |
return; |
29c00b4a1 rcu: Add event-tr... |
1858 |
} |
64db4cfff "Tree RCU": scala... |
1859 1860 1861 1862 1863 1864 |
/* * Extract the list of ready callbacks, disabling to prevent * races with call_rcu() from interrupt handlers. */ local_irq_save(flags); |
8146c4e2e rcu: Check for ca... |
1865 |
WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); |
29c00b4a1 rcu: Add event-tr... |
1866 |
bl = rdp->blimit; |
486e25934 rcu: Avoid waking... |
1867 |
trace_rcu_batch_start(rsp->name, rdp->qlen_lazy, rdp->qlen, bl); |
64db4cfff "Tree RCU": scala... |
1868 1869 1870 1871 |
list = rdp->nxtlist; rdp->nxtlist = *rdp->nxttail[RCU_DONE_TAIL]; *rdp->nxttail[RCU_DONE_TAIL] = NULL; tail = rdp->nxttail[RCU_DONE_TAIL]; |
b41772abe rcu: Stop rcu_do_... |
1872 1873 1874 |
for (i = RCU_NEXT_SIZE - 1; i >= 0; i--) if (rdp->nxttail[i] == rdp->nxttail[RCU_DONE_TAIL]) rdp->nxttail[i] = &rdp->nxtlist; |
64db4cfff "Tree RCU": scala... |
1875 1876 1877 |
local_irq_restore(flags); /* Invoke callbacks. */ |
486e25934 rcu: Avoid waking... |
1878 |
count = count_lazy = 0; |
64db4cfff "Tree RCU": scala... |
1879 1880 1881 |
while (list) { next = list->next; prefetch(next); |
551d55a94 tree/tiny rcu: Ad... |
1882 |
debug_rcu_head_unqueue(list); |
486e25934 rcu: Avoid waking... |
1883 1884 |
if (__rcu_reclaim(rsp->name, list)) count_lazy++; |
64db4cfff "Tree RCU": scala... |
1885 |
list = next; |
dff1672d9 rcu: Keep invokin... |
1886 1887 1888 1889 |
/* Stop only if limit reached and CPU has something to do. */ if (++count >= bl && (need_resched() || (!is_idle_task(current) && !rcu_is_callbacks_kthread()))) |
64db4cfff "Tree RCU": scala... |
1890 1891 1892 1893 |
break; } local_irq_save(flags); |
4968c300e rcu: Augment rcu_... |
1894 1895 1896 |
trace_rcu_batch_end(rsp->name, count, !!list, need_resched(), is_idle_task(current), rcu_is_callbacks_kthread()); |
64db4cfff "Tree RCU": scala... |
1897 1898 |
/* Update count, and requeue any remaining callbacks. */ |
64db4cfff "Tree RCU": scala... |
1899 1900 1901 |
if (list != NULL) { *tail = rdp->nxtlist; rdp->nxtlist = list; |
b41772abe rcu: Stop rcu_do_... |
1902 1903 1904 |
for (i = 0; i < RCU_NEXT_SIZE; i++) if (&rdp->nxtlist == rdp->nxttail[i]) rdp->nxttail[i] = tail; |
64db4cfff "Tree RCU": scala... |
1905 1906 1907 |
else break; } |
b1420f1c8 rcu: Make rcu_bar... |
1908 1909 |
smp_mb(); /* List handling before counting for rcu_barrier(). */ rdp->qlen_lazy -= count_lazy; |
1d1fb395f rcu: Add ACCESS_O... |
1910 |
ACCESS_ONCE(rdp->qlen) -= count; |
b1420f1c8 rcu: Make rcu_bar... |
1911 |
rdp->n_cbs_invoked += count; |
64db4cfff "Tree RCU": scala... |
1912 1913 1914 1915 |
/* Reinstate batch limit if we have worked down the excess. */ if (rdp->blimit == LONG_MAX && rdp->qlen <= qlowmark) rdp->blimit = blimit; |
37c72e56f rcu: Prevent RCU ... |
1916 1917 1918 1919 1920 1921 |
/* Reset ->qlen_last_fqs_check trigger if enough CBs have drained. */ if (rdp->qlen == 0 && rdp->qlen_last_fqs_check != 0) { rdp->qlen_last_fqs_check = 0; rdp->n_force_qs_snap = rsp->n_force_qs; } else if (rdp->qlen < rdp->qlen_last_fqs_check - qhimark) rdp->qlen_last_fqs_check = rdp->qlen; |
cfca92797 rcu: Introduce ch... |
1922 |
WARN_ON_ONCE((rdp->nxtlist == NULL) != (rdp->qlen == 0)); |
37c72e56f rcu: Prevent RCU ... |
1923 |
|
64db4cfff "Tree RCU": scala... |
1924 |
local_irq_restore(flags); |
e0f23060a rcu: Update comme... |
1925 |
/* Re-invoke RCU core processing if there are callbacks remaining. */ |
64db4cfff "Tree RCU": scala... |
1926 |
if (cpu_has_callbacks_ready_to_invoke(rdp)) |
a46e0899e rcu: use softirq ... |
1927 |
invoke_rcu_core(); |
64db4cfff "Tree RCU": scala... |
1928 1929 1930 1931 1932 |
} /* * Check to see if this CPU is in a non-context-switch quiescent state * (user mode or idle loop for rcu, non-softirq execution for rcu_bh). |
e0f23060a rcu: Update comme... |
1933 |
* Also schedule RCU core processing. |
64db4cfff "Tree RCU": scala... |
1934 |
* |
9b2e4f188 rcu: Track idlene... |
1935 |
* This function must be called from hardirq context. It is normally |
64db4cfff "Tree RCU": scala... |
1936 1937 1938 1939 1940 |
* invoked from the scheduling-clock interrupt. If rcu_pending returns * false, there is no point in invoking rcu_check_callbacks(). */ void rcu_check_callbacks(int cpu, int user) { |
300df91ca rcu: Event-trace ... |
1941 |
trace_rcu_utilization("Start scheduler-tick"); |
a858af287 rcu: Print schedu... |
1942 |
increment_cpu_stall_ticks(); |
9b2e4f188 rcu: Track idlene... |
1943 |
if (user || rcu_is_cpu_rrupt_from_idle()) { |
64db4cfff "Tree RCU": scala... |
1944 1945 1946 1947 1948 |
/* * Get here if this CPU took its interrupt from user * mode or from the idle loop, and if this is not a * nested interrupt. In this case, the CPU is in |
d6714c22b rcu: Renamings to... |
1949 |
* a quiescent state, so note it. |
64db4cfff "Tree RCU": scala... |
1950 1951 |
* * No memory barrier is required here because both |
d6714c22b rcu: Renamings to... |
1952 1953 1954 |
* rcu_sched_qs() and rcu_bh_qs() reference only CPU-local * variables that other CPUs neither access nor modify, * at least not while the corresponding CPU is online. |
64db4cfff "Tree RCU": scala... |
1955 |
*/ |
d6714c22b rcu: Renamings to... |
1956 1957 |
rcu_sched_qs(cpu); rcu_bh_qs(cpu); |
64db4cfff "Tree RCU": scala... |
1958 1959 1960 1961 1962 1963 1964 |
} else if (!in_softirq()) { /* * Get here if this CPU did not take its interrupt from * softirq, in other words, if it is not interrupting * a rcu_bh read-side critical section. This is an _bh |
d6714c22b rcu: Renamings to... |
1965 |
* critical section, so note it. |
64db4cfff "Tree RCU": scala... |
1966 |
*/ |
d6714c22b rcu: Renamings to... |
1967 |
rcu_bh_qs(cpu); |
64db4cfff "Tree RCU": scala... |
1968 |
} |
f41d911f8 rcu: Merge preemp... |
1969 |
rcu_preempt_check_callbacks(cpu); |
d21670aca rcu: reduce the n... |
1970 |
if (rcu_pending(cpu)) |
a46e0899e rcu: use softirq ... |
1971 |
invoke_rcu_core(); |
300df91ca rcu: Event-trace ... |
1972 |
trace_rcu_utilization("End scheduler-tick"); |
64db4cfff "Tree RCU": scala... |
1973 |
} |
64db4cfff "Tree RCU": scala... |
1974 1975 1976 |
/* * Scan the leaf rcu_node structures, processing dyntick state for any that * have not yet encountered a quiescent state, using the function specified. |
27f4d2805 rcu: priority boo... |
1977 1978 |
* Also initiate boosting for any threads blocked on the root rcu_node. * |
ee47eb9f4 rcu: Remove leg o... |
1979 |
* The caller must have suppressed start of new grace periods. |
64db4cfff "Tree RCU": scala... |
1980 |
*/ |
45f014c52 rcu: Remove redun... |
1981 |
static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *)) |
64db4cfff "Tree RCU": scala... |
1982 1983 1984 1985 1986 |
{ unsigned long bit; int cpu; unsigned long flags; unsigned long mask; |
a0b6c9a78 rcu: Clean up cod... |
1987 |
struct rcu_node *rnp; |
64db4cfff "Tree RCU": scala... |
1988 |
|
a0b6c9a78 rcu: Clean up cod... |
1989 |
rcu_for_each_leaf_node(rsp, rnp) { |
b4be093fe rcu: Allow RCU qu... |
1990 |
cond_resched(); |
64db4cfff "Tree RCU": scala... |
1991 |
mask = 0; |
1304afb22 rcu: Convert to r... |
1992 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
ee47eb9f4 rcu: Remove leg o... |
1993 |
if (!rcu_gp_in_progress(rsp)) { |
1304afb22 rcu: Convert to r... |
1994 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
0f10dc826 rcu: Eliminate rc... |
1995 |
return; |
64db4cfff "Tree RCU": scala... |
1996 |
} |
a0b6c9a78 rcu: Clean up cod... |
1997 |
if (rnp->qsmask == 0) { |
1217ed1ba rcu: permit rcu_r... |
1998 |
rcu_initiate_boost(rnp, flags); /* releases rnp->lock */ |
64db4cfff "Tree RCU": scala... |
1999 2000 |
continue; } |
a0b6c9a78 rcu: Clean up cod... |
2001 |
cpu = rnp->grplo; |
64db4cfff "Tree RCU": scala... |
2002 |
bit = 1; |
a0b6c9a78 rcu: Clean up cod... |
2003 |
for (; cpu <= rnp->grphi; cpu++, bit <<= 1) { |
394f99a90 rcu: simplify the... |
2004 2005 |
if ((rnp->qsmask & bit) != 0 && f(per_cpu_ptr(rsp->rda, cpu))) |
64db4cfff "Tree RCU": scala... |
2006 2007 |
mask |= bit; } |
45f014c52 rcu: Remove redun... |
2008 |
if (mask != 0) { |
64db4cfff "Tree RCU": scala... |
2009 |
|
d3f6bad39 rcu: Rename "quie... |
2010 2011 |
/* rcu_report_qs_rnp() releases rnp->lock. */ rcu_report_qs_rnp(mask, rsp, rnp, flags); |
64db4cfff "Tree RCU": scala... |
2012 2013 |
continue; } |
1304afb22 rcu: Convert to r... |
2014 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
2015 |
} |
27f4d2805 rcu: priority boo... |
2016 |
rnp = rcu_get_root(rsp); |
1217ed1ba rcu: permit rcu_r... |
2017 2018 2019 2020 |
if (rnp->qsmask == 0) { raw_spin_lock_irqsave(&rnp->lock, flags); rcu_initiate_boost(rnp, flags); /* releases rnp->lock. */ } |
64db4cfff "Tree RCU": scala... |
2021 2022 2023 2024 2025 2026 |
} /* * Force quiescent states on reluctant CPUs, and also detect which * CPUs are in dyntick-idle mode. */ |
4cdfc175c rcu: Move quiesce... |
2027 |
static void force_quiescent_state(struct rcu_state *rsp) |
64db4cfff "Tree RCU": scala... |
2028 2029 |
{ unsigned long flags; |
394f2769a rcu: Prevent forc... |
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 |
bool ret; struct rcu_node *rnp; struct rcu_node *rnp_old = NULL; /* Funnel through hierarchy to reduce memory contention. */ rnp = per_cpu_ptr(rsp->rda, raw_smp_processor_id())->mynode; for (; rnp != NULL; rnp = rnp->parent) { ret = (ACCESS_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || !raw_spin_trylock(&rnp->fqslock); if (rnp_old != NULL) raw_spin_unlock(&rnp_old->fqslock); if (ret) { rsp->n_force_qs_lh++; return; } rnp_old = rnp; } /* rnp_old == rcu_get_root(rsp), rnp == NULL. */ |
64db4cfff "Tree RCU": scala... |
2048 |
|
394f2769a rcu: Prevent forc... |
2049 2050 2051 2052 2053 2054 |
/* Reached the root of the rcu_node tree, acquire lock. */ raw_spin_lock_irqsave(&rnp_old->lock, flags); raw_spin_unlock(&rnp_old->fqslock); if (ACCESS_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) { rsp->n_force_qs_lh++; raw_spin_unlock_irqrestore(&rnp_old->lock, flags); |
4cdfc175c rcu: Move quiesce... |
2055 |
return; /* Someone beat us to it. */ |
46a1e34ed rcu: Make force_q... |
2056 |
} |
4cdfc175c rcu: Move quiesce... |
2057 |
rsp->gp_flags |= RCU_GP_FLAG_FQS; |
394f2769a rcu: Prevent forc... |
2058 |
raw_spin_unlock_irqrestore(&rnp_old->lock, flags); |
4cdfc175c rcu: Move quiesce... |
2059 |
wake_up(&rsp->gp_wq); /* Memory barrier implied by wake_up() path. */ |
64db4cfff "Tree RCU": scala... |
2060 |
} |
64db4cfff "Tree RCU": scala... |
2061 |
/* |
e0f23060a rcu: Update comme... |
2062 2063 2064 |
* This does the RCU core processing work for the specified rcu_state * and rcu_data structures. This may be called only from the CPU to * whom the rdp belongs. |
64db4cfff "Tree RCU": scala... |
2065 2066 |
*/ static void |
1bca8cf1a rcu: Remove unnee... |
2067 |
__rcu_process_callbacks(struct rcu_state *rsp) |
64db4cfff "Tree RCU": scala... |
2068 2069 |
{ unsigned long flags; |
1bca8cf1a rcu: Remove unnee... |
2070 |
struct rcu_data *rdp = __this_cpu_ptr(rsp->rda); |
64db4cfff "Tree RCU": scala... |
2071 |
|
2e5975580 rcu: Simplify RCU... |
2072 |
WARN_ON_ONCE(rdp->beenonline == 0); |
dc35c8934 rcu: Tag callback... |
2073 |
/* Handle the end of a grace period that some other CPU ended. */ |
64db4cfff "Tree RCU": scala... |
2074 2075 2076 2077 2078 2079 |
rcu_process_gp_end(rsp, rdp); /* Update RCU state based on any recent quiescent states. */ rcu_check_quiescent_state(rsp, rdp); /* Does this CPU require a not-yet-started grace period? */ |
dc35c8934 rcu: Tag callback... |
2080 |
local_irq_save(flags); |
64db4cfff "Tree RCU": scala... |
2081 |
if (cpu_needs_another_gp(rsp, rdp)) { |
dc35c8934 rcu: Tag callback... |
2082 |
raw_spin_lock(&rcu_get_root(rsp)->lock); /* irqs disabled. */ |
64db4cfff "Tree RCU": scala... |
2083 |
rcu_start_gp(rsp, flags); /* releases above lock */ |
dc35c8934 rcu: Tag callback... |
2084 2085 |
} else { local_irq_restore(flags); |
64db4cfff "Tree RCU": scala... |
2086 2087 2088 |
} /* If there are callbacks ready, invoke them. */ |
09223371d rcu: Use softirq ... |
2089 |
if (cpu_has_callbacks_ready_to_invoke(rdp)) |
a46e0899e rcu: use softirq ... |
2090 |
invoke_rcu_callbacks(rsp, rdp); |
09223371d rcu: Use softirq ... |
2091 |
} |
64db4cfff "Tree RCU": scala... |
2092 |
/* |
e0f23060a rcu: Update comme... |
2093 |
* Do RCU core processing for the current CPU. |
64db4cfff "Tree RCU": scala... |
2094 |
*/ |
09223371d rcu: Use softirq ... |
2095 |
static void rcu_process_callbacks(struct softirq_action *unused) |
64db4cfff "Tree RCU": scala... |
2096 |
{ |
6ce75a232 rcu: Introduce fo... |
2097 |
struct rcu_state *rsp; |
bfa00b4c4 rcu: Prevent offl... |
2098 2099 |
if (cpu_is_offline(smp_processor_id())) return; |
300df91ca rcu: Event-trace ... |
2100 |
trace_rcu_utilization("Start RCU core"); |
6ce75a232 rcu: Introduce fo... |
2101 2102 |
for_each_rcu_flavor(rsp) __rcu_process_callbacks(rsp); |
300df91ca rcu: Event-trace ... |
2103 |
trace_rcu_utilization("End RCU core"); |
64db4cfff "Tree RCU": scala... |
2104 |
} |
a26ac2455 rcu: move TREE_RC... |
2105 |
/* |
e0f23060a rcu: Update comme... |
2106 2107 2108 2109 2110 |
* Schedule RCU callback invocation. If the specified type of RCU * does not support RCU priority boosting, just do a direct call, * otherwise wake up the per-CPU kernel kthread. Note that because we * are running on the current CPU with interrupts disabled, the * rcu_cpu_kthread_task cannot disappear out from under us. |
a26ac2455 rcu: move TREE_RC... |
2111 |
*/ |
a46e0899e rcu: use softirq ... |
2112 |
static void invoke_rcu_callbacks(struct rcu_state *rsp, struct rcu_data *rdp) |
a26ac2455 rcu: move TREE_RC... |
2113 |
{ |
b0d304172 rcu: Prevent RCU ... |
2114 2115 |
if (unlikely(!ACCESS_ONCE(rcu_scheduler_fully_active))) return; |
a46e0899e rcu: use softirq ... |
2116 2117 |
if (likely(!rsp->boost)) { rcu_do_batch(rsp, rdp); |
a26ac2455 rcu: move TREE_RC... |
2118 2119 |
return; } |
a46e0899e rcu: use softirq ... |
2120 |
invoke_rcu_callbacks_kthread(); |
a26ac2455 rcu: move TREE_RC... |
2121 |
} |
a46e0899e rcu: use softirq ... |
2122 |
static void invoke_rcu_core(void) |
09223371d rcu: Use softirq ... |
2123 2124 2125 |
{ raise_softirq(RCU_SOFTIRQ); } |
29154c57e rcu: Split RCU co... |
2126 2127 2128 2129 2130 |
/* * Handle any core-RCU processing required by a call_rcu() invocation. */ static void __call_rcu_core(struct rcu_state *rsp, struct rcu_data *rdp, struct rcu_head *head, unsigned long flags) |
64db4cfff "Tree RCU": scala... |
2131 |
{ |
62fde6edf rcu: Make __call_... |
2132 2133 2134 2135 |
/* * If called from an extended quiescent state, invoke the RCU * core in order to force a re-evaluation of RCU's idleness. */ |
a16b7a693 rcu: Prevent __ca... |
2136 |
if (rcu_is_cpu_idle() && cpu_online(smp_processor_id())) |
62fde6edf rcu: Make __call_... |
2137 |
invoke_rcu_core(); |
a16b7a693 rcu: Prevent __ca... |
2138 |
/* If interrupts were disabled or CPU offline, don't invoke RCU core. */ |
29154c57e rcu: Split RCU co... |
2139 |
if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) |
2655d57ef rcu: prevent call... |
2140 |
return; |
64db4cfff "Tree RCU": scala... |
2141 |
|
37c72e56f rcu: Prevent RCU ... |
2142 2143 2144 2145 2146 2147 2148 |
/* * Force the grace period if too many callbacks or too long waiting. * Enforce hysteresis, and don't invoke force_quiescent_state() * if some other CPU has recently done so. Also, don't bother * invoking force_quiescent_state() if the newly enqueued callback * is the only one waiting for a grace period to complete. */ |
2655d57ef rcu: prevent call... |
2149 |
if (unlikely(rdp->qlen > rdp->qlen_last_fqs_check + qhimark)) { |
b52573d27 rcu: reduce __cal... |
2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 |
/* Are we ignoring a completed grace period? */ rcu_process_gp_end(rsp, rdp); check_for_new_grace_period(rsp, rdp); /* Start a new grace period if one not already started. */ if (!rcu_gp_in_progress(rsp)) { unsigned long nestflag; struct rcu_node *rnp_root = rcu_get_root(rsp); raw_spin_lock_irqsave(&rnp_root->lock, nestflag); rcu_start_gp(rsp, nestflag); /* rlses rnp_root->lock */ } else { /* Give the grace period a kick. */ rdp->blimit = LONG_MAX; if (rsp->n_force_qs == rdp->n_force_qs_snap && *rdp->nxttail[RCU_DONE_TAIL] != head) |
4cdfc175c rcu: Move quiesce... |
2167 |
force_quiescent_state(rsp); |
b52573d27 rcu: reduce __cal... |
2168 2169 2170 |
rdp->n_force_qs_snap = rsp->n_force_qs; rdp->qlen_last_fqs_check = rdp->qlen; } |
4cdfc175c rcu: Move quiesce... |
2171 |
} |
29154c57e rcu: Split RCU co... |
2172 |
} |
3fbfbf7a3 rcu: Add callback... |
2173 2174 2175 2176 2177 2178 |
/* * Helper function for call_rcu() and friends. The cpu argument will * normally be -1, indicating "currently running CPU". It may specify * a CPU only if that CPU is a no-CBs CPU. Currently, only _rcu_barrier() * is expected to specify a CPU. */ |
64db4cfff "Tree RCU": scala... |
2179 2180 |
static void __call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu), |
3fbfbf7a3 rcu: Add callback... |
2181 |
struct rcu_state *rsp, int cpu, bool lazy) |
64db4cfff "Tree RCU": scala... |
2182 2183 2184 |
{ unsigned long flags; struct rcu_data *rdp; |
0bb7b59d6 rcu: Add diagnost... |
2185 |
WARN_ON_ONCE((unsigned long)head & 0x3); /* Misaligned rcu_head! */ |
551d55a94 tree/tiny rcu: Ad... |
2186 |
debug_rcu_head_queue(head); |
64db4cfff "Tree RCU": scala... |
2187 2188 |
head->func = func; head->next = NULL; |
64db4cfff "Tree RCU": scala... |
2189 2190 2191 2192 2193 2194 2195 |
/* * Opportunistically note grace-period endings and beginnings. * Note that we might see a beginning right after we see an * end, but never vice versa, since this CPU has to pass through * a quiescent state betweentimes. */ local_irq_save(flags); |
394f99a90 rcu: simplify the... |
2196 |
rdp = this_cpu_ptr(rsp->rda); |
64db4cfff "Tree RCU": scala... |
2197 2198 |
/* Add the callback to our list. */ |
3fbfbf7a3 rcu: Add callback... |
2199 2200 2201 2202 2203 2204 2205 |
if (unlikely(rdp->nxttail[RCU_NEXT_TAIL] == NULL) || cpu != -1) { int offline; if (cpu != -1) rdp = per_cpu_ptr(rsp->rda, cpu); offline = !__call_rcu_nocb(rdp, head, lazy); WARN_ON_ONCE(offline); |
0d8ee37e2 rcu: Disallow cal... |
2206 |
/* _call_rcu() is illegal on offline CPU; leak the callback. */ |
0d8ee37e2 rcu: Disallow cal... |
2207 2208 2209 |
local_irq_restore(flags); return; } |
29154c57e rcu: Split RCU co... |
2210 |
ACCESS_ONCE(rdp->qlen)++; |
486e25934 rcu: Avoid waking... |
2211 2212 |
if (lazy) rdp->qlen_lazy++; |
c57afe80d rcu: Make RCU_FAS... |
2213 2214 |
else rcu_idle_count_callbacks_posted(); |
b1420f1c8 rcu: Make rcu_bar... |
2215 2216 2217 |
smp_mb(); /* Count before adding callback for rcu_barrier(). */ *rdp->nxttail[RCU_NEXT_TAIL] = head; rdp->nxttail[RCU_NEXT_TAIL] = &head->next; |
2655d57ef rcu: prevent call... |
2218 |
|
d4c08f2ac rcu: Add grace-pe... |
2219 2220 |
if (__is_kfree_rcu_offset((unsigned long)func)) trace_rcu_kfree_callback(rsp->name, head, (unsigned long)func, |
486e25934 rcu: Avoid waking... |
2221 |
rdp->qlen_lazy, rdp->qlen); |
d4c08f2ac rcu: Add grace-pe... |
2222 |
else |
486e25934 rcu: Avoid waking... |
2223 |
trace_rcu_callback(rsp->name, head, rdp->qlen_lazy, rdp->qlen); |
d4c08f2ac rcu: Add grace-pe... |
2224 |
|
29154c57e rcu: Split RCU co... |
2225 2226 |
/* Go handle any RCU core processing required. */ __call_rcu_core(rsp, rdp, head, flags); |
64db4cfff "Tree RCU": scala... |
2227 2228 2229 2230 |
local_irq_restore(flags); } /* |
d6714c22b rcu: Renamings to... |
2231 |
* Queue an RCU-sched callback for invocation after a grace period. |
64db4cfff "Tree RCU": scala... |
2232 |
*/ |
d6714c22b rcu: Renamings to... |
2233 |
void call_rcu_sched(struct rcu_head *head, void (*func)(struct rcu_head *rcu)) |
64db4cfff "Tree RCU": scala... |
2234 |
{ |
3fbfbf7a3 rcu: Add callback... |
2235 |
__call_rcu(head, func, &rcu_sched_state, -1, 0); |
64db4cfff "Tree RCU": scala... |
2236 |
} |
d6714c22b rcu: Renamings to... |
2237 |
EXPORT_SYMBOL_GPL(call_rcu_sched); |
64db4cfff "Tree RCU": scala... |
2238 2239 |
/* |
486e25934 rcu: Avoid waking... |
2240 |
* Queue an RCU callback for invocation after a quicker grace period. |
64db4cfff "Tree RCU": scala... |
2241 2242 2243 |
*/ void call_rcu_bh(struct rcu_head *head, void (*func)(struct rcu_head *rcu)) { |
3fbfbf7a3 rcu: Add callback... |
2244 |
__call_rcu(head, func, &rcu_bh_state, -1, 0); |
64db4cfff "Tree RCU": scala... |
2245 2246 |
} EXPORT_SYMBOL_GPL(call_rcu_bh); |
6d8133919 rcu: Document why... |
2247 2248 2249 2250 2251 2252 2253 2254 |
/* * Because a context switch is a grace period for RCU-sched and RCU-bh, * any blocking grace-period wait automatically implies a grace period * if there is only one CPU online at any point time during execution * of either synchronize_sched() or synchronize_rcu_bh(). It is OK to * occasionally incorrectly indicate that there are multiple CPUs online * when there was in fact only one the whole time, as this just adds * some overhead: RCU still operates correctly. |
6d8133919 rcu: Document why... |
2255 2256 2257 |
*/ static inline int rcu_blocking_is_gp(void) { |
95f0c1de3 rcu: Disable pree... |
2258 |
int ret; |
6d8133919 rcu: Document why... |
2259 |
might_sleep(); /* Check for RCU read-side critical section. */ |
95f0c1de3 rcu: Disable pree... |
2260 2261 2262 2263 |
preempt_disable(); ret = num_online_cpus() <= 1; preempt_enable(); return ret; |
6d8133919 rcu: Document why... |
2264 |
} |
6ebb237be rcu: Re-arrange c... |
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 |
/** * synchronize_sched - wait until an rcu-sched grace period has elapsed. * * Control will return to the caller some time after a full rcu-sched * grace period has elapsed, in other words after all currently executing * rcu-sched read-side critical sections have completed. These read-side * critical sections are delimited by rcu_read_lock_sched() and * rcu_read_unlock_sched(), and may be nested. Note that preempt_disable(), * local_irq_disable(), and so on may be used in place of * rcu_read_lock_sched(). * * This means that all preempt_disable code sequences, including NMI and |
f0a0e6f28 rcu: Clarify memo... |
2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 |
* non-threaded hardware-interrupt handlers, in progress on entry will * have completed before this primitive returns. However, this does not * guarantee that softirq handlers will have completed, since in some * kernels, these handlers can run in process context, and can block. * * Note that this guarantee implies further memory-ordering guarantees. * On systems with more than one CPU, when synchronize_sched() returns, * each CPU is guaranteed to have executed a full memory barrier since the * end of its last RCU-sched read-side critical section whose beginning * preceded the call to synchronize_sched(). In addition, each CPU having * an RCU read-side critical section that extends beyond the return from * synchronize_sched() is guaranteed to have executed a full memory barrier * after the beginning of synchronize_sched() and before the beginning of * that RCU read-side critical section. Note that these guarantees include * CPUs that are offline, idle, or executing in user mode, as well as CPUs * that are executing in the kernel. * * Furthermore, if CPU A invoked synchronize_sched(), which returned * to its caller on CPU B, then both CPU A and CPU B are guaranteed * to have executed a full memory barrier during the execution of * synchronize_sched() -- even if CPU A and CPU B are the same CPU (but * again only if the system has more than one CPU). |
6ebb237be rcu: Re-arrange c... |
2299 2300 2301 2302 2303 2304 2305 2306 2307 |
* * This primitive provides the guarantees made by the (now removed) * synchronize_kernel() API. In contrast, synchronize_rcu() only * guarantees that rcu_read_lock() sections will have completed. * In "classic RCU", these two guarantees happen to be one and * the same, but can differ in realtime RCU implementations. */ void synchronize_sched(void) { |
fe15d706c rcu: Add lockdep-... |
2308 2309 2310 2311 |
rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map) && !lock_is_held(&rcu_lock_map) && !lock_is_held(&rcu_sched_lock_map), "Illegal synchronize_sched() in RCU-sched read-side critical section"); |
6ebb237be rcu: Re-arrange c... |
2312 2313 |
if (rcu_blocking_is_gp()) return; |
3705b88db rcu: Add a module... |
2314 2315 2316 2317 |
if (rcu_expedited) synchronize_sched_expedited(); else wait_rcu_gp(call_rcu_sched); |
6ebb237be rcu: Re-arrange c... |
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 |
} EXPORT_SYMBOL_GPL(synchronize_sched); /** * synchronize_rcu_bh - wait until an rcu_bh grace period has elapsed. * * Control will return to the caller some time after a full rcu_bh grace * period has elapsed, in other words after all currently executing rcu_bh * read-side critical sections have completed. RCU read-side critical * sections are delimited by rcu_read_lock_bh() and rcu_read_unlock_bh(), * and may be nested. |
f0a0e6f28 rcu: Clarify memo... |
2329 2330 2331 |
* * See the description of synchronize_sched() for more detailed information * on memory ordering guarantees. |
6ebb237be rcu: Re-arrange c... |
2332 2333 2334 |
*/ void synchronize_rcu_bh(void) { |
fe15d706c rcu: Add lockdep-... |
2335 2336 2337 2338 |
rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map) && !lock_is_held(&rcu_lock_map) && !lock_is_held(&rcu_sched_lock_map), "Illegal synchronize_rcu_bh() in RCU-bh read-side critical section"); |
6ebb237be rcu: Re-arrange c... |
2339 2340 |
if (rcu_blocking_is_gp()) return; |
3705b88db rcu: Add a module... |
2341 2342 2343 2344 |
if (rcu_expedited) synchronize_rcu_bh_expedited(); else wait_rcu_gp(call_rcu_bh); |
6ebb237be rcu: Re-arrange c... |
2345 2346 |
} EXPORT_SYMBOL_GPL(synchronize_rcu_bh); |
3d3b7db0a rcu: Move synchro... |
2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 |
static int synchronize_sched_expedited_cpu_stop(void *data) { /* * There must be a full memory barrier on each affected CPU * between the time that try_stop_cpus() is called and the * time that it returns. * * In the current initial implementation of cpu_stop, the * above condition is already met when the control reaches * this point and the following smp_mb() is not strictly * necessary. Do smp_mb() anyway for documentation and * robustness against future implementation changes. */ smp_mb(); /* See above comment block. */ return 0; } |
236fefafe rcu: Call out dan... |
2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 |
/** * synchronize_sched_expedited - Brute-force RCU-sched grace period * * Wait for an RCU-sched grace period to elapse, but use a "big hammer" * approach to force the grace period to end quickly. This consumes * significant time on all CPUs and is unfriendly to real-time workloads, * so is thus not recommended for any sort of common-case code. In fact, * if you are using synchronize_sched_expedited() in a loop, please * restructure your code to batch your updates, and then use a single * synchronize_sched() instead. |
3d3b7db0a rcu: Move synchro... |
2373 |
* |
236fefafe rcu: Call out dan... |
2374 2375 2376 2377 |
* Note that it is illegal to call this function while holding any lock * that is acquired by a CPU-hotplug notifier. And yes, it is also illegal * to call this function from a CPU-hotplug notifier. Failing to observe * these restriction will result in deadlock. |
3d3b7db0a rcu: Move synchro... |
2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 |
* * This implementation can be thought of as an application of ticket * locking to RCU, with sync_sched_expedited_started and * sync_sched_expedited_done taking on the roles of the halves * of the ticket-lock word. Each task atomically increments * sync_sched_expedited_started upon entry, snapshotting the old value, * then attempts to stop all the CPUs. If this succeeds, then each * CPU will have executed a context switch, resulting in an RCU-sched * grace period. We are then done, so we use atomic_cmpxchg() to * update sync_sched_expedited_done to match our snapshot -- but * only if someone else has not already advanced past our snapshot. * * On the other hand, if try_stop_cpus() fails, we check the value * of sync_sched_expedited_done. If it has advanced past our * initial snapshot, then someone else must have forced a grace period * some time after we took our snapshot. In this case, our work is * done for us, and we can simply return. Otherwise, we try again, * but keep our initial snapshot for purposes of checking for someone * doing our work for us. * * If we fail too many times in a row, we fall back to synchronize_sched(). */ void synchronize_sched_expedited(void) { |
1924bcb02 rcu: Avoid counte... |
2402 2403 |
long firstsnap, s, snap; int trycount = 0; |
40694d664 rcu: Move synchro... |
2404 |
struct rcu_state *rsp = &rcu_sched_state; |
3d3b7db0a rcu: Move synchro... |
2405 |
|
1924bcb02 rcu: Avoid counte... |
2406 2407 2408 2409 2410 2411 2412 2413 |
/* * If we are in danger of counter wrap, just do synchronize_sched(). * By allowing sync_sched_expedited_started to advance no more than * ULONG_MAX/8 ahead of sync_sched_expedited_done, we are ensuring * that more than 3.5 billion CPUs would be required to force a * counter wrap on a 32-bit system. Quite a few more CPUs would of * course be required on a 64-bit system. */ |
40694d664 rcu: Move synchro... |
2414 2415 |
if (ULONG_CMP_GE((ulong)atomic_long_read(&rsp->expedited_start), (ulong)atomic_long_read(&rsp->expedited_done) + |
1924bcb02 rcu: Avoid counte... |
2416 2417 |
ULONG_MAX / 8)) { synchronize_sched(); |
a30489c52 rcu: Instrument s... |
2418 |
atomic_long_inc(&rsp->expedited_wrap); |
1924bcb02 rcu: Avoid counte... |
2419 2420 |
return; } |
3d3b7db0a rcu: Move synchro... |
2421 |
|
1924bcb02 rcu: Avoid counte... |
2422 2423 2424 2425 |
/* * Take a ticket. Note that atomic_inc_return() implies a * full memory barrier. */ |
40694d664 rcu: Move synchro... |
2426 |
snap = atomic_long_inc_return(&rsp->expedited_start); |
1924bcb02 rcu: Avoid counte... |
2427 |
firstsnap = snap; |
3d3b7db0a rcu: Move synchro... |
2428 |
get_online_cpus(); |
1cc85961e rcu: Stop spuriou... |
2429 |
WARN_ON_ONCE(cpu_is_offline(raw_smp_processor_id())); |
3d3b7db0a rcu: Move synchro... |
2430 2431 2432 2433 2434 2435 2436 2437 2438 |
/* * Each pass through the following loop attempts to force a * context switch on each CPU. */ while (try_stop_cpus(cpu_online_mask, synchronize_sched_expedited_cpu_stop, NULL) == -EAGAIN) { put_online_cpus(); |
a30489c52 rcu: Instrument s... |
2439 |
atomic_long_inc(&rsp->expedited_tryfail); |
3d3b7db0a rcu: Move synchro... |
2440 |
|
1924bcb02 rcu: Avoid counte... |
2441 |
/* Check to see if someone else did our work for us. */ |
40694d664 rcu: Move synchro... |
2442 |
s = atomic_long_read(&rsp->expedited_done); |
1924bcb02 rcu: Avoid counte... |
2443 |
if (ULONG_CMP_GE((ulong)s, (ulong)firstsnap)) { |
a30489c52 rcu: Instrument s... |
2444 2445 2446 |
/* ensure test happens before caller kfree */ smp_mb__before_atomic_inc(); /* ^^^ */ atomic_long_inc(&rsp->expedited_workdone1); |
1924bcb02 rcu: Avoid counte... |
2447 2448 |
return; } |
3d3b7db0a rcu: Move synchro... |
2449 2450 |
/* No joy, try again later. Or just synchronize_sched(). */ |
c701d5d9b rcu: Fix code-sty... |
2451 |
if (trycount++ < 10) { |
3d3b7db0a rcu: Move synchro... |
2452 |
udelay(trycount * num_online_cpus()); |
c701d5d9b rcu: Fix code-sty... |
2453 |
} else { |
3705b88db rcu: Add a module... |
2454 |
wait_rcu_gp(call_rcu_sched); |
a30489c52 rcu: Instrument s... |
2455 |
atomic_long_inc(&rsp->expedited_normal); |
3d3b7db0a rcu: Move synchro... |
2456 2457 |
return; } |
1924bcb02 rcu: Avoid counte... |
2458 |
/* Recheck to see if someone else did our work for us. */ |
40694d664 rcu: Move synchro... |
2459 |
s = atomic_long_read(&rsp->expedited_done); |
1924bcb02 rcu: Avoid counte... |
2460 |
if (ULONG_CMP_GE((ulong)s, (ulong)firstsnap)) { |
a30489c52 rcu: Instrument s... |
2461 2462 2463 |
/* ensure test happens before caller kfree */ smp_mb__before_atomic_inc(); /* ^^^ */ atomic_long_inc(&rsp->expedited_workdone2); |
3d3b7db0a rcu: Move synchro... |
2464 2465 2466 2467 2468 |
return; } /* * Refetching sync_sched_expedited_started allows later |
1924bcb02 rcu: Avoid counte... |
2469 2470 2471 2472 |
* callers to piggyback on our grace period. We retry * after they started, so our grace period works for them, * and they started after our first try, so their grace * period works for us. |
3d3b7db0a rcu: Move synchro... |
2473 2474 |
*/ get_online_cpus(); |
40694d664 rcu: Move synchro... |
2475 |
snap = atomic_long_read(&rsp->expedited_start); |
3d3b7db0a rcu: Move synchro... |
2476 2477 |
smp_mb(); /* ensure read is before try_stop_cpus(). */ } |
a30489c52 rcu: Instrument s... |
2478 |
atomic_long_inc(&rsp->expedited_stoppedcpus); |
3d3b7db0a rcu: Move synchro... |
2479 2480 2481 2482 2483 |
/* * Everyone up to our most recent fetch is covered by our grace * period. Update the counter, but only if our work is still * relevant -- which it won't be if someone who started later |
1924bcb02 rcu: Avoid counte... |
2484 |
* than we did already did their update. |
3d3b7db0a rcu: Move synchro... |
2485 2486 |
*/ do { |
a30489c52 rcu: Instrument s... |
2487 |
atomic_long_inc(&rsp->expedited_done_tries); |
40694d664 rcu: Move synchro... |
2488 |
s = atomic_long_read(&rsp->expedited_done); |
1924bcb02 rcu: Avoid counte... |
2489 |
if (ULONG_CMP_GE((ulong)s, (ulong)snap)) { |
a30489c52 rcu: Instrument s... |
2490 2491 2492 |
/* ensure test happens before caller kfree */ smp_mb__before_atomic_inc(); /* ^^^ */ atomic_long_inc(&rsp->expedited_done_lost); |
3d3b7db0a rcu: Move synchro... |
2493 2494 |
break; } |
40694d664 rcu: Move synchro... |
2495 |
} while (atomic_long_cmpxchg(&rsp->expedited_done, s, snap) != s); |
a30489c52 rcu: Instrument s... |
2496 |
atomic_long_inc(&rsp->expedited_done_exit); |
3d3b7db0a rcu: Move synchro... |
2497 2498 2499 2500 |
put_online_cpus(); } EXPORT_SYMBOL_GPL(synchronize_sched_expedited); |
64db4cfff "Tree RCU": scala... |
2501 2502 2503 2504 2505 2506 2507 2508 2509 |
/* * Check to see if there is any immediate RCU-related work to be done * by the current CPU, for the specified type of RCU, returning 1 if so. * The checks are in order of increasing expense: checks that can be * carried out against CPU-local state are performed first. However, * we must check for CPU stalls first, else we might not get a chance. */ static int __rcu_pending(struct rcu_state *rsp, struct rcu_data *rdp) { |
2f51f9884 rcu: Eliminate __... |
2510 |
struct rcu_node *rnp = rdp->mynode; |
64db4cfff "Tree RCU": scala... |
2511 2512 2513 2514 2515 2516 |
rdp->n_rcu_pending++; /* Check for CPU stalls, if enabled. */ check_cpu_stall(rsp, rdp); /* Is the RCU core waiting for a quiescent state from this CPU? */ |
5c51dd734 rcu: Prevent earl... |
2517 2518 |
if (rcu_scheduler_fully_active && rdp->qs_pending && !rdp->passed_quiesce) { |
d21670aca rcu: reduce the n... |
2519 |
rdp->n_rp_qs_pending++; |
e4cc1f22b rcu: Simplify qui... |
2520 |
} else if (rdp->qs_pending && rdp->passed_quiesce) { |
d21670aca rcu: reduce the n... |
2521 |
rdp->n_rp_report_qs++; |
64db4cfff "Tree RCU": scala... |
2522 |
return 1; |
7ba5c840e rcu: Add __rcu_pe... |
2523 |
} |
64db4cfff "Tree RCU": scala... |
2524 2525 |
/* Does this CPU have callbacks ready to invoke? */ |
7ba5c840e rcu: Add __rcu_pe... |
2526 2527 |
if (cpu_has_callbacks_ready_to_invoke(rdp)) { rdp->n_rp_cb_ready++; |
64db4cfff "Tree RCU": scala... |
2528 |
return 1; |
7ba5c840e rcu: Add __rcu_pe... |
2529 |
} |
64db4cfff "Tree RCU": scala... |
2530 2531 |
/* Has RCU gone idle with this CPU needing another grace period? */ |
7ba5c840e rcu: Add __rcu_pe... |
2532 2533 |
if (cpu_needs_another_gp(rsp, rdp)) { rdp->n_rp_cpu_needs_gp++; |
64db4cfff "Tree RCU": scala... |
2534 |
return 1; |
7ba5c840e rcu: Add __rcu_pe... |
2535 |
} |
64db4cfff "Tree RCU": scala... |
2536 2537 |
/* Has another RCU grace period completed? */ |
2f51f9884 rcu: Eliminate __... |
2538 |
if (ACCESS_ONCE(rnp->completed) != rdp->completed) { /* outside lock */ |
7ba5c840e rcu: Add __rcu_pe... |
2539 |
rdp->n_rp_gp_completed++; |
64db4cfff "Tree RCU": scala... |
2540 |
return 1; |
7ba5c840e rcu: Add __rcu_pe... |
2541 |
} |
64db4cfff "Tree RCU": scala... |
2542 2543 |
/* Has a new RCU grace period started? */ |
2f51f9884 rcu: Eliminate __... |
2544 |
if (ACCESS_ONCE(rnp->gpnum) != rdp->gpnum) { /* outside lock */ |
7ba5c840e rcu: Add __rcu_pe... |
2545 |
rdp->n_rp_gp_started++; |
64db4cfff "Tree RCU": scala... |
2546 |
return 1; |
7ba5c840e rcu: Add __rcu_pe... |
2547 |
} |
64db4cfff "Tree RCU": scala... |
2548 |
|
64db4cfff "Tree RCU": scala... |
2549 |
/* nothing to do */ |
7ba5c840e rcu: Add __rcu_pe... |
2550 |
rdp->n_rp_need_nothing++; |
64db4cfff "Tree RCU": scala... |
2551 2552 2553 2554 2555 2556 2557 2558 |
return 0; } /* * Check to see if there is any immediate RCU-related work to be done * by the current CPU, returning 1 if so. This function is part of the * RCU implementation; it is -not- an exported member of the RCU API. */ |
a157229ca rcu: Simplify rcu... |
2559 |
static int rcu_pending(int cpu) |
64db4cfff "Tree RCU": scala... |
2560 |
{ |
6ce75a232 rcu: Introduce fo... |
2561 2562 2563 2564 2565 2566 |
struct rcu_state *rsp; for_each_rcu_flavor(rsp) if (__rcu_pending(rsp, per_cpu_ptr(rsp->rda, cpu))) return 1; return 0; |
64db4cfff "Tree RCU": scala... |
2567 2568 2569 2570 2571 |
} /* * Check to see if any future RCU-related work will need to be done * by the current CPU, even if none need be done immediately, returning |
8bd93a2c5 rcu: Accelerate g... |
2572 |
* 1 if so. |
64db4cfff "Tree RCU": scala... |
2573 |
*/ |
aea1b35e2 rcu: Allow dyntic... |
2574 |
static int rcu_cpu_has_callbacks(int cpu) |
64db4cfff "Tree RCU": scala... |
2575 |
{ |
6ce75a232 rcu: Introduce fo... |
2576 |
struct rcu_state *rsp; |
64db4cfff "Tree RCU": scala... |
2577 |
/* RCU callbacks either ready or pending? */ |
6ce75a232 rcu: Introduce fo... |
2578 2579 2580 2581 |
for_each_rcu_flavor(rsp) if (per_cpu_ptr(rsp->rda, cpu)->nxtlist) return 1; return 0; |
64db4cfff "Tree RCU": scala... |
2582 |
} |
b1420f1c8 rcu: Make rcu_bar... |
2583 |
/* |
a83eff0a8 rcu: Add tracing ... |
2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 |
* Helper function for _rcu_barrier() tracing. If tracing is disabled, * the compiler is expected to optimize this away. */ static void _rcu_barrier_trace(struct rcu_state *rsp, char *s, int cpu, unsigned long done) { trace_rcu_barrier(rsp->name, s, cpu, atomic_read(&rsp->barrier_cpu_count), done); } /* |
b1420f1c8 rcu: Make rcu_bar... |
2595 2596 2597 |
* RCU callback function for _rcu_barrier(). If we are last, wake * up the task executing _rcu_barrier(). */ |
24ebbca8e rcu: Move rcu_bar... |
2598 |
static void rcu_barrier_callback(struct rcu_head *rhp) |
d0ec774cb rcu: Move rcu_bar... |
2599 |
{ |
24ebbca8e rcu: Move rcu_bar... |
2600 2601 |
struct rcu_data *rdp = container_of(rhp, struct rcu_data, barrier_head); struct rcu_state *rsp = rdp->rsp; |
a83eff0a8 rcu: Add tracing ... |
2602 2603 |
if (atomic_dec_and_test(&rsp->barrier_cpu_count)) { _rcu_barrier_trace(rsp, "LastCB", -1, rsp->n_barrier_done); |
7db74df88 rcu: Move rcu_bar... |
2604 |
complete(&rsp->barrier_completion); |
a83eff0a8 rcu: Add tracing ... |
2605 2606 2607 |
} else { _rcu_barrier_trace(rsp, "CB", -1, rsp->n_barrier_done); } |
d0ec774cb rcu: Move rcu_bar... |
2608 2609 2610 2611 2612 2613 2614 |
} /* * Called with preemption disabled, and from cross-cpu IRQ context. */ static void rcu_barrier_func(void *type) { |
037b64ed0 rcu: Place pointe... |
2615 |
struct rcu_state *rsp = type; |
06668efa9 rcu: Move _rcu_ba... |
2616 |
struct rcu_data *rdp = __this_cpu_ptr(rsp->rda); |
d0ec774cb rcu: Move rcu_bar... |
2617 |
|
a83eff0a8 rcu: Add tracing ... |
2618 |
_rcu_barrier_trace(rsp, "IRQ", -1, rsp->n_barrier_done); |
24ebbca8e rcu: Move rcu_bar... |
2619 |
atomic_inc(&rsp->barrier_cpu_count); |
06668efa9 rcu: Move _rcu_ba... |
2620 |
rsp->call(&rdp->barrier_head, rcu_barrier_callback); |
d0ec774cb rcu: Move rcu_bar... |
2621 |
} |
d0ec774cb rcu: Move rcu_bar... |
2622 2623 2624 2625 |
/* * Orchestrate the specified type of RCU barrier, waiting for all * RCU callbacks of the specified type to complete. */ |
037b64ed0 rcu: Place pointe... |
2626 |
static void _rcu_barrier(struct rcu_state *rsp) |
d0ec774cb rcu: Move rcu_bar... |
2627 |
{ |
b1420f1c8 rcu: Make rcu_bar... |
2628 |
int cpu; |
b1420f1c8 rcu: Make rcu_bar... |
2629 |
struct rcu_data *rdp; |
cf3a9c484 rcu: Increase rcu... |
2630 2631 |
unsigned long snap = ACCESS_ONCE(rsp->n_barrier_done); unsigned long snap_done; |
b1420f1c8 rcu: Make rcu_bar... |
2632 |
|
a83eff0a8 rcu: Add tracing ... |
2633 |
_rcu_barrier_trace(rsp, "Begin", -1, snap); |
b1420f1c8 rcu: Make rcu_bar... |
2634 |
|
e74f4c456 rcu: Make hot-unp... |
2635 |
/* Take mutex to serialize concurrent rcu_barrier() requests. */ |
7be7f0be9 rcu: Move rcu_bar... |
2636 |
mutex_lock(&rsp->barrier_mutex); |
b1420f1c8 rcu: Make rcu_bar... |
2637 |
|
cf3a9c484 rcu: Increase rcu... |
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 |
/* * Ensure that all prior references, including to ->n_barrier_done, * are ordered before the _rcu_barrier() machinery. */ smp_mb(); /* See above block comment. */ /* * Recheck ->n_barrier_done to see if others did our work for us. * This means checking ->n_barrier_done for an even-to-odd-to-even * transition. The "if" expression below therefore rounds the old * value up to the next even number and adds two before comparing. */ snap_done = ACCESS_ONCE(rsp->n_barrier_done); |
a83eff0a8 rcu: Add tracing ... |
2651 |
_rcu_barrier_trace(rsp, "Check", -1, snap_done); |
cf3a9c484 rcu: Increase rcu... |
2652 |
if (ULONG_CMP_GE(snap_done, ((snap + 1) & ~0x1) + 2)) { |
a83eff0a8 rcu: Add tracing ... |
2653 |
_rcu_barrier_trace(rsp, "EarlyExit", -1, snap_done); |
cf3a9c484 rcu: Increase rcu... |
2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 |
smp_mb(); /* caller's subsequent code after above check. */ mutex_unlock(&rsp->barrier_mutex); return; } /* * Increment ->n_barrier_done to avoid duplicate work. Use * ACCESS_ONCE() to prevent the compiler from speculating * the increment to precede the early-exit check. */ ACCESS_ONCE(rsp->n_barrier_done)++; WARN_ON_ONCE((rsp->n_barrier_done & 0x1) != 1); |
a83eff0a8 rcu: Add tracing ... |
2666 |
_rcu_barrier_trace(rsp, "Inc1", -1, rsp->n_barrier_done); |
cf3a9c484 rcu: Increase rcu... |
2667 |
smp_mb(); /* Order ->n_barrier_done increment with below mechanism. */ |
b1420f1c8 rcu: Make rcu_bar... |
2668 |
|
d0ec774cb rcu: Move rcu_bar... |
2669 |
/* |
b1420f1c8 rcu: Make rcu_bar... |
2670 2671 |
* Initialize the count to one rather than to zero in order to * avoid a too-soon return to zero in case of a short grace period |
1331e7a1b rcu: Remove _rcu_... |
2672 2673 |
* (or preemption of this task). Exclude CPU-hotplug operations * to ensure that no offline CPU has callbacks queued. |
d0ec774cb rcu: Move rcu_bar... |
2674 |
*/ |
7db74df88 rcu: Move rcu_bar... |
2675 |
init_completion(&rsp->barrier_completion); |
24ebbca8e rcu: Move rcu_bar... |
2676 |
atomic_set(&rsp->barrier_cpu_count, 1); |
1331e7a1b rcu: Remove _rcu_... |
2677 |
get_online_cpus(); |
b1420f1c8 rcu: Make rcu_bar... |
2678 2679 |
/* |
1331e7a1b rcu: Remove _rcu_... |
2680 2681 2682 |
* Force each CPU with callbacks to register a new callback. * When that callback is invoked, we will know that all of the * corresponding CPU's preceding callbacks have been invoked. |
b1420f1c8 rcu: Make rcu_bar... |
2683 |
*/ |
3fbfbf7a3 rcu: Add callback... |
2684 2685 2686 |
for_each_possible_cpu(cpu) { if (!cpu_online(cpu) && !is_nocb_cpu(cpu)) continue; |
b1420f1c8 rcu: Make rcu_bar... |
2687 |
rdp = per_cpu_ptr(rsp->rda, cpu); |
3fbfbf7a3 rcu: Add callback... |
2688 2689 2690 2691 2692 2693 2694 |
if (is_nocb_cpu(cpu)) { _rcu_barrier_trace(rsp, "OnlineNoCB", cpu, rsp->n_barrier_done); atomic_inc(&rsp->barrier_cpu_count); __call_rcu(&rdp->barrier_head, rcu_barrier_callback, rsp, cpu, 0); } else if (ACCESS_ONCE(rdp->qlen)) { |
a83eff0a8 rcu: Add tracing ... |
2695 2696 |
_rcu_barrier_trace(rsp, "OnlineQ", cpu, rsp->n_barrier_done); |
037b64ed0 rcu: Place pointe... |
2697 |
smp_call_function_single(cpu, rcu_barrier_func, rsp, 1); |
b1420f1c8 rcu: Make rcu_bar... |
2698 |
} else { |
a83eff0a8 rcu: Add tracing ... |
2699 2700 |
_rcu_barrier_trace(rsp, "OnlineNQ", cpu, rsp->n_barrier_done); |
b1420f1c8 rcu: Make rcu_bar... |
2701 2702 |
} } |
1331e7a1b rcu: Remove _rcu_... |
2703 |
put_online_cpus(); |
b1420f1c8 rcu: Make rcu_bar... |
2704 2705 2706 2707 2708 |
/* * Now that we have an rcu_barrier_callback() callback on each * CPU, and thus each counted, remove the initial count. */ |
24ebbca8e rcu: Move rcu_bar... |
2709 |
if (atomic_dec_and_test(&rsp->barrier_cpu_count)) |
7db74df88 rcu: Move rcu_bar... |
2710 |
complete(&rsp->barrier_completion); |
b1420f1c8 rcu: Make rcu_bar... |
2711 |
|
cf3a9c484 rcu: Increase rcu... |
2712 2713 2714 2715 |
/* Increment ->n_barrier_done to prevent duplicate work. */ smp_mb(); /* Keep increment after above mechanism. */ ACCESS_ONCE(rsp->n_barrier_done)++; WARN_ON_ONCE((rsp->n_barrier_done & 0x1) != 0); |
a83eff0a8 rcu: Add tracing ... |
2716 |
_rcu_barrier_trace(rsp, "Inc2", -1, rsp->n_barrier_done); |
cf3a9c484 rcu: Increase rcu... |
2717 |
smp_mb(); /* Keep increment before caller's subsequent code. */ |
b1420f1c8 rcu: Make rcu_bar... |
2718 |
/* Wait for all rcu_barrier_callback() callbacks to be invoked. */ |
7db74df88 rcu: Move rcu_bar... |
2719 |
wait_for_completion(&rsp->barrier_completion); |
b1420f1c8 rcu: Make rcu_bar... |
2720 2721 |
/* Other rcu_barrier() invocations can now safely proceed. */ |
7be7f0be9 rcu: Move rcu_bar... |
2722 |
mutex_unlock(&rsp->barrier_mutex); |
d0ec774cb rcu: Move rcu_bar... |
2723 |
} |
d0ec774cb rcu: Move rcu_bar... |
2724 2725 2726 2727 2728 2729 |
/** * rcu_barrier_bh - Wait until all in-flight call_rcu_bh() callbacks complete. */ void rcu_barrier_bh(void) { |
037b64ed0 rcu: Place pointe... |
2730 |
_rcu_barrier(&rcu_bh_state); |
d0ec774cb rcu: Move rcu_bar... |
2731 2732 2733 2734 2735 2736 2737 2738 |
} EXPORT_SYMBOL_GPL(rcu_barrier_bh); /** * rcu_barrier_sched - Wait for in-flight call_rcu_sched() callbacks. */ void rcu_barrier_sched(void) { |
037b64ed0 rcu: Place pointe... |
2739 |
_rcu_barrier(&rcu_sched_state); |
d0ec774cb rcu: Move rcu_bar... |
2740 2741 |
} EXPORT_SYMBOL_GPL(rcu_barrier_sched); |
64db4cfff "Tree RCU": scala... |
2742 |
/* |
27569620c rcu: Split hierar... |
2743 |
* Do boot-time initialization of a CPU's per-CPU RCU data. |
64db4cfff "Tree RCU": scala... |
2744 |
*/ |
27569620c rcu: Split hierar... |
2745 2746 |
static void __init rcu_boot_init_percpu_data(int cpu, struct rcu_state *rsp) |
64db4cfff "Tree RCU": scala... |
2747 2748 |
{ unsigned long flags; |
394f99a90 rcu: simplify the... |
2749 |
struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu); |
27569620c rcu: Split hierar... |
2750 2751 2752 |
struct rcu_node *rnp = rcu_get_root(rsp); /* Set up local state, ensuring consistent view of global state. */ |
1304afb22 rcu: Convert to r... |
2753 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
27569620c rcu: Split hierar... |
2754 |
rdp->grpmask = 1UL << (cpu - rdp->mynode->grplo); |
3f5d3ea64 rcu: Consolidate ... |
2755 |
init_callback_list(rdp); |
486e25934 rcu: Avoid waking... |
2756 |
rdp->qlen_lazy = 0; |
1d1fb395f rcu: Add ACCESS_O... |
2757 |
ACCESS_ONCE(rdp->qlen) = 0; |
27569620c rcu: Split hierar... |
2758 |
rdp->dynticks = &per_cpu(rcu_dynticks, cpu); |
29e37d814 rcu: Allow nestin... |
2759 |
WARN_ON_ONCE(rdp->dynticks->dynticks_nesting != DYNTICK_TASK_EXIT_IDLE); |
9b2e4f188 rcu: Track idlene... |
2760 |
WARN_ON_ONCE(atomic_read(&rdp->dynticks->dynticks) != 1); |
27569620c rcu: Split hierar... |
2761 |
rdp->cpu = cpu; |
d4c08f2ac rcu: Add grace-pe... |
2762 |
rdp->rsp = rsp; |
3fbfbf7a3 rcu: Add callback... |
2763 |
rcu_boot_init_nocb_percpu_data(rdp); |
1304afb22 rcu: Convert to r... |
2764 |
raw_spin_unlock_irqrestore(&rnp->lock, flags); |
27569620c rcu: Split hierar... |
2765 2766 2767 2768 2769 2770 2771 |
} /* * Initialize a CPU's per-CPU RCU data. Note that only one online or * offline event can be happening at a given time. Note also that we * can accept some slop in the rsp->completed access due to the fact * that this CPU cannot possibly have any RCU callbacks in flight yet. |
64db4cfff "Tree RCU": scala... |
2772 |
*/ |
e4fa4c970 rcu: add __cpuini... |
2773 |
static void __cpuinit |
6cc68793e rcu: fix spelling |
2774 |
rcu_init_percpu_data(int cpu, struct rcu_state *rsp, int preemptible) |
64db4cfff "Tree RCU": scala... |
2775 2776 |
{ unsigned long flags; |
64db4cfff "Tree RCU": scala... |
2777 |
unsigned long mask; |
394f99a90 rcu: simplify the... |
2778 |
struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu); |
64db4cfff "Tree RCU": scala... |
2779 |
struct rcu_node *rnp = rcu_get_root(rsp); |
a4fbe35a1 rcu: Grace-period... |
2780 2781 |
/* Exclude new grace periods. */ mutex_lock(&rsp->onoff_mutex); |
64db4cfff "Tree RCU": scala... |
2782 |
/* Set up local state, ensuring consistent view of global state. */ |
1304afb22 rcu: Convert to r... |
2783 |
raw_spin_lock_irqsave(&rnp->lock, flags); |
64db4cfff "Tree RCU": scala... |
2784 |
rdp->beenonline = 1; /* We have now been online. */ |
6cc68793e rcu: fix spelling |
2785 |
rdp->preemptible = preemptible; |
37c72e56f rcu: Prevent RCU ... |
2786 2787 |
rdp->qlen_last_fqs_check = 0; rdp->n_force_qs_snap = rsp->n_force_qs; |
64db4cfff "Tree RCU": scala... |
2788 |
rdp->blimit = blimit; |
0d8ee37e2 rcu: Disallow cal... |
2789 |
init_callback_list(rdp); /* Re-enable callbacks on this CPU. */ |
29e37d814 rcu: Allow nestin... |
2790 |
rdp->dynticks->dynticks_nesting = DYNTICK_TASK_EXIT_IDLE; |
c92b131bd rcu: Remove dynti... |
2791 2792 |
atomic_set(&rdp->dynticks->dynticks, (atomic_read(&rdp->dynticks->dynticks) & ~0x1) + 1); |
7cb924990 rcu: Permit dynti... |
2793 |
rcu_prepare_for_idle_init(cpu); |
1304afb22 rcu: Convert to r... |
2794 |
raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */ |
64db4cfff "Tree RCU": scala... |
2795 |
|
64db4cfff "Tree RCU": scala... |
2796 2797 2798 2799 2800 |
/* Add CPU to rcu_node bitmasks. */ rnp = rdp->mynode; mask = rdp->grpmask; do { /* Exclude any attempts to start a new GP on small systems. */ |
1304afb22 rcu: Convert to r... |
2801 |
raw_spin_lock(&rnp->lock); /* irqs already disabled. */ |
64db4cfff "Tree RCU": scala... |
2802 2803 |
rnp->qsmaskinit |= mask; mask = rnp->grpmask; |
d09b62dfa rcu: Fix synchron... |
2804 |
if (rnp == rdp->mynode) { |
06ae115a1 rcu: Avoid having... |
2805 2806 2807 2808 2809 2810 |
/* * If there is a grace period in progress, we will * set up to wait for it next time we run the * RCU core code. */ rdp->gpnum = rnp->completed; |
d09b62dfa rcu: Fix synchron... |
2811 |
rdp->completed = rnp->completed; |
06ae115a1 rcu: Avoid having... |
2812 2813 |
rdp->passed_quiesce = 0; rdp->qs_pending = 0; |
d4c08f2ac rcu: Add grace-pe... |
2814 |
trace_rcu_grace_period(rsp->name, rdp->gpnum, "cpuonl"); |
d09b62dfa rcu: Fix synchron... |
2815 |
} |
1304afb22 rcu: Convert to r... |
2816 |
raw_spin_unlock(&rnp->lock); /* irqs already disabled. */ |
64db4cfff "Tree RCU": scala... |
2817 2818 |
rnp = rnp->parent; } while (rnp != NULL && !(rnp->qsmaskinit & mask)); |
a4fbe35a1 rcu: Grace-period... |
2819 |
local_irq_restore(flags); |
64db4cfff "Tree RCU": scala... |
2820 |
|
a4fbe35a1 rcu: Grace-period... |
2821 |
mutex_unlock(&rsp->onoff_mutex); |
64db4cfff "Tree RCU": scala... |
2822 |
} |
d72bce0e6 rcu: Cure load woes |
2823 |
static void __cpuinit rcu_prepare_cpu(int cpu) |
64db4cfff "Tree RCU": scala... |
2824 |
{ |
6ce75a232 rcu: Introduce fo... |
2825 2826 2827 2828 2829 |
struct rcu_state *rsp; for_each_rcu_flavor(rsp) rcu_init_percpu_data(cpu, rsp, strcmp(rsp->name, "rcu_preempt") == 0); |
64db4cfff "Tree RCU": scala... |
2830 2831 2832 |
} /* |
f41d911f8 rcu: Merge preemp... |
2833 |
* Handle CPU online/offline notification events. |
64db4cfff "Tree RCU": scala... |
2834 |
*/ |
9f680ab41 rcu: Eliminate un... |
2835 2836 |
static int __cpuinit rcu_cpu_notify(struct notifier_block *self, unsigned long action, void *hcpu) |
64db4cfff "Tree RCU": scala... |
2837 2838 |
{ long cpu = (long)hcpu; |
27f4d2805 rcu: priority boo... |
2839 |
struct rcu_data *rdp = per_cpu_ptr(rcu_state->rda, cpu); |
a26ac2455 rcu: move TREE_RC... |
2840 |
struct rcu_node *rnp = rdp->mynode; |
6ce75a232 rcu: Introduce fo... |
2841 |
struct rcu_state *rsp; |
3fbfbf7a3 rcu: Add callback... |
2842 |
int ret = NOTIFY_OK; |
64db4cfff "Tree RCU": scala... |
2843 |
|
300df91ca rcu: Event-trace ... |
2844 |
trace_rcu_utilization("Start CPU hotplug"); |
64db4cfff "Tree RCU": scala... |
2845 2846 2847 |
switch (action) { case CPU_UP_PREPARE: case CPU_UP_PREPARE_FROZEN: |
d72bce0e6 rcu: Cure load woes |
2848 2849 |
rcu_prepare_cpu(cpu); rcu_prepare_kthreads(cpu); |
a26ac2455 rcu: move TREE_RC... |
2850 2851 |
break; case CPU_ONLINE: |
0f962a5e7 rcu: Force per-rc... |
2852 |
case CPU_DOWN_FAILED: |
5d01bbd11 rcu: Yield simpler |
2853 |
rcu_boost_kthread_setaffinity(rnp, -1); |
0f962a5e7 rcu: Force per-rc... |
2854 2855 |
break; case CPU_DOWN_PREPARE: |
3fbfbf7a3 rcu: Add callback... |
2856 2857 2858 2859 |
if (nocb_cpu_expendable(cpu)) rcu_boost_kthread_setaffinity(rnp, cpu); else ret = NOTIFY_BAD; |
64db4cfff "Tree RCU": scala... |
2860 |
break; |
d0ec774cb rcu: Move rcu_bar... |
2861 2862 2863 |
case CPU_DYING: case CPU_DYING_FROZEN: /* |
2d999e03b rcu: update docum... |
2864 2865 2866 |
* The whole machine is "stopped" except this CPU, so we can * touch any data without introducing corruption. We send the * dying CPU's callbacks to an arbitrarily chosen online CPU. |
d0ec774cb rcu: Move rcu_bar... |
2867 |
*/ |
6ce75a232 rcu: Introduce fo... |
2868 2869 |
for_each_rcu_flavor(rsp) rcu_cleanup_dying_cpu(rsp); |
7cb924990 rcu: Permit dynti... |
2870 |
rcu_cleanup_after_idle(cpu); |
d0ec774cb rcu: Move rcu_bar... |
2871 |
break; |
64db4cfff "Tree RCU": scala... |
2872 2873 2874 2875 |
case CPU_DEAD: case CPU_DEAD_FROZEN: case CPU_UP_CANCELED: case CPU_UP_CANCELED_FROZEN: |
6ce75a232 rcu: Introduce fo... |
2876 2877 |
for_each_rcu_flavor(rsp) rcu_cleanup_dead_cpu(cpu, rsp); |
64db4cfff "Tree RCU": scala... |
2878 2879 2880 2881 |
break; default: break; } |
300df91ca rcu: Event-trace ... |
2882 |
trace_rcu_utilization("End CPU hotplug"); |
3fbfbf7a3 rcu: Add callback... |
2883 |
return ret; |
64db4cfff "Tree RCU": scala... |
2884 2885 2886 |
} /* |
b3dbec76e rcu: Move RCU gra... |
2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 |
* Spawn the kthread that handles this RCU flavor's grace periods. */ static int __init rcu_spawn_gp_kthread(void) { unsigned long flags; struct rcu_node *rnp; struct rcu_state *rsp; struct task_struct *t; for_each_rcu_flavor(rsp) { t = kthread_run(rcu_gp_kthread, rsp, rsp->name); BUG_ON(IS_ERR(t)); rnp = rcu_get_root(rsp); raw_spin_lock_irqsave(&rnp->lock, flags); rsp->gp_kthread = t; raw_spin_unlock_irqrestore(&rnp->lock, flags); |
3fbfbf7a3 rcu: Add callback... |
2903 |
rcu_spawn_nocb_kthreads(rsp); |
b3dbec76e rcu: Move RCU gra... |
2904 2905 2906 2907 2908 2909 |
} return 0; } early_initcall(rcu_spawn_gp_kthread); /* |
bbad93798 rcu: slim down rc... |
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 |
* This function is invoked towards the end of the scheduler's initialization * process. Before this is called, the idle task might contain * RCU read-side critical sections (during which time, this idle * task is booting the system). After this function is called, the * idle tasks are prohibited from containing RCU read-side critical * sections. This function also enables RCU lockdep checking. */ void rcu_scheduler_starting(void) { WARN_ON(num_online_cpus() != 1); WARN_ON(nr_context_switches() > 0); rcu_scheduler_active = 1; } /* |
64db4cfff "Tree RCU": scala... |
2925 2926 2927 2928 2929 2930 2931 |
* Compute the per-level fanout, either using the exact fanout specified * or balancing the tree, depending on CONFIG_RCU_FANOUT_EXACT. */ #ifdef CONFIG_RCU_FANOUT_EXACT static void __init rcu_init_levelspread(struct rcu_state *rsp) { int i; |
f885b7f2b rcu: Control RCU_... |
2932 |
for (i = rcu_num_lvls - 1; i > 0; i--) |
64db4cfff "Tree RCU": scala... |
2933 |
rsp->levelspread[i] = CONFIG_RCU_FANOUT; |
f885b7f2b rcu: Control RCU_... |
2934 |
rsp->levelspread[0] = rcu_fanout_leaf; |
64db4cfff "Tree RCU": scala... |
2935 2936 2937 2938 2939 2940 2941 |
} #else /* #ifdef CONFIG_RCU_FANOUT_EXACT */ static void __init rcu_init_levelspread(struct rcu_state *rsp) { int ccur; int cprv; int i; |
4dbd6bb38 rcu: Handle unbal... |
2942 |
cprv = nr_cpu_ids; |
f885b7f2b rcu: Control RCU_... |
2943 |
for (i = rcu_num_lvls - 1; i >= 0; i--) { |
64db4cfff "Tree RCU": scala... |
2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 |
ccur = rsp->levelcnt[i]; rsp->levelspread[i] = (cprv + ccur - 1) / ccur; cprv = ccur; } } #endif /* #else #ifdef CONFIG_RCU_FANOUT_EXACT */ /* * Helper function for rcu_init() that initializes one rcu_state structure. */ |
394f99a90 rcu: simplify the... |
2954 2955 |
static void __init rcu_init_one(struct rcu_state *rsp, struct rcu_data __percpu *rda) |
64db4cfff "Tree RCU": scala... |
2956 |
{ |
394f2769a rcu: Prevent forc... |
2957 2958 2959 2960 2961 2962 2963 2964 |
static char *buf[] = { "rcu_node_0", "rcu_node_1", "rcu_node_2", "rcu_node_3" }; /* Match MAX_RCU_LVLS */ static char *fqs[] = { "rcu_node_fqs_0", "rcu_node_fqs_1", "rcu_node_fqs_2", "rcu_node_fqs_3" }; /* Match MAX_RCU_LVLS */ |
64db4cfff "Tree RCU": scala... |
2965 2966 2967 2968 |
int cpustride = 1; int i; int j; struct rcu_node *rnp; |
b6407e863 rcu: Give differe... |
2969 |
BUILD_BUG_ON(MAX_RCU_LVLS > ARRAY_SIZE(buf)); /* Fix buf[] init! */ |
4930521ae rcu: Silence comp... |
2970 2971 2972 |
/* Silence gcc 4.8 warning about array index out of range. */ if (rcu_num_lvls > RCU_NUM_LVLS) panic("rcu_init_one: rcu_num_lvls overflow"); |
64db4cfff "Tree RCU": scala... |
2973 |
/* Initialize the level-tracking arrays. */ |
f885b7f2b rcu: Control RCU_... |
2974 2975 2976 |
for (i = 0; i < rcu_num_lvls; i++) rsp->levelcnt[i] = num_rcu_lvl[i]; for (i = 1; i < rcu_num_lvls; i++) |
64db4cfff "Tree RCU": scala... |
2977 2978 2979 2980 |
rsp->level[i] = rsp->level[i - 1] + rsp->levelcnt[i - 1]; rcu_init_levelspread(rsp); /* Initialize the elements themselves, starting from the leaves. */ |
f885b7f2b rcu: Control RCU_... |
2981 |
for (i = rcu_num_lvls - 1; i >= 0; i--) { |
64db4cfff "Tree RCU": scala... |
2982 2983 2984 |
cpustride *= rsp->levelspread[i]; rnp = rsp->level[i]; for (j = 0; j < rsp->levelcnt[i]; j++, rnp++) { |
1304afb22 rcu: Convert to r... |
2985 |
raw_spin_lock_init(&rnp->lock); |
b6407e863 rcu: Give differe... |
2986 2987 |
lockdep_set_class_and_name(&rnp->lock, &rcu_node_class[i], buf[i]); |
394f2769a rcu: Prevent forc... |
2988 2989 2990 |
raw_spin_lock_init(&rnp->fqslock); lockdep_set_class_and_name(&rnp->fqslock, &rcu_fqs_class[i], fqs[i]); |
25d30cf42 rcu: Adjust for u... |
2991 2992 |
rnp->gpnum = rsp->gpnum; rnp->completed = rsp->completed; |
64db4cfff "Tree RCU": scala... |
2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 |
rnp->qsmask = 0; rnp->qsmaskinit = 0; rnp->grplo = j * cpustride; rnp->grphi = (j + 1) * cpustride - 1; if (rnp->grphi >= NR_CPUS) rnp->grphi = NR_CPUS - 1; if (i == 0) { rnp->grpnum = 0; rnp->grpmask = 0; rnp->parent = NULL; } else { rnp->grpnum = j % rsp->levelspread[i - 1]; rnp->grpmask = 1UL << rnp->grpnum; rnp->parent = rsp->level[i - 1] + j / rsp->levelspread[i - 1]; } rnp->level = i; |
12f5f524c rcu: merge TREE_P... |
3010 |
INIT_LIST_HEAD(&rnp->blkd_tasks); |
64db4cfff "Tree RCU": scala... |
3011 3012 |
} } |
0c34029ab rcu: move some co... |
3013 |
|
394f99a90 rcu: simplify the... |
3014 |
rsp->rda = rda; |
b3dbec76e rcu: Move RCU gra... |
3015 |
init_waitqueue_head(&rsp->gp_wq); |
f885b7f2b rcu: Control RCU_... |
3016 |
rnp = rsp->level[rcu_num_lvls - 1]; |
0c34029ab rcu: move some co... |
3017 |
for_each_possible_cpu(i) { |
4a90a0681 rcu: permit disco... |
3018 |
while (i > rnp->grphi) |
0c34029ab rcu: move some co... |
3019 |
rnp++; |
394f99a90 rcu: simplify the... |
3020 |
per_cpu_ptr(rsp->rda, i)->mynode = rnp; |
0c34029ab rcu: move some co... |
3021 3022 |
rcu_boot_init_percpu_data(i, rsp); } |
6ce75a232 rcu: Introduce fo... |
3023 |
list_add(&rsp->flavors, &rcu_struct_flavors); |
64db4cfff "Tree RCU": scala... |
3024 |
} |
f885b7f2b rcu: Control RCU_... |
3025 3026 3027 3028 3029 3030 3031 3032 3033 |
/* * Compute the rcu_node tree geometry from kernel parameters. This cannot * replace the definitions in rcutree.h because those are needed to size * the ->node array in the rcu_state structure. */ static void __init rcu_init_geometry(void) { int i; int j; |
cca6f3931 rcu: Size rcu_nod... |
3034 |
int n = nr_cpu_ids; |
f885b7f2b rcu: Control RCU_... |
3035 3036 3037 |
int rcu_capacity[MAX_RCU_LVLS + 1]; /* If the compile-time values are accurate, just leave. */ |
b17c7035f rcu: Shrink RCU b... |
3038 3039 |
if (rcu_fanout_leaf == CONFIG_RCU_FANOUT_LEAF && nr_cpu_ids == NR_CPUS) |
f885b7f2b rcu: Control RCU_... |
3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 |
return; /* * Compute number of nodes that can be handled an rcu_node tree * with the given number of levels. Setting rcu_capacity[0] makes * some of the arithmetic easier. */ rcu_capacity[0] = 1; rcu_capacity[1] = rcu_fanout_leaf; for (i = 2; i <= MAX_RCU_LVLS; i++) rcu_capacity[i] = rcu_capacity[i - 1] * CONFIG_RCU_FANOUT; /* * The boot-time rcu_fanout_leaf parameter is only permitted * to increase the leaf-level fanout, not decrease it. Of course, * the leaf-level fanout cannot exceed the number of bits in * the rcu_node masks. Finally, the tree must be able to accommodate * the configured number of CPUs. Complain and fall back to the * compile-time values if these limits are exceeded. */ if (rcu_fanout_leaf < CONFIG_RCU_FANOUT_LEAF || rcu_fanout_leaf > sizeof(unsigned long) * 8 || n > rcu_capacity[MAX_RCU_LVLS]) { WARN_ON(1); return; } /* Calculate the number of rcu_nodes at each level of the tree. */ for (i = 1; i <= MAX_RCU_LVLS; i++) if (n <= rcu_capacity[i]) { for (j = 0; j <= i; j++) num_rcu_lvl[j] = DIV_ROUND_UP(n, rcu_capacity[i - j]); rcu_num_lvls = i; for (j = i + 1; j <= MAX_RCU_LVLS; j++) num_rcu_lvl[j] = 0; break; } /* Calculate the total number of rcu_node structures. */ rcu_num_nodes = 0; for (i = 0; i <= MAX_RCU_LVLS; i++) rcu_num_nodes += num_rcu_lvl[i]; rcu_num_nodes -= n; } |
9f680ab41 rcu: Eliminate un... |
3085 |
void __init rcu_init(void) |
64db4cfff "Tree RCU": scala... |
3086 |
{ |
017c42613 rcu: Fix sparse w... |
3087 |
int cpu; |
9f680ab41 rcu: Eliminate un... |
3088 |
|
f41d911f8 rcu: Merge preemp... |
3089 |
rcu_bootup_announce(); |
f885b7f2b rcu: Control RCU_... |
3090 |
rcu_init_geometry(); |
394f99a90 rcu: simplify the... |
3091 3092 |
rcu_init_one(&rcu_sched_state, &rcu_sched_data); rcu_init_one(&rcu_bh_state, &rcu_bh_data); |
f41d911f8 rcu: Merge preemp... |
3093 |
__rcu_init_preempt(); |
3fbfbf7a3 rcu: Add callback... |
3094 |
rcu_init_nocb(); |
09223371d rcu: Use softirq ... |
3095 |
open_softirq(RCU_SOFTIRQ, rcu_process_callbacks); |
9f680ab41 rcu: Eliminate un... |
3096 3097 3098 3099 3100 3101 3102 |
/* * We don't need protection against CPU-hotplug here because * this is called early in boot, before either interrupts * or the scheduler are operational. */ cpu_notifier(rcu_cpu_notify, 0); |
017c42613 rcu: Fix sparse w... |
3103 3104 |
for_each_online_cpu(cpu) rcu_cpu_notify(NULL, CPU_UP_PREPARE, (void *)(long)cpu); |
64db4cfff "Tree RCU": scala... |
3105 |
} |
1eba8f843 rcu: Clean up cod... |
3106 |
#include "rcutree_plugin.h" |