.. | .. |
---|
| 1 | +/* SPDX-License-Identifier: GPL-2.0+ */ |
---|
1 | 2 | /* |
---|
2 | 3 | * Read-Copy Update mechanism for mutual exclusion (tree-based version) |
---|
3 | 4 | * Internal non-public definitions. |
---|
4 | 5 | * |
---|
5 | | - * This program is free software; you can redistribute it and/or modify |
---|
6 | | - * it under the terms of the GNU General Public License as published by |
---|
7 | | - * the Free Software Foundation; either version 2 of the License, or |
---|
8 | | - * (at your option) any later version. |
---|
9 | | - * |
---|
10 | | - * This program is distributed in the hope that it will be useful, |
---|
11 | | - * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
12 | | - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
13 | | - * GNU General Public License for more details. |
---|
14 | | - * |
---|
15 | | - * You should have received a copy of the GNU General Public License |
---|
16 | | - * along with this program; if not, you can access it online at |
---|
17 | | - * http://www.gnu.org/licenses/gpl-2.0.html. |
---|
18 | | - * |
---|
19 | 6 | * Copyright IBM Corporation, 2008 |
---|
20 | 7 | * |
---|
21 | 8 | * Author: Ingo Molnar <mingo@elte.hu> |
---|
22 | | - * Paul E. McKenney <paulmck@linux.vnet.ibm.com> |
---|
| 9 | + * Paul E. McKenney <paulmck@linux.ibm.com> |
---|
23 | 10 | */ |
---|
24 | 11 | |
---|
25 | 12 | #include <linux/cache.h> |
---|
.. | .. |
---|
29 | 16 | #include <linux/cpumask.h> |
---|
30 | 17 | #include <linux/seqlock.h> |
---|
31 | 18 | #include <linux/swait.h> |
---|
32 | | -#include <linux/stop_machine.h> |
---|
33 | 19 | #include <linux/rcu_node_tree.h> |
---|
34 | 20 | |
---|
35 | 21 | #include "rcu_segcblist.h" |
---|
36 | 22 | |
---|
37 | | -/* |
---|
38 | | - * Dynticks per-CPU state. |
---|
39 | | - */ |
---|
40 | | -struct rcu_dynticks { |
---|
41 | | - long dynticks_nesting; /* Track process nesting level. */ |
---|
42 | | - long dynticks_nmi_nesting; /* Track irq/NMI nesting level. */ |
---|
43 | | - atomic_t dynticks; /* Even value for idle, else odd. */ |
---|
44 | | - bool rcu_need_heavy_qs; /* GP old, need heavy quiescent state. */ |
---|
45 | | - unsigned long rcu_qs_ctr; /* Light universal quiescent state ctr. */ |
---|
46 | | - bool rcu_urgent_qs; /* GP old need light quiescent state. */ |
---|
47 | | -#ifdef CONFIG_RCU_FAST_NO_HZ |
---|
48 | | - bool all_lazy; /* Are all CPU's CBs lazy? */ |
---|
49 | | - unsigned long nonlazy_posted; |
---|
50 | | - /* # times non-lazy CBs posted to CPU. */ |
---|
51 | | - unsigned long nonlazy_posted_snap; |
---|
52 | | - /* idle-period nonlazy_posted snapshot. */ |
---|
53 | | - unsigned long last_accelerate; |
---|
54 | | - /* Last jiffy CBs were accelerated. */ |
---|
55 | | - unsigned long last_advance_all; |
---|
56 | | - /* Last jiffy CBs were all advanced. */ |
---|
57 | | - int tick_nohz_enabled_snap; /* Previously seen value from sysfs. */ |
---|
58 | | -#endif /* #ifdef CONFIG_RCU_FAST_NO_HZ */ |
---|
59 | | -}; |
---|
60 | | - |
---|
61 | 23 | /* Communicate arguments to a workqueue handler. */ |
---|
62 | 24 | struct rcu_exp_work { |
---|
63 | | - smp_call_func_t rew_func; |
---|
64 | | - struct rcu_state *rew_rsp; |
---|
65 | 25 | unsigned long rew_s; |
---|
66 | 26 | struct work_struct rew_work; |
---|
67 | 27 | }; |
---|
.. | .. |
---|
81 | 41 | raw_spinlock_t __private lock; /* Root rcu_node's lock protects */ |
---|
82 | 42 | /* some rcu_state fields as well as */ |
---|
83 | 43 | /* following. */ |
---|
84 | | - unsigned long gp_seq; /* Track rsp->rcu_gp_seq. */ |
---|
85 | | - unsigned long gp_seq_needed; /* Track rsp->rcu_gp_seq_needed. */ |
---|
| 44 | + unsigned long gp_seq; /* Track rsp->gp_seq. */ |
---|
| 45 | + unsigned long gp_seq_needed; /* Track furthest future GP request. */ |
---|
86 | 46 | unsigned long completedqs; /* All QSes done for this node. */ |
---|
87 | 47 | unsigned long qsmask; /* CPUs or groups that need to switch in */ |
---|
88 | 48 | /* order for current grace period to proceed.*/ |
---|
.. | .. |
---|
96 | 56 | /* Initialized from ->qsmaskinitnext at the */ |
---|
97 | 57 | /* beginning of each grace period. */ |
---|
98 | 58 | unsigned long qsmaskinitnext; |
---|
| 59 | + unsigned long ofl_seq; /* CPU-hotplug operation sequence count. */ |
---|
99 | 60 | /* Online CPUs for next grace period. */ |
---|
100 | 61 | unsigned long expmask; /* CPUs or groups that need to check in */ |
---|
101 | 62 | /* to allow the current expedited GP */ |
---|
.. | .. |
---|
108 | 69 | /* Online CPUs for next expedited GP. */ |
---|
109 | 70 | /* Any CPU that has ever been online will */ |
---|
110 | 71 | /* have its bit set. */ |
---|
| 72 | + unsigned long cbovldmask; |
---|
| 73 | + /* CPUs experiencing callback overload. */ |
---|
111 | 74 | unsigned long ffmask; /* Fully functional CPUs. */ |
---|
112 | 75 | unsigned long grpmask; /* Mask to apply to parent qsmask. */ |
---|
113 | 76 | /* Only one bit will be set in this mask. */ |
---|
114 | | - int grplo; /* lowest-numbered CPU or group here. */ |
---|
115 | | - int grphi; /* highest-numbered CPU or group here. */ |
---|
116 | | - u8 grpnum; /* CPU/group number for next level up. */ |
---|
| 77 | + int grplo; /* lowest-numbered CPU here. */ |
---|
| 78 | + int grphi; /* highest-numbered CPU here. */ |
---|
| 79 | + u8 grpnum; /* group number for next level up. */ |
---|
117 | 80 | u8 level; /* root is at level 0. */ |
---|
118 | 81 | bool wait_blkd_tasks;/* Necessary to wait for blocked tasks to */ |
---|
119 | 82 | /* exit RCU read-side critical sections */ |
---|
.. | .. |
---|
170 | 133 | * are indexed relative to this interval rather than the global CPU ID space. |
---|
171 | 134 | * This generates the bit for a CPU in node-local masks. |
---|
172 | 135 | */ |
---|
173 | | -#define leaf_node_cpu_bit(rnp, cpu) (1UL << ((cpu) - (rnp)->grplo)) |
---|
| 136 | +#define leaf_node_cpu_bit(rnp, cpu) (BIT((cpu) - (rnp)->grplo)) |
---|
174 | 137 | |
---|
175 | 138 | /* |
---|
176 | 139 | * Union to allow "aggregate OR" operation on the need for a quiescent |
---|
.. | .. |
---|
187 | 150 | /* Per-CPU data for read-copy update. */ |
---|
188 | 151 | struct rcu_data { |
---|
189 | 152 | /* 1) quiescent-state and grace-period handling : */ |
---|
190 | | - unsigned long gp_seq; /* Track rsp->rcu_gp_seq counter. */ |
---|
191 | | - unsigned long gp_seq_needed; /* Track rsp->rcu_gp_seq_needed ctr. */ |
---|
192 | | - unsigned long rcu_qs_ctr_snap;/* Snapshot of rcu_qs_ctr to check */ |
---|
193 | | - /* for rcu_all_qs() invocations. */ |
---|
| 153 | + unsigned long gp_seq; /* Track rsp->gp_seq counter. */ |
---|
| 154 | + unsigned long gp_seq_needed; /* Track furthest future GP request. */ |
---|
194 | 155 | union rcu_noqs cpu_no_qs; /* No QSes yet for this CPU. */ |
---|
195 | 156 | bool core_needs_qs; /* Core waits for quiesc state. */ |
---|
196 | 157 | bool beenonline; /* CPU online at least once. */ |
---|
197 | 158 | bool gpwrap; /* Possible ->gp_seq wrap. */ |
---|
| 159 | + bool exp_deferred_qs; /* This CPU awaiting a deferred QS? */ |
---|
| 160 | + bool cpu_started; /* RCU watching this onlining CPU. */ |
---|
198 | 161 | struct rcu_node *mynode; /* This CPU's leaf of hierarchy */ |
---|
199 | 162 | unsigned long grpmask; /* Mask to apply to leaf qsmask. */ |
---|
200 | 163 | unsigned long ticks_this_gp; /* The number of scheduling-clock */ |
---|
201 | 164 | /* ticks this CPU has handled */ |
---|
202 | 165 | /* during and after the last grace */ |
---|
203 | 166 | /* period it is aware of. */ |
---|
| 167 | + struct irq_work defer_qs_iw; /* Obtain later scheduler attention. */ |
---|
| 168 | + bool defer_qs_iw_pending; /* Scheduler attention pending? */ |
---|
| 169 | + struct work_struct strict_work; /* Schedule readers for strict GPs. */ |
---|
204 | 170 | |
---|
205 | 171 | /* 2) batch handling */ |
---|
206 | 172 | struct rcu_segcblist cblist; /* Segmented callback list, with */ |
---|
.. | .. |
---|
208 | 174 | /* different grace periods. */ |
---|
209 | 175 | long qlen_last_fqs_check; |
---|
210 | 176 | /* qlen at last check for QS forcing */ |
---|
| 177 | + unsigned long n_cbs_invoked; /* # callbacks invoked since boot. */ |
---|
211 | 178 | unsigned long n_force_qs_snap; |
---|
212 | 179 | /* did other CPU force QS recently? */ |
---|
213 | 180 | long blimit; /* Upper limit on a processed batch */ |
---|
214 | 181 | |
---|
215 | 182 | /* 3) dynticks interface. */ |
---|
216 | | - struct rcu_dynticks *dynticks; /* Shared per-CPU dynticks state. */ |
---|
217 | 183 | int dynticks_snap; /* Per-GP tracking for dynticks. */ |
---|
218 | | - |
---|
219 | | - /* 4) reasons this CPU needed to be kicked by force_quiescent_state */ |
---|
220 | | - unsigned long dynticks_fqs; /* Kicked due to dynticks idle. */ |
---|
221 | | - unsigned long cond_resched_completed; |
---|
222 | | - /* Grace period that needs help */ |
---|
223 | | - /* from cond_resched(). */ |
---|
224 | | - |
---|
225 | | - /* 5) _rcu_barrier(), OOM callbacks, and expediting. */ |
---|
226 | | - struct rcu_head barrier_head; |
---|
| 184 | + long dynticks_nesting; /* Track process nesting level. */ |
---|
| 185 | + long dynticks_nmi_nesting; /* Track irq/NMI nesting level. */ |
---|
| 186 | + atomic_t dynticks; /* Even value for idle, else odd. */ |
---|
| 187 | + bool rcu_need_heavy_qs; /* GP old, so heavy quiescent state! */ |
---|
| 188 | + bool rcu_urgent_qs; /* GP old need light quiescent state. */ |
---|
| 189 | + bool rcu_forced_tick; /* Forced tick to provide QS. */ |
---|
| 190 | + bool rcu_forced_tick_exp; /* ... provide QS to expedited GP. */ |
---|
227 | 191 | #ifdef CONFIG_RCU_FAST_NO_HZ |
---|
228 | | - struct rcu_head oom_head; |
---|
| 192 | + unsigned long last_accelerate; /* Last jiffy CBs were accelerated. */ |
---|
| 193 | + unsigned long last_advance_all; /* Last jiffy CBs were all advanced. */ |
---|
| 194 | + int tick_nohz_enabled_snap; /* Previously seen value from sysfs. */ |
---|
229 | 195 | #endif /* #ifdef CONFIG_RCU_FAST_NO_HZ */ |
---|
| 196 | + |
---|
| 197 | + /* 4) rcu_barrier(), OOM callbacks, and expediting. */ |
---|
| 198 | + struct rcu_head barrier_head; |
---|
230 | 199 | int exp_dynticks_snap; /* Double-check need for IPI. */ |
---|
231 | 200 | |
---|
232 | | - /* 6) Callback offloading. */ |
---|
| 201 | + /* 5) Callback offloading. */ |
---|
233 | 202 | #ifdef CONFIG_RCU_NOCB_CPU |
---|
234 | | - struct rcu_head *nocb_head; /* CBs waiting for kthread. */ |
---|
235 | | - struct rcu_head **nocb_tail; |
---|
236 | | - atomic_long_t nocb_q_count; /* # CBs waiting for nocb */ |
---|
237 | | - atomic_long_t nocb_q_count_lazy; /* invocation (all stages). */ |
---|
238 | | - struct rcu_head *nocb_follower_head; /* CBs ready to invoke. */ |
---|
239 | | - struct rcu_head **nocb_follower_tail; |
---|
240 | | - struct swait_queue_head nocb_wq; /* For nocb kthreads to sleep on. */ |
---|
241 | | - struct task_struct *nocb_kthread; |
---|
| 203 | + struct swait_queue_head nocb_cb_wq; /* For nocb kthreads to sleep on. */ |
---|
| 204 | + struct task_struct *nocb_gp_kthread; |
---|
242 | 205 | raw_spinlock_t nocb_lock; /* Guard following pair of fields. */ |
---|
| 206 | + atomic_t nocb_lock_contended; /* Contention experienced. */ |
---|
243 | 207 | int nocb_defer_wakeup; /* Defer wakeup of nocb_kthread. */ |
---|
244 | 208 | struct timer_list nocb_timer; /* Enforce finite deferral. */ |
---|
| 209 | + unsigned long nocb_gp_adv_time; /* Last call_rcu() CB adv (jiffies). */ |
---|
245 | 210 | |
---|
246 | | - /* The following fields are used by the leader, hence own cacheline. */ |
---|
247 | | - struct rcu_head *nocb_gp_head ____cacheline_internodealigned_in_smp; |
---|
248 | | - /* CBs waiting for GP. */ |
---|
249 | | - struct rcu_head **nocb_gp_tail; |
---|
250 | | - bool nocb_leader_sleep; /* Is the nocb leader thread asleep? */ |
---|
251 | | - struct rcu_data *nocb_next_follower; |
---|
252 | | - /* Next follower in wakeup chain. */ |
---|
| 211 | + /* The following fields are used by call_rcu, hence own cacheline. */ |
---|
| 212 | + raw_spinlock_t nocb_bypass_lock ____cacheline_internodealigned_in_smp; |
---|
| 213 | + struct rcu_cblist nocb_bypass; /* Lock-contention-bypass CB list. */ |
---|
| 214 | + unsigned long nocb_bypass_first; /* Time (jiffies) of first enqueue. */ |
---|
| 215 | + unsigned long nocb_nobypass_last; /* Last ->cblist enqueue (jiffies). */ |
---|
| 216 | + int nocb_nobypass_count; /* # ->cblist enqueues at ^^^ time. */ |
---|
253 | 217 | |
---|
254 | | - /* The following fields are used by the follower, hence new cachline. */ |
---|
255 | | - struct rcu_data *nocb_leader ____cacheline_internodealigned_in_smp; |
---|
256 | | - /* Leader CPU takes GP-end wakeups. */ |
---|
| 218 | + /* The following fields are used by GP kthread, hence own cacheline. */ |
---|
| 219 | + raw_spinlock_t nocb_gp_lock ____cacheline_internodealigned_in_smp; |
---|
| 220 | + struct timer_list nocb_bypass_timer; /* Force nocb_bypass flush. */ |
---|
| 221 | + u8 nocb_gp_sleep; /* Is the nocb GP thread asleep? */ |
---|
| 222 | + u8 nocb_gp_bypass; /* Found a bypass on last scan? */ |
---|
| 223 | + u8 nocb_gp_gp; /* GP to wait for on last scan? */ |
---|
| 224 | + unsigned long nocb_gp_seq; /* If so, ->gp_seq to wait for. */ |
---|
| 225 | + unsigned long nocb_gp_loops; /* # passes through wait code. */ |
---|
| 226 | + struct swait_queue_head nocb_gp_wq; /* For nocb kthreads to sleep on. */ |
---|
| 227 | + bool nocb_cb_sleep; /* Is the nocb CB thread asleep? */ |
---|
| 228 | + struct task_struct *nocb_cb_kthread; |
---|
| 229 | + struct rcu_data *nocb_next_cb_rdp; |
---|
| 230 | + /* Next rcu_data in wakeup chain. */ |
---|
| 231 | + |
---|
| 232 | + /* The following fields are used by CB kthread, hence new cacheline. */ |
---|
| 233 | + struct rcu_data *nocb_gp_rdp ____cacheline_internodealigned_in_smp; |
---|
| 234 | + /* GP rdp takes GP-end wakeups. */ |
---|
257 | 235 | #endif /* #ifdef CONFIG_RCU_NOCB_CPU */ |
---|
| 236 | + |
---|
| 237 | + /* 6) RCU priority boosting. */ |
---|
| 238 | + struct task_struct *rcu_cpu_kthread_task; |
---|
| 239 | + /* rcuc per-CPU kthread or NULL. */ |
---|
| 240 | + unsigned int rcu_cpu_kthread_status; |
---|
| 241 | + char rcu_cpu_has_work; |
---|
258 | 242 | |
---|
259 | 243 | /* 7) Diagnostic data, including RCU CPU stall warnings. */ |
---|
260 | 244 | unsigned int softirq_snap; /* Snapshot of softirq activity. */ |
---|
.. | .. |
---|
266 | 250 | short rcu_ofl_gp_flags; /* ->gp_flags at last offline. */ |
---|
267 | 251 | unsigned long rcu_onl_gp_seq; /* ->gp_seq at last online. */ |
---|
268 | 252 | short rcu_onl_gp_flags; /* ->gp_flags at last online. */ |
---|
| 253 | + unsigned long last_fqs_resched; /* Time of last rcu_resched(). */ |
---|
269 | 254 | |
---|
270 | 255 | int cpu; |
---|
271 | | - struct rcu_state *rsp; |
---|
272 | 256 | }; |
---|
273 | 257 | |
---|
274 | 258 | /* Values for nocb_defer_wakeup field in struct rcu_data. */ |
---|
.. | .. |
---|
314 | 298 | struct rcu_node *level[RCU_NUM_LVLS + 1]; |
---|
315 | 299 | /* Hierarchy levels (+1 to */ |
---|
316 | 300 | /* shut bogus gcc warning) */ |
---|
317 | | - struct rcu_data __percpu *rda; /* pointer of percu rcu_data. */ |
---|
318 | | - call_rcu_func_t call; /* call_rcu() flavor. */ |
---|
319 | 301 | int ncpus; /* # CPUs seen so far. */ |
---|
320 | 302 | |
---|
321 | 303 | /* The following fields are guarded by the root rcu_node's lock. */ |
---|
.. | .. |
---|
323 | 305 | u8 boost ____cacheline_internodealigned_in_smp; |
---|
324 | 306 | /* Subject to priority boost. */ |
---|
325 | 307 | unsigned long gp_seq; /* Grace-period sequence #. */ |
---|
| 308 | + unsigned long gp_max; /* Maximum GP duration in */ |
---|
| 309 | + /* jiffies. */ |
---|
326 | 310 | struct task_struct *gp_kthread; /* Task for grace periods. */ |
---|
327 | 311 | struct swait_queue_head gp_wq; /* Where GP task waits. */ |
---|
328 | 312 | short gp_flags; /* Commands for GP task. */ |
---|
329 | 313 | short gp_state; /* GP kthread sleep state. */ |
---|
| 314 | + unsigned long gp_wake_time; /* Last GP kthread wake. */ |
---|
| 315 | + unsigned long gp_wake_seq; /* ->gp_seq at ^^^. */ |
---|
330 | 316 | |
---|
331 | 317 | /* End of fields guarded by root rcu_node's lock. */ |
---|
332 | 318 | |
---|
.. | .. |
---|
334 | 320 | atomic_t barrier_cpu_count; /* # CPUs waiting on. */ |
---|
335 | 321 | struct completion barrier_completion; /* Wake at barrier end. */ |
---|
336 | 322 | unsigned long barrier_sequence; /* ++ at start and end of */ |
---|
337 | | - /* _rcu_barrier(). */ |
---|
| 323 | + /* rcu_barrier(). */ |
---|
338 | 324 | /* End of fields guarded by barrier_mutex. */ |
---|
339 | 325 | |
---|
340 | 326 | struct mutex exp_mutex; /* Serialize expedited GP. */ |
---|
.. | .. |
---|
343 | 329 | atomic_t expedited_need_qs; /* # CPUs left to check in. */ |
---|
344 | 330 | struct swait_queue_head expedited_wq; /* Wait for check-ins. */ |
---|
345 | 331 | int ncpus_snap; /* # CPUs seen last time. */ |
---|
| 332 | + u8 cbovld; /* Callback overload now? */ |
---|
| 333 | + u8 cbovldnext; /* ^ ^ next time? */ |
---|
346 | 334 | |
---|
347 | 335 | unsigned long jiffies_force_qs; /* Time at which to invoke */ |
---|
348 | 336 | /* force_quiescent_state(). */ |
---|
.. | .. |
---|
352 | 340 | /* force_quiescent_state(). */ |
---|
353 | 341 | unsigned long gp_start; /* Time at which GP started, */ |
---|
354 | 342 | /* but in jiffies. */ |
---|
| 343 | + unsigned long gp_end; /* Time last GP ended, again */ |
---|
| 344 | + /* in jiffies. */ |
---|
355 | 345 | unsigned long gp_activity; /* Time of last GP kthread */ |
---|
356 | 346 | /* activity in jiffies. */ |
---|
357 | 347 | unsigned long gp_req_activity; /* Time of last GP request */ |
---|
.. | .. |
---|
362 | 352 | /* a reluctant CPU. */ |
---|
363 | 353 | unsigned long n_force_qs_gpstart; /* Snapshot of n_force_qs at */ |
---|
364 | 354 | /* GP start. */ |
---|
365 | | - unsigned long gp_max; /* Maximum GP duration in */ |
---|
366 | | - /* jiffies. */ |
---|
367 | 355 | const char *name; /* Name of structure. */ |
---|
368 | 356 | char abbr; /* Abbreviated name. */ |
---|
369 | | - struct list_head flavors; /* List of RCU flavors. */ |
---|
370 | 357 | |
---|
371 | | - spinlock_t ofl_lock ____cacheline_internodealigned_in_smp; |
---|
| 358 | + raw_spinlock_t ofl_lock ____cacheline_internodealigned_in_smp; |
---|
372 | 359 | /* Synchronize offline with */ |
---|
373 | 360 | /* GP pre-initialization. */ |
---|
374 | 361 | }; |
---|
.. | .. |
---|
376 | 363 | /* Values for rcu_state structure's gp_flags field. */ |
---|
377 | 364 | #define RCU_GP_FLAG_INIT 0x1 /* Need grace-period initialization. */ |
---|
378 | 365 | #define RCU_GP_FLAG_FQS 0x2 /* Need grace-period quiescent-state forcing. */ |
---|
| 366 | +#define RCU_GP_FLAG_OVLD 0x4 /* Experiencing callback overload. */ |
---|
379 | 367 | |
---|
380 | 368 | /* Values for rcu_state structure's gp_state field. */ |
---|
381 | 369 | #define RCU_GP_IDLE 0 /* Initial state and no GP in progress. */ |
---|
.. | .. |
---|
388 | 376 | #define RCU_GP_CLEANUP 7 /* Grace-period cleanup started. */ |
---|
389 | 377 | #define RCU_GP_CLEANED 8 /* Grace-period cleanup complete. */ |
---|
390 | 378 | |
---|
391 | | -#ifndef RCU_TREE_NONCORE |
---|
392 | | -static const char * const gp_state_names[] = { |
---|
393 | | - "RCU_GP_IDLE", |
---|
394 | | - "RCU_GP_WAIT_GPS", |
---|
395 | | - "RCU_GP_DONE_GPS", |
---|
396 | | - "RCU_GP_ONOFF", |
---|
397 | | - "RCU_GP_INIT", |
---|
398 | | - "RCU_GP_WAIT_FQS", |
---|
399 | | - "RCU_GP_DOING_FQS", |
---|
400 | | - "RCU_GP_CLEANUP", |
---|
401 | | - "RCU_GP_CLEANED", |
---|
402 | | -}; |
---|
403 | | -#endif /* #ifndef RCU_TREE_NONCORE */ |
---|
404 | | - |
---|
405 | | -extern struct list_head rcu_struct_flavors; |
---|
406 | | - |
---|
407 | | -/* Sequence through rcu_state structures for each RCU flavor. */ |
---|
408 | | -#define for_each_rcu_flavor(rsp) \ |
---|
409 | | - list_for_each_entry((rsp), &rcu_struct_flavors, flavors) |
---|
410 | | - |
---|
411 | 379 | /* |
---|
412 | | - * RCU implementation internal declarations: |
---|
| 380 | + * In order to export the rcu_state name to the tracing tools, it |
---|
| 381 | + * needs to be added in the __tracepoint_string section. |
---|
| 382 | + * This requires defining a separate variable tp_<sname>_varname |
---|
| 383 | + * that points to the string being used, and this will allow |
---|
| 384 | + * the tracing userspace tools to be able to decipher the string |
---|
| 385 | + * address to the matching string. |
---|
413 | 386 | */ |
---|
414 | | -extern struct rcu_state rcu_sched_state; |
---|
415 | | - |
---|
416 | | -extern struct rcu_state rcu_bh_state; |
---|
417 | | - |
---|
418 | 387 | #ifdef CONFIG_PREEMPT_RCU |
---|
419 | | -extern struct rcu_state rcu_preempt_state; |
---|
420 | | -#endif /* #ifdef CONFIG_PREEMPT_RCU */ |
---|
| 388 | +#define RCU_ABBR 'p' |
---|
| 389 | +#define RCU_NAME_RAW "rcu_preempt" |
---|
| 390 | +#else /* #ifdef CONFIG_PREEMPT_RCU */ |
---|
| 391 | +#define RCU_ABBR 's' |
---|
| 392 | +#define RCU_NAME_RAW "rcu_sched" |
---|
| 393 | +#endif /* #else #ifdef CONFIG_PREEMPT_RCU */ |
---|
| 394 | +#ifndef CONFIG_TRACING |
---|
| 395 | +#define RCU_NAME RCU_NAME_RAW |
---|
| 396 | +#else /* #ifdef CONFIG_TRACING */ |
---|
| 397 | +static char rcu_name[] = RCU_NAME_RAW; |
---|
| 398 | +static const char *tp_rcu_varname __used __tracepoint_string = rcu_name; |
---|
| 399 | +#define RCU_NAME rcu_name |
---|
| 400 | +#endif /* #else #ifdef CONFIG_TRACING */ |
---|
421 | 401 | |
---|
422 | | -int rcu_dynticks_snap(struct rcu_dynticks *rdtp); |
---|
423 | | - |
---|
424 | | -#ifdef CONFIG_RCU_BOOST |
---|
425 | | -DECLARE_PER_CPU(unsigned int, rcu_cpu_kthread_status); |
---|
426 | | -DECLARE_PER_CPU(int, rcu_cpu_kthread_cpu); |
---|
427 | | -DECLARE_PER_CPU(unsigned int, rcu_cpu_kthread_loops); |
---|
428 | | -DECLARE_PER_CPU(char, rcu_cpu_has_work); |
---|
429 | | -#endif /* #ifdef CONFIG_RCU_BOOST */ |
---|
430 | | - |
---|
431 | | -#ifndef RCU_TREE_NONCORE |
---|
432 | | - |
---|
433 | | -/* Forward declarations for rcutree_plugin.h */ |
---|
| 402 | +/* Forward declarations for tree_plugin.h */ |
---|
434 | 403 | static void rcu_bootup_announce(void); |
---|
435 | | -static void rcu_preempt_note_context_switch(bool preempt); |
---|
| 404 | +static void rcu_qs(void); |
---|
436 | 405 | static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp); |
---|
437 | 406 | #ifdef CONFIG_HOTPLUG_CPU |
---|
438 | 407 | static bool rcu_preempt_has_tasks(struct rcu_node *rnp); |
---|
439 | 408 | #endif /* #ifdef CONFIG_HOTPLUG_CPU */ |
---|
440 | | -static void rcu_print_detail_task_stall(struct rcu_state *rsp); |
---|
441 | | -static int rcu_print_task_stall(struct rcu_node *rnp); |
---|
442 | 409 | static int rcu_print_task_exp_stall(struct rcu_node *rnp); |
---|
443 | | -static void rcu_preempt_check_blocked_tasks(struct rcu_state *rsp, |
---|
444 | | - struct rcu_node *rnp); |
---|
445 | | -static void rcu_preempt_check_callbacks(void); |
---|
446 | | -void call_rcu(struct rcu_head *head, rcu_callback_t func); |
---|
447 | | -static void __init __rcu_init_preempt(void); |
---|
448 | | -static void dump_blkd_tasks(struct rcu_state *rsp, struct rcu_node *rnp, |
---|
449 | | - int ncheck); |
---|
| 410 | +static void rcu_preempt_check_blocked_tasks(struct rcu_node *rnp); |
---|
| 411 | +static void rcu_flavor_sched_clock_irq(int user); |
---|
| 412 | +static void dump_blkd_tasks(struct rcu_node *rnp, int ncheck); |
---|
450 | 413 | static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags); |
---|
451 | 414 | static void rcu_preempt_boost_start_gp(struct rcu_node *rnp); |
---|
452 | | -static void invoke_rcu_callbacks_kthread(void); |
---|
453 | 415 | static bool rcu_is_callbacks_kthread(void); |
---|
454 | | -#ifdef CONFIG_RCU_BOOST |
---|
455 | | -static int rcu_spawn_one_boost_kthread(struct rcu_state *rsp, |
---|
456 | | - struct rcu_node *rnp); |
---|
457 | | -#endif /* #ifdef CONFIG_RCU_BOOST */ |
---|
| 416 | +static void rcu_cpu_kthread_setup(unsigned int cpu); |
---|
458 | 417 | static void __init rcu_spawn_boost_kthreads(void); |
---|
459 | 418 | static void rcu_prepare_kthreads(int cpu); |
---|
460 | 419 | static void rcu_cleanup_after_idle(void); |
---|
461 | 420 | static void rcu_prepare_for_idle(void); |
---|
462 | | -static void rcu_idle_count_callbacks_posted(void); |
---|
463 | 421 | static bool rcu_preempt_has_tasks(struct rcu_node *rnp); |
---|
464 | | -static void print_cpu_stall_info_begin(void); |
---|
465 | | -static void print_cpu_stall_info(struct rcu_state *rsp, int cpu); |
---|
466 | | -static void print_cpu_stall_info_end(void); |
---|
| 422 | +static bool rcu_preempt_need_deferred_qs(struct task_struct *t); |
---|
| 423 | +static void rcu_preempt_deferred_qs(struct task_struct *t); |
---|
467 | 424 | static void zero_cpu_stall_ticks(struct rcu_data *rdp); |
---|
468 | | -static void increment_cpu_stall_ticks(void); |
---|
469 | | -static bool rcu_nocb_cpu_needs_barrier(struct rcu_state *rsp, int cpu); |
---|
470 | 425 | static struct swait_queue_head *rcu_nocb_gp_get(struct rcu_node *rnp); |
---|
471 | 426 | static void rcu_nocb_gp_cleanup(struct swait_queue_head *sq); |
---|
472 | 427 | static void rcu_init_one_nocb(struct rcu_node *rnp); |
---|
473 | | -static bool __call_rcu_nocb(struct rcu_data *rdp, struct rcu_head *rhp, |
---|
474 | | - bool lazy, unsigned long flags); |
---|
475 | | -static bool rcu_nocb_adopt_orphan_cbs(struct rcu_data *my_rdp, |
---|
476 | | - struct rcu_data *rdp, |
---|
477 | | - unsigned long flags); |
---|
| 428 | +static bool rcu_nocb_flush_bypass(struct rcu_data *rdp, struct rcu_head *rhp, |
---|
| 429 | + unsigned long j); |
---|
| 430 | +static bool rcu_nocb_try_bypass(struct rcu_data *rdp, struct rcu_head *rhp, |
---|
| 431 | + bool *was_alldone, unsigned long flags); |
---|
| 432 | +static void __call_rcu_nocb_wake(struct rcu_data *rdp, bool was_empty, |
---|
| 433 | + unsigned long flags); |
---|
478 | 434 | static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp); |
---|
479 | 435 | static void do_nocb_deferred_wakeup(struct rcu_data *rdp); |
---|
480 | 436 | static void rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp); |
---|
481 | | -static void rcu_spawn_all_nocb_kthreads(int cpu); |
---|
| 437 | +static void rcu_spawn_cpu_nocb_kthread(int cpu); |
---|
482 | 438 | static void __init rcu_spawn_nocb_kthreads(void); |
---|
| 439 | +static void show_rcu_nocb_state(struct rcu_data *rdp); |
---|
| 440 | +static void rcu_nocb_lock(struct rcu_data *rdp); |
---|
| 441 | +static void rcu_nocb_unlock(struct rcu_data *rdp); |
---|
| 442 | +static void rcu_nocb_unlock_irqrestore(struct rcu_data *rdp, |
---|
| 443 | + unsigned long flags); |
---|
| 444 | +static void rcu_lockdep_assert_cblist_protected(struct rcu_data *rdp); |
---|
483 | 445 | #ifdef CONFIG_RCU_NOCB_CPU |
---|
484 | | -static void __init rcu_organize_nocb_kthreads(struct rcu_state *rsp); |
---|
485 | | -#endif /* #ifdef CONFIG_RCU_NOCB_CPU */ |
---|
486 | | -static bool init_nocb_callback_list(struct rcu_data *rdp); |
---|
| 446 | +static void __init rcu_organize_nocb_kthreads(void); |
---|
| 447 | +#define rcu_nocb_lock_irqsave(rdp, flags) \ |
---|
| 448 | +do { \ |
---|
| 449 | + if (!rcu_segcblist_is_offloaded(&(rdp)->cblist)) \ |
---|
| 450 | + local_irq_save(flags); \ |
---|
| 451 | + else \ |
---|
| 452 | + raw_spin_lock_irqsave(&(rdp)->nocb_lock, (flags)); \ |
---|
| 453 | +} while (0) |
---|
| 454 | +#else /* #ifdef CONFIG_RCU_NOCB_CPU */ |
---|
| 455 | +#define rcu_nocb_lock_irqsave(rdp, flags) local_irq_save(flags) |
---|
| 456 | +#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */ |
---|
| 457 | + |
---|
487 | 458 | static void rcu_bind_gp_kthread(void); |
---|
488 | | -static bool rcu_nohz_full_cpu(struct rcu_state *rsp); |
---|
| 459 | +static bool rcu_nohz_full_cpu(void); |
---|
489 | 460 | static void rcu_dynticks_task_enter(void); |
---|
490 | 461 | static void rcu_dynticks_task_exit(void); |
---|
| 462 | +static void rcu_dynticks_task_trace_enter(void); |
---|
| 463 | +static void rcu_dynticks_task_trace_exit(void); |
---|
491 | 464 | |
---|
492 | | -#ifdef CONFIG_SRCU |
---|
493 | | -void srcu_online_cpu(unsigned int cpu); |
---|
494 | | -void srcu_offline_cpu(unsigned int cpu); |
---|
495 | | -#else /* #ifdef CONFIG_SRCU */ |
---|
496 | | -void srcu_online_cpu(unsigned int cpu) { } |
---|
497 | | -void srcu_offline_cpu(unsigned int cpu) { } |
---|
498 | | -#endif /* #else #ifdef CONFIG_SRCU */ |
---|
499 | | - |
---|
500 | | -#endif /* #ifndef RCU_TREE_NONCORE */ |
---|
| 465 | +/* Forward declarations for tree_stall.h */ |
---|
| 466 | +static void record_gp_stall_check_time(void); |
---|
| 467 | +static void rcu_iw_handler(struct irq_work *iwp); |
---|
| 468 | +static void check_cpu_stall(struct rcu_data *rdp); |
---|
| 469 | +static void rcu_check_gp_start_stall(struct rcu_node *rnp, struct rcu_data *rdp, |
---|
| 470 | + const unsigned long gpssdelay); |
---|