2005-04-17 02:20:36 +04:00
|
|
|
/*
|
2009-09-18 21:28:19 +04:00
|
|
|
* Read-Copy Update mechanism for mutual exclusion
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
* 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
|
2013-12-03 22:02:52 +04:00
|
|
|
* along with this program; if not, you can access it online at
|
|
|
|
* http://www.gnu.org/licenses/gpl-2.0.html.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
2008-01-25 23:08:24 +03:00
|
|
|
* Copyright IBM Corporation, 2001
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
* Author: Dipankar Sarma <dipankar@in.ibm.com>
|
2009-09-18 21:28:19 +04:00
|
|
|
*
|
2006-10-04 13:17:21 +04:00
|
|
|
* Based on the original work by Paul McKenney <paulmck@us.ibm.com>
|
2005-04-17 02:20:36 +04:00
|
|
|
* and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
|
|
|
|
* Papers:
|
|
|
|
* http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
|
|
|
|
* http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
|
|
|
|
*
|
|
|
|
* For detailed explanation of Read-Copy Update mechanism see -
|
2009-09-18 21:28:19 +04:00
|
|
|
* http://lse.sourceforge.net/locking/rcupdate.html
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_RCUPDATE_H
|
|
|
|
#define __LINUX_RCUPDATE_H
|
|
|
|
|
2011-06-01 08:03:55 +04:00
|
|
|
#include <linux/types.h>
|
2010-04-29 01:39:09 +04:00
|
|
|
#include <linux/compiler.h>
|
2017-05-04 01:24:25 +03:00
|
|
|
#include <linux/atomic.h>
|
2016-05-02 21:58:56 +03:00
|
|
|
#include <linux/irqflags.h>
|
2017-05-04 01:24:25 +03:00
|
|
|
#include <linux/preempt.h>
|
|
|
|
#include <linux/bottom_half.h>
|
|
|
|
#include <linux/lockdep.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <linux/cpumask.h>
|
2015-04-15 00:08:58 +03:00
|
|
|
|
2010-08-14 03:16:25 +04:00
|
|
|
#define ULONG_CMP_GE(a, b) (ULONG_MAX / 2 >= (a) - (b))
|
|
|
|
#define ULONG_CMP_LT(a, b) (ULONG_MAX / 2 < (a) - (b))
|
2012-12-28 23:30:36 +04:00
|
|
|
#define ulong2long(a) (*(long *)(&(a)))
|
2010-08-14 03:16:25 +04:00
|
|
|
|
2009-06-25 20:08:16 +04:00
|
|
|
/* Exported common interfaces */
|
2018-07-03 20:44:44 +03:00
|
|
|
void call_rcu(struct rcu_head *head, rcu_callback_t func);
|
2014-07-01 23:22:23 +04:00
|
|
|
void rcu_barrier_tasks(void);
|
2018-07-03 20:44:44 +03:00
|
|
|
void synchronize_rcu(void);
|
2014-06-28 00:42:20 +04:00
|
|
|
|
2010-08-14 03:16:25 +04:00
|
|
|
#ifdef CONFIG_PREEMPT_RCU
|
|
|
|
|
2013-11-11 19:11:23 +04:00
|
|
|
void __rcu_read_lock(void);
|
|
|
|
void __rcu_read_unlock(void);
|
2010-08-18 01:18:46 +04:00
|
|
|
|
2010-08-14 03:16:25 +04:00
|
|
|
/*
|
|
|
|
* Defined as a macro as it is a very low level header included from
|
|
|
|
* areas that don't even know about current. This gives the rcu_read_lock()
|
|
|
|
* nesting depth, but makes sense only if CONFIG_PREEMPT_RCU -- in other
|
|
|
|
* types of kernel builds, the rcu_read_lock() nesting depth is unknowable.
|
|
|
|
*/
|
|
|
|
#define rcu_preempt_depth() (current->rcu_read_lock_nesting)
|
|
|
|
|
2010-08-18 01:18:46 +04:00
|
|
|
#else /* #ifdef CONFIG_PREEMPT_RCU */
|
|
|
|
|
|
|
|
static inline void __rcu_read_lock(void)
|
|
|
|
{
|
rcu: Don't disable preemption for Tiny and Tree RCU readers
Because preempt_disable() maps to barrier() for non-debug builds,
it forces the compiler to spill and reload registers. Because Tree
RCU and Tiny RCU now only appear in CONFIG_PREEMPT=n builds, these
barrier() instances generate needless extra code for each instance of
rcu_read_lock() and rcu_read_unlock(). This extra code slows down Tree
RCU and bloats Tiny RCU.
This commit therefore removes the preempt_disable() and preempt_enable()
from the non-preemptible implementations of __rcu_read_lock() and
__rcu_read_unlock(), respectively. However, for debug purposes,
preempt_disable() and preempt_enable() are still invoked if
CONFIG_PREEMPT_COUNT=y, because this allows detection of sleeping inside
atomic sections in non-preemptible kernels.
However, Tiny and Tree RCU operates by coalescing all RCU read-side
critical sections on a given CPU that lie between successive quiescent
states. It is therefore necessary to compensate for removing barriers
from __rcu_read_lock() and __rcu_read_unlock() by adding them to a
couple of the RCU functions invoked during quiescent states, namely to
rcu_all_qs() and rcu_note_context_switch(). However, note that the latter
is more paranoia than necessity, at least until link-time optimizations
become more aggressive.
This is based on an earlier patch by Paul E. McKenney, fixing
a bug encountered in kernels built with CONFIG_PREEMPT=n and
CONFIG_PREEMPT_COUNT=y.
Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
2015-07-31 02:55:38 +03:00
|
|
|
if (IS_ENABLED(CONFIG_PREEMPT_COUNT))
|
|
|
|
preempt_disable();
|
2010-08-18 01:18:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __rcu_read_unlock(void)
|
|
|
|
{
|
rcu: Don't disable preemption for Tiny and Tree RCU readers
Because preempt_disable() maps to barrier() for non-debug builds,
it forces the compiler to spill and reload registers. Because Tree
RCU and Tiny RCU now only appear in CONFIG_PREEMPT=n builds, these
barrier() instances generate needless extra code for each instance of
rcu_read_lock() and rcu_read_unlock(). This extra code slows down Tree
RCU and bloats Tiny RCU.
This commit therefore removes the preempt_disable() and preempt_enable()
from the non-preemptible implementations of __rcu_read_lock() and
__rcu_read_unlock(), respectively. However, for debug purposes,
preempt_disable() and preempt_enable() are still invoked if
CONFIG_PREEMPT_COUNT=y, because this allows detection of sleeping inside
atomic sections in non-preemptible kernels.
However, Tiny and Tree RCU operates by coalescing all RCU read-side
critical sections on a given CPU that lie between successive quiescent
states. It is therefore necessary to compensate for removing barriers
from __rcu_read_lock() and __rcu_read_unlock() by adding them to a
couple of the RCU functions invoked during quiescent states, namely to
rcu_all_qs() and rcu_note_context_switch(). However, note that the latter
is more paranoia than necessity, at least until link-time optimizations
become more aggressive.
This is based on an earlier patch by Paul E. McKenney, fixing
a bug encountered in kernels built with CONFIG_PREEMPT=n and
CONFIG_PREEMPT_COUNT=y.
Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
2015-07-31 02:55:38 +03:00
|
|
|
if (IS_ENABLED(CONFIG_PREEMPT_COUNT))
|
|
|
|
preempt_enable();
|
2010-08-18 01:18:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int rcu_preempt_depth(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
|
|
|
|
|
|
|
|
/* Internal to kernel */
|
2013-11-11 19:11:23 +04:00
|
|
|
void rcu_init(void);
|
2017-05-27 02:16:40 +03:00
|
|
|
extern int rcu_scheduler_active __read_mostly;
|
2014-10-21 18:53:02 +04:00
|
|
|
void rcu_check_callbacks(int user);
|
2016-02-26 21:43:44 +03:00
|
|
|
void rcu_report_dead(unsigned int cpu);
|
rcu: Migrate callbacks earlier in the CPU-offline timeline
RCU callbacks must be migrated away from an outgoing CPU, and this is
done near the end of the CPU-hotplug operation, after the outgoing CPU is
long gone. Unfortunately, this means that other CPU-hotplug callbacks
can execute while the outgoing CPU's callbacks are still immobilized
on the long-gone CPU's callback lists. If any of these CPU-hotplug
callbacks must wait, either directly or indirectly, for the invocation
of any of the immobilized RCU callbacks, the system will hang.
This commit avoids such hangs by migrating the callbacks away from the
outgoing CPU immediately upon its departure, shortly after the return
from __cpu_die() in takedown_cpu(). Thus, RCU is able to advance these
callbacks and invoke them, which allows all the after-the-fact CPU-hotplug
callbacks to wait on these RCU callbacks without risk of a hang.
While in the neighborhood, this commit also moves rcu_send_cbs_to_orphanage()
and rcu_adopt_orphan_cbs() under a pre-existing #ifdef to avoid including
dead code on the one hand and to avoid define-without-use warnings on the
other hand.
Reported-by: Jeffrey Hugo <jhugo@codeaurora.org>
Link: http://lkml.kernel.org/r/db9c91f6-1b17-6136-84f0-03c3c2581ab4@codeaurora.org
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Anna-Maria Gleixner <anna-maria@linutronix.de>
Cc: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Cc: Richard Weinberger <richard@nod.at>
2017-06-20 22:11:34 +03:00
|
|
|
void rcutree_migrate_callbacks(int cpu);
|
2012-07-11 22:26:30 +04:00
|
|
|
|
2014-04-27 10:15:35 +04:00
|
|
|
#ifdef CONFIG_RCU_STALL_COMMON
|
|
|
|
void rcu_sysrq_start(void);
|
|
|
|
void rcu_sysrq_end(void);
|
|
|
|
#else /* #ifdef CONFIG_RCU_STALL_COMMON */
|
2017-05-03 20:52:10 +03:00
|
|
|
static inline void rcu_sysrq_start(void) { }
|
|
|
|
static inline void rcu_sysrq_end(void) { }
|
2014-04-27 10:15:35 +04:00
|
|
|
#endif /* #else #ifdef CONFIG_RCU_STALL_COMMON */
|
|
|
|
|
2015-05-13 20:41:58 +03:00
|
|
|
#ifdef CONFIG_NO_HZ_FULL
|
2013-11-11 19:11:23 +04:00
|
|
|
void rcu_user_enter(void);
|
|
|
|
void rcu_user_exit(void);
|
2012-07-11 22:26:30 +04:00
|
|
|
#else
|
|
|
|
static inline void rcu_user_enter(void) { }
|
|
|
|
static inline void rcu_user_exit(void) { }
|
2015-05-13 20:41:58 +03:00
|
|
|
#endif /* CONFIG_NO_HZ_FULL */
|
2012-07-11 22:26:30 +04:00
|
|
|
|
2014-07-25 22:21:47 +04:00
|
|
|
#ifdef CONFIG_RCU_NOCB_CPU
|
|
|
|
void rcu_init_nohz(void);
|
|
|
|
#else /* #ifdef CONFIG_RCU_NOCB_CPU */
|
2017-05-03 20:52:10 +03:00
|
|
|
static inline void rcu_init_nohz(void) { }
|
2014-07-25 22:21:47 +04:00
|
|
|
#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
|
|
|
|
|
2012-02-03 03:42:04 +04:00
|
|
|
/**
|
|
|
|
* RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
|
|
|
|
* @a: Code that RCU needs to pay attention to.
|
|
|
|
*
|
2018-07-08 04:12:26 +03:00
|
|
|
* RCU read-side critical sections are forbidden in the inner idle loop,
|
|
|
|
* that is, between the rcu_idle_enter() and the rcu_idle_exit() -- RCU
|
|
|
|
* will happily ignore any such read-side critical sections. However,
|
|
|
|
* things like powertop need tracepoints in the inner idle loop.
|
2012-02-03 03:42:04 +04:00
|
|
|
*
|
|
|
|
* This macro provides the way out: RCU_NONIDLE(do_something_with_RCU())
|
2016-04-20 19:22:15 +03:00
|
|
|
* will tell RCU that it needs to pay attention, invoke its argument
|
|
|
|
* (in this example, calling the do_something_with_RCU() function),
|
2012-02-03 03:42:04 +04:00
|
|
|
* and then tell RCU to go back to ignoring this CPU. It is permissible
|
2016-04-20 19:22:15 +03:00
|
|
|
* to nest RCU_NONIDLE() wrappers, but not indefinitely (but the limit is
|
|
|
|
* on the order of a million or so, even on 32-bit systems). It is
|
|
|
|
* not legal to block within RCU_NONIDLE(), nor is it permissible to
|
|
|
|
* transfer control either into or out of RCU_NONIDLE()'s statement.
|
2012-02-03 03:42:04 +04:00
|
|
|
*/
|
|
|
|
#define RCU_NONIDLE(a) \
|
|
|
|
do { \
|
2015-10-31 10:59:01 +03:00
|
|
|
rcu_irq_enter_irqson(); \
|
2012-02-03 03:42:04 +04:00
|
|
|
do { a; } while (0); \
|
2015-10-31 10:59:01 +03:00
|
|
|
rcu_irq_exit_irqson(); \
|
2012-02-03 03:42:04 +04:00
|
|
|
} while (0)
|
|
|
|
|
2014-06-28 00:42:20 +04:00
|
|
|
/*
|
2018-05-14 23:52:27 +03:00
|
|
|
* Note a quasi-voluntary context switch for RCU-tasks's benefit.
|
|
|
|
* This is a macro rather than an inline function to avoid #include hell.
|
2014-06-28 00:42:20 +04:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_TASKS_RCU
|
2018-05-14 23:52:27 +03:00
|
|
|
#define rcu_tasks_qs(t) \
|
2014-06-28 00:42:20 +04:00
|
|
|
do { \
|
2015-03-04 01:57:58 +03:00
|
|
|
if (READ_ONCE((t)->rcu_tasks_holdout)) \
|
|
|
|
WRITE_ONCE((t)->rcu_tasks_holdout, false); \
|
2014-06-28 00:42:20 +04:00
|
|
|
} while (0)
|
2018-07-10 22:53:40 +03:00
|
|
|
#define rcu_note_voluntary_context_switch(t) rcu_tasks_qs(t)
|
2017-05-25 18:05:00 +03:00
|
|
|
void call_rcu_tasks(struct rcu_head *head, rcu_callback_t func);
|
|
|
|
void synchronize_rcu_tasks(void);
|
2017-05-25 18:51:48 +03:00
|
|
|
void exit_tasks_rcu_start(void);
|
|
|
|
void exit_tasks_rcu_finish(void);
|
2014-06-28 00:42:20 +04:00
|
|
|
#else /* #ifdef CONFIG_TASKS_RCU */
|
2018-05-14 23:52:27 +03:00
|
|
|
#define rcu_tasks_qs(t) do { } while (0)
|
2018-07-10 22:53:40 +03:00
|
|
|
#define rcu_note_voluntary_context_switch(t) do { } while (0)
|
2018-07-08 04:12:26 +03:00
|
|
|
#define call_rcu_tasks call_rcu
|
2018-07-06 21:46:47 +03:00
|
|
|
#define synchronize_rcu_tasks synchronize_rcu
|
2017-05-25 18:51:48 +03:00
|
|
|
static inline void exit_tasks_rcu_start(void) { }
|
|
|
|
static inline void exit_tasks_rcu_finish(void) { }
|
2014-06-28 00:42:20 +04:00
|
|
|
#endif /* #else #ifdef CONFIG_TASKS_RCU */
|
|
|
|
|
2014-07-01 22:26:57 +04:00
|
|
|
/**
|
2018-03-03 03:35:27 +03:00
|
|
|
* cond_resched_tasks_rcu_qs - Report potential quiescent states to RCU
|
2014-07-01 22:26:57 +04:00
|
|
|
*
|
|
|
|
* This macro resembles cond_resched(), except that it is defined to
|
|
|
|
* report potential quiescent states to RCU-tasks even if the cond_resched()
|
|
|
|
* machinery were to be shut off, as some advocate for PREEMPT kernels.
|
|
|
|
*/
|
2018-03-03 03:35:27 +03:00
|
|
|
#define cond_resched_tasks_rcu_qs() \
|
2014-07-01 22:26:57 +04:00
|
|
|
do { \
|
2018-05-14 23:52:27 +03:00
|
|
|
rcu_tasks_qs(current); \
|
2018-05-11 11:30:34 +03:00
|
|
|
cond_resched(); \
|
2014-07-01 22:26:57 +04:00
|
|
|
} while (0)
|
|
|
|
|
2011-05-27 09:14:36 +04:00
|
|
|
/*
|
|
|
|
* Infrastructure to implement the synchronize_() primitives in
|
|
|
|
* TREE_RCU and rcu_barrier_() primitives in TINY_RCU.
|
|
|
|
*/
|
|
|
|
|
2014-09-22 22:00:48 +04:00
|
|
|
#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
|
"Tree RCU": scalable classic RCU implementation
This patch fixes a long-standing performance bug in classic RCU that
results in massive internal-to-RCU lock contention on systems with
more than a few hundred CPUs. Although this patch creates a separate
flavor of RCU for ease of review and patch maintenance, it is intended
to replace classic RCU.
This patch still handles stress better than does mainline, so I am still
calling it ready for inclusion. This patch is against the -tip tree.
Nevertheless, experience on an actual 1000+ CPU machine would still be
most welcome.
Most of the changes noted below were found while creating an rcutiny
(which should permit ejecting the current rcuclassic) and while doing
detailed line-by-line documentation.
Updates from v9 (http://lkml.org/lkml/2008/12/2/334):
o Fixes from remainder of line-by-line code walkthrough,
including comment spelling, initialization, undesirable
narrowing due to type conversion, removing redundant memory
barriers, removing redundant local-variable initialization,
and removing redundant local variables.
I do not believe that any of these fixes address the CPU-hotplug
issues that Andi Kleen was seeing, but please do give it a whirl
in case the machine is smarter than I am.
A writeup from the walkthrough may be found at the following
URL, in case you are suffering from terminal insomnia or
masochism:
http://www.kernel.org/pub/linux/kernel/people/paulmck/tmp/rcutree-walkthrough.2008.12.16a.pdf
o Made rcutree tracing use seq_file, as suggested some time
ago by Lai Jiangshan.
o Added a .csv variant of the rcudata debugfs trace file, to allow
people having thousands of CPUs to drop the data into
a spreadsheet. Tested with oocalc and gnumeric. Updated
documentation to suit.
Updates from v8 (http://lkml.org/lkml/2008/11/15/139):
o Fix a theoretical race between grace-period initialization and
force_quiescent_state() that could occur if more than three
jiffies were required to carry out the grace-period
initialization. Which it might, if you had enough CPUs.
o Apply Ingo's printk-standardization patch.
o Substitute local variables for repeated accesses to global
variables.
o Fix comment misspellings and redundant (but harmless) increments
of ->n_rcu_pending (this latter after having explicitly added it).
o Apply checkpatch fixes.
Updates from v7 (http://lkml.org/lkml/2008/10/10/291):
o Fixed a number of problems noted by Gautham Shenoy, including
the cpu-stall-detection bug that he was having difficulty
convincing me was real. ;-)
o Changed cpu-stall detection to wait for ten seconds rather than
three in order to reduce false positive, as suggested by Ingo
Molnar.
o Produced a design document (http://lwn.net/Articles/305782/).
The act of writing this document uncovered a number of both
theoretical and "here and now" bugs as noted below.
o Fix dynticks_nesting accounting confusion, simplify WARN_ON()
condition, fix kerneldoc comments, and add memory barriers
in dynticks interface functions.
o Add more data to tracing.
o Remove unused "rcu_barrier" field from rcu_data structure.
o Count calls to rcu_pending() from scheduling-clock interrupt
to use as a surrogate timebase should jiffies stop counting.
o Fix a theoretical race between force_quiescent_state() and
grace-period initialization. Yes, initialization does have to
go on for some jiffies for this race to occur, but given enough
CPUs...
Updates from v6 (http://lkml.org/lkml/2008/9/23/448):
o Fix a number of checkpatch.pl complaints.
o Apply review comments from Ingo Molnar and Lai Jiangshan
on the stall-detection code.
o Fix several bugs in !CONFIG_SMP builds.
o Fix a misspelled config-parameter name so that RCU now announces
at boot time if stall detection is configured.
o Run tests on numerous combinations of configurations parameters,
which after the fixes above, now build and run correctly.
Updates from v5 (http://lkml.org/lkml/2008/9/15/92, bad subject line):
o Fix a compiler error in the !CONFIG_FANOUT_EXACT case (blew a
changeset some time ago, and finally got around to retesting
this option).
o Fix some tracing bugs in rcupreempt that caused incorrect
totals to be printed.
o I now test with a more brutal random-selection online/offline
script (attached). Probably more brutal than it needs to be
on the people reading it as well, but so it goes.
o A number of optimizations and usability improvements:
o Make rcu_pending() ignore the grace-period timeout when
there is no grace period in progress.
o Make force_quiescent_state() avoid going for a global
lock in the case where there is no grace period in
progress.
o Rearrange struct fields to improve struct layout.
o Make call_rcu() initiate a grace period if RCU was
idle, rather than waiting for the next scheduling
clock interrupt.
o Invoke rcu_irq_enter() and rcu_irq_exit() only when
idle, as suggested by Andi Kleen. I still don't
completely trust this change, and might back it out.
o Make CONFIG_RCU_TRACE be the single config variable
manipulated for all forms of RCU, instead of the prior
confusion.
o Document tracing files and formats for both rcupreempt
and rcutree.
Updates from v4 for those missing v5 given its bad subject line:
o Separated dynticks interface so that NMIs and irqs call separate
functions, greatly simplifying it. In particular, this code
no longer requires a proof of correctness. ;-)
o Separated dynticks state out into its own per-CPU structure,
avoiding the duplicated accounting.
o The case where a dynticks-idle CPU runs an irq handler that
invokes call_rcu() is now correctly handled, forcing that CPU
out of dynticks-idle mode.
o Review comments have been applied (thank you all!!!).
For but one example, fixed the dynticks-ordering issue that
Manfred pointed out, saving me much debugging. ;-)
o Adjusted rcuclassic and rcupreempt to handle dynticks changes.
Attached is an updated patch to Classic RCU that applies a hierarchy,
greatly reducing the contention on the top-level lock for large machines.
This passes 10-hour concurrent rcutorture and online-offline testing on
128-CPU ppc64 without dynticks enabled, and exposes some timekeeping
bugs in presence of dynticks (exciting working on a system where
"sleep 1" hangs until interrupted...), which were fixed in the
2.6.27 kernel. It is getting more reliable than mainline by some
measures, so the next version will be against -tip for inclusion.
See also Manfred Spraul's recent patches (or his earlier work from
2004 at http://marc.info/?l=linux-kernel&m=108546384711797&w=2).
We will converge onto a common patch in the fullness of time, but are
currently exploring different regions of the design space. That said,
I have already gratefully stolen quite a few of Manfred's ideas.
This patch provides CONFIG_RCU_FANOUT, which controls the bushiness
of the RCU hierarchy. Defaults to 32 on 32-bit machines and 64 on
64-bit machines. If CONFIG_NR_CPUS is less than CONFIG_RCU_FANOUT,
there is no hierarchy. By default, the RCU initialization code will
adjust CONFIG_RCU_FANOUT to balance the hierarchy, so strongly NUMA
architectures may choose to set CONFIG_RCU_FANOUT_EXACT to disable
this balancing, allowing the hierarchy to be exactly aligned to the
underlying hardware. Up to two levels of hierarchy are permitted
(in addition to the root node), allowing up to 16,384 CPUs on 32-bit
systems and up to 262,144 CPUs on 64-bit systems. I just know that I
am going to regret saying this, but this seems more than sufficient
for the foreseeable future. (Some architectures might wish to set
CONFIG_RCU_FANOUT=4, which would limit such architectures to 64 CPUs.
If this becomes a real problem, additional levels can be added, but I
doubt that it will make a significant difference on real hardware.)
In the common case, a given CPU will manipulate its private rcu_data
structure and the rcu_node structure that it shares with its immediate
neighbors. This can reduce both lock and memory contention by multiple
orders of magnitude, which should eliminate the need for the strange
manipulations that are reported to be required when running Linux on
very large systems.
Some shortcomings:
o More bugs will probably surface as a result of an ongoing
line-by-line code inspection.
Patches will be provided as required.
o There are probably hangs, rcutorture failures, &c. Seems
quite stable on a 128-CPU machine, but that is kind of small
compared to 4096 CPUs. However, seems to do better than
mainline.
Patches will be provided as required.
o The memory footprint of this version is several KB larger
than rcuclassic.
A separate UP-only rcutiny patch will be provided, which will
reduce the memory footprint significantly, even compared
to the old rcuclassic. One such patch passes light testing,
and has a memory footprint smaller even than rcuclassic.
Initial reaction from various embedded guys was "it is not
worth it", so am putting it aside.
Credits:
o Manfred Spraul for ideas, review comments, and bugs spotted,
as well as some good friendly competition. ;-)
o Josh Triplett, Ingo Molnar, Peter Zijlstra, Mathieu Desnoyers,
Lai Jiangshan, Andi Kleen, Andy Whitcroft, and Andrew Morton
for reviews and comments.
o Thomas Gleixner for much-needed help with some timer issues
(see patches below).
o Jon M. Tollefson, Tim Pepper, Andrew Theurer, Jose R. Santos,
Andy Whitcroft, Darrick Wong, Nishanth Aravamudan, Anton
Blanchard, Dave Kleikamp, and Nathan Lynch for keeping machines
alive despite my heavy abuse^Wtesting.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-12-18 23:55:32 +03:00
|
|
|
#include <linux/rcutree.h>
|
2013-03-27 19:44:00 +04:00
|
|
|
#elif defined(CONFIG_TINY_RCU)
|
rcu: "Tiny RCU", The Bloatwatch Edition
This patch is a version of RCU designed for !SMP provided for a
small-footprint RCU implementation. In particular, the
implementation of synchronize_rcu() is extremely lightweight and
high performance. It passes rcutorture testing in each of the
four relevant configurations (combinations of NO_HZ and PREEMPT)
on x86. This saves about 1K bytes compared to old Classic RCU
(which is no longer in mainline), and more than three kilobytes
compared to Hierarchical RCU (updated to 2.6.30):
CONFIG_TREE_RCU:
text data bss dec filename
183 4 0 187 kernel/rcupdate.o
2783 520 36 3339 kernel/rcutree.o
3526 Total (vs 4565 for v7)
CONFIG_TREE_PREEMPT_RCU:
text data bss dec filename
263 4 0 267 kernel/rcupdate.o
4594 776 52 5422 kernel/rcutree.o
5689 Total (6155 for v7)
CONFIG_TINY_RCU:
text data bss dec filename
96 4 0 100 kernel/rcupdate.o
734 24 0 758 kernel/rcutiny.o
858 Total (vs 848 for v7)
The above is for x86. Your mileage may vary on other platforms.
Further compression is possible, but is being procrastinated.
Changes from v7 (http://lkml.org/lkml/2009/10/9/388)
o Apply Lai Jiangshan's review comments (aside from
might_sleep() in synchronize_sched(), which is covered by SMP builds).
o Fix up expedited primitives.
Changes from v6 (http://lkml.org/lkml/2009/9/23/293).
o Forward ported to put it into the 2.6.33 stream.
o Added lockdep support.
o Make lightweight rcu_barrier.
Changes from v5 (http://lkml.org/lkml/2009/6/23/12).
o Ported to latest pre-2.6.32 merge window kernel.
- Renamed rcu_qsctr_inc() to rcu_sched_qs().
- Renamed rcu_bh_qsctr_inc() to rcu_bh_qs().
- Provided trivial rcu_cpu_notify().
- Provided trivial exit_rcu().
- Provided trivial rcu_needs_cpu().
- Fixed up the rcu_*_enter/exit() functions in linux/hardirq.h.
o Removed the dependence on EMBEDDED, with a view to making
TINY_RCU default for !SMP at some time in the future.
o Added (trivial) support for expedited grace periods.
Changes from v4 (http://lkml.org/lkml/2009/5/2/91) include:
o Squeeze the size down a bit further by removing the
->completed field from struct rcu_ctrlblk.
o This permits synchronize_rcu() to become the empty function.
Previous concerns about rcutorture were unfounded, as
rcutorture correctly handles a constant value from
rcu_batches_completed() and rcu_batches_completed_bh().
Changes from v3 (http://lkml.org/lkml/2009/3/29/221) include:
o Changed rcu_batches_completed(), rcu_batches_completed_bh()
rcu_enter_nohz(), rcu_exit_nohz(), rcu_nmi_enter(), and
rcu_nmi_exit(), to be static inlines, as suggested by David
Howells. Doing this saves about 100 bytes from rcutiny.o.
(The numbers between v3 and this v4 of the patch are not directly
comparable, since they are against different versions of Linux.)
Changes from v2 (http://lkml.org/lkml/2009/2/3/333) include:
o Fix whitespace issues.
o Change short-circuit "||" operator to instead be "+" in order
to fix performance bug noted by "kraai" on LWN.
(http://lwn.net/Articles/324348/)
Changes from v1 (http://lkml.org/lkml/2009/1/13/440) include:
o This version depends on EMBEDDED as well as !SMP, as suggested
by Ingo.
o Updated rcu_needs_cpu() to unconditionally return zero,
permitting the CPU to enter dynticks-idle mode at any time.
This works because callbacks can be invoked upon entry to
dynticks-idle mode.
o Paul is now OK with this being included, based on a poll at
the Kernel Miniconf at linux.conf.au, where about ten people said
that they cared about saving 900 bytes on single-CPU systems.
o Applies to both mainline and tip/core/rcu.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Acked-by: David Howells <dhowells@redhat.com>
Acked-by: Josh Triplett <josh@joshtriplett.org>
Reviewed-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: avi@redhat.com
Cc: mtosatti@redhat.com
LKML-Reference: <12565226351355-git-send-email->
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-26 05:03:50 +03:00
|
|
|
#include <linux/rcutiny.h>
|
"Tree RCU": scalable classic RCU implementation
This patch fixes a long-standing performance bug in classic RCU that
results in massive internal-to-RCU lock contention on systems with
more than a few hundred CPUs. Although this patch creates a separate
flavor of RCU for ease of review and patch maintenance, it is intended
to replace classic RCU.
This patch still handles stress better than does mainline, so I am still
calling it ready for inclusion. This patch is against the -tip tree.
Nevertheless, experience on an actual 1000+ CPU machine would still be
most welcome.
Most of the changes noted below were found while creating an rcutiny
(which should permit ejecting the current rcuclassic) and while doing
detailed line-by-line documentation.
Updates from v9 (http://lkml.org/lkml/2008/12/2/334):
o Fixes from remainder of line-by-line code walkthrough,
including comment spelling, initialization, undesirable
narrowing due to type conversion, removing redundant memory
barriers, removing redundant local-variable initialization,
and removing redundant local variables.
I do not believe that any of these fixes address the CPU-hotplug
issues that Andi Kleen was seeing, but please do give it a whirl
in case the machine is smarter than I am.
A writeup from the walkthrough may be found at the following
URL, in case you are suffering from terminal insomnia or
masochism:
http://www.kernel.org/pub/linux/kernel/people/paulmck/tmp/rcutree-walkthrough.2008.12.16a.pdf
o Made rcutree tracing use seq_file, as suggested some time
ago by Lai Jiangshan.
o Added a .csv variant of the rcudata debugfs trace file, to allow
people having thousands of CPUs to drop the data into
a spreadsheet. Tested with oocalc and gnumeric. Updated
documentation to suit.
Updates from v8 (http://lkml.org/lkml/2008/11/15/139):
o Fix a theoretical race between grace-period initialization and
force_quiescent_state() that could occur if more than three
jiffies were required to carry out the grace-period
initialization. Which it might, if you had enough CPUs.
o Apply Ingo's printk-standardization patch.
o Substitute local variables for repeated accesses to global
variables.
o Fix comment misspellings and redundant (but harmless) increments
of ->n_rcu_pending (this latter after having explicitly added it).
o Apply checkpatch fixes.
Updates from v7 (http://lkml.org/lkml/2008/10/10/291):
o Fixed a number of problems noted by Gautham Shenoy, including
the cpu-stall-detection bug that he was having difficulty
convincing me was real. ;-)
o Changed cpu-stall detection to wait for ten seconds rather than
three in order to reduce false positive, as suggested by Ingo
Molnar.
o Produced a design document (http://lwn.net/Articles/305782/).
The act of writing this document uncovered a number of both
theoretical and "here and now" bugs as noted below.
o Fix dynticks_nesting accounting confusion, simplify WARN_ON()
condition, fix kerneldoc comments, and add memory barriers
in dynticks interface functions.
o Add more data to tracing.
o Remove unused "rcu_barrier" field from rcu_data structure.
o Count calls to rcu_pending() from scheduling-clock interrupt
to use as a surrogate timebase should jiffies stop counting.
o Fix a theoretical race between force_quiescent_state() and
grace-period initialization. Yes, initialization does have to
go on for some jiffies for this race to occur, but given enough
CPUs...
Updates from v6 (http://lkml.org/lkml/2008/9/23/448):
o Fix a number of checkpatch.pl complaints.
o Apply review comments from Ingo Molnar and Lai Jiangshan
on the stall-detection code.
o Fix several bugs in !CONFIG_SMP builds.
o Fix a misspelled config-parameter name so that RCU now announces
at boot time if stall detection is configured.
o Run tests on numerous combinations of configurations parameters,
which after the fixes above, now build and run correctly.
Updates from v5 (http://lkml.org/lkml/2008/9/15/92, bad subject line):
o Fix a compiler error in the !CONFIG_FANOUT_EXACT case (blew a
changeset some time ago, and finally got around to retesting
this option).
o Fix some tracing bugs in rcupreempt that caused incorrect
totals to be printed.
o I now test with a more brutal random-selection online/offline
script (attached). Probably more brutal than it needs to be
on the people reading it as well, but so it goes.
o A number of optimizations and usability improvements:
o Make rcu_pending() ignore the grace-period timeout when
there is no grace period in progress.
o Make force_quiescent_state() avoid going for a global
lock in the case where there is no grace period in
progress.
o Rearrange struct fields to improve struct layout.
o Make call_rcu() initiate a grace period if RCU was
idle, rather than waiting for the next scheduling
clock interrupt.
o Invoke rcu_irq_enter() and rcu_irq_exit() only when
idle, as suggested by Andi Kleen. I still don't
completely trust this change, and might back it out.
o Make CONFIG_RCU_TRACE be the single config variable
manipulated for all forms of RCU, instead of the prior
confusion.
o Document tracing files and formats for both rcupreempt
and rcutree.
Updates from v4 for those missing v5 given its bad subject line:
o Separated dynticks interface so that NMIs and irqs call separate
functions, greatly simplifying it. In particular, this code
no longer requires a proof of correctness. ;-)
o Separated dynticks state out into its own per-CPU structure,
avoiding the duplicated accounting.
o The case where a dynticks-idle CPU runs an irq handler that
invokes call_rcu() is now correctly handled, forcing that CPU
out of dynticks-idle mode.
o Review comments have been applied (thank you all!!!).
For but one example, fixed the dynticks-ordering issue that
Manfred pointed out, saving me much debugging. ;-)
o Adjusted rcuclassic and rcupreempt to handle dynticks changes.
Attached is an updated patch to Classic RCU that applies a hierarchy,
greatly reducing the contention on the top-level lock for large machines.
This passes 10-hour concurrent rcutorture and online-offline testing on
128-CPU ppc64 without dynticks enabled, and exposes some timekeeping
bugs in presence of dynticks (exciting working on a system where
"sleep 1" hangs until interrupted...), which were fixed in the
2.6.27 kernel. It is getting more reliable than mainline by some
measures, so the next version will be against -tip for inclusion.
See also Manfred Spraul's recent patches (or his earlier work from
2004 at http://marc.info/?l=linux-kernel&m=108546384711797&w=2).
We will converge onto a common patch in the fullness of time, but are
currently exploring different regions of the design space. That said,
I have already gratefully stolen quite a few of Manfred's ideas.
This patch provides CONFIG_RCU_FANOUT, which controls the bushiness
of the RCU hierarchy. Defaults to 32 on 32-bit machines and 64 on
64-bit machines. If CONFIG_NR_CPUS is less than CONFIG_RCU_FANOUT,
there is no hierarchy. By default, the RCU initialization code will
adjust CONFIG_RCU_FANOUT to balance the hierarchy, so strongly NUMA
architectures may choose to set CONFIG_RCU_FANOUT_EXACT to disable
this balancing, allowing the hierarchy to be exactly aligned to the
underlying hardware. Up to two levels of hierarchy are permitted
(in addition to the root node), allowing up to 16,384 CPUs on 32-bit
systems and up to 262,144 CPUs on 64-bit systems. I just know that I
am going to regret saying this, but this seems more than sufficient
for the foreseeable future. (Some architectures might wish to set
CONFIG_RCU_FANOUT=4, which would limit such architectures to 64 CPUs.
If this becomes a real problem, additional levels can be added, but I
doubt that it will make a significant difference on real hardware.)
In the common case, a given CPU will manipulate its private rcu_data
structure and the rcu_node structure that it shares with its immediate
neighbors. This can reduce both lock and memory contention by multiple
orders of magnitude, which should eliminate the need for the strange
manipulations that are reported to be required when running Linux on
very large systems.
Some shortcomings:
o More bugs will probably surface as a result of an ongoing
line-by-line code inspection.
Patches will be provided as required.
o There are probably hangs, rcutorture failures, &c. Seems
quite stable on a 128-CPU machine, but that is kind of small
compared to 4096 CPUs. However, seems to do better than
mainline.
Patches will be provided as required.
o The memory footprint of this version is several KB larger
than rcuclassic.
A separate UP-only rcutiny patch will be provided, which will
reduce the memory footprint significantly, even compared
to the old rcuclassic. One such patch passes light testing,
and has a memory footprint smaller even than rcuclassic.
Initial reaction from various embedded guys was "it is not
worth it", so am putting it aside.
Credits:
o Manfred Spraul for ideas, review comments, and bugs spotted,
as well as some good friendly competition. ;-)
o Josh Triplett, Ingo Molnar, Peter Zijlstra, Mathieu Desnoyers,
Lai Jiangshan, Andi Kleen, Andy Whitcroft, and Andrew Morton
for reviews and comments.
o Thomas Gleixner for much-needed help with some timer issues
(see patches below).
o Jon M. Tollefson, Tim Pepper, Andrew Theurer, Jose R. Santos,
Andy Whitcroft, Darrick Wong, Nishanth Aravamudan, Anton
Blanchard, Dave Kleikamp, and Nathan Lynch for keeping machines
alive despite my heavy abuse^Wtesting.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-12-18 23:55:32 +03:00
|
|
|
#else
|
|
|
|
#error "Unknown RCU implementation specified to kernel configuration"
|
2009-08-23 00:56:53 +04:00
|
|
|
#endif
|
2008-01-25 23:08:24 +03:00
|
|
|
|
2010-04-17 16:48:42 +04:00
|
|
|
/*
|
2018-01-24 01:48:33 +03:00
|
|
|
* The init_rcu_head_on_stack() and destroy_rcu_head_on_stack() calls
|
|
|
|
* are needed for dynamic initialization and destruction of rcu_head
|
|
|
|
* on the stack, and init_rcu_head()/destroy_rcu_head() are needed for
|
|
|
|
* dynamic initialization and destruction of statically allocated rcu_head
|
|
|
|
* structures. However, rcu_head structures allocated dynamically in the
|
|
|
|
* heap don't need any initialization.
|
2010-04-17 16:48:42 +04:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
|
2014-06-20 01:57:10 +04:00
|
|
|
void init_rcu_head(struct rcu_head *head);
|
|
|
|
void destroy_rcu_head(struct rcu_head *head);
|
2013-11-11 19:11:23 +04:00
|
|
|
void init_rcu_head_on_stack(struct rcu_head *head);
|
|
|
|
void destroy_rcu_head_on_stack(struct rcu_head *head);
|
2010-04-17 16:48:42 +04:00
|
|
|
#else /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
|
2017-05-03 20:52:10 +03:00
|
|
|
static inline void init_rcu_head(struct rcu_head *head) { }
|
|
|
|
static inline void destroy_rcu_head(struct rcu_head *head) { }
|
|
|
|
static inline void init_rcu_head_on_stack(struct rcu_head *head) { }
|
|
|
|
static inline void destroy_rcu_head_on_stack(struct rcu_head *head) { }
|
2010-04-17 16:48:42 +04:00
|
|
|
#endif /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
|
2010-04-17 16:48:39 +04:00
|
|
|
|
2012-01-24 00:41:26 +04:00
|
|
|
#if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU)
|
|
|
|
bool rcu_lockdep_current_cpu_online(void);
|
|
|
|
#else /* #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
|
2017-05-03 22:32:55 +03:00
|
|
|
static inline bool rcu_lockdep_current_cpu_online(void) { return true; }
|
2012-01-24 00:41:26 +04:00
|
|
|
#endif /* #else #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
|
|
|
|
|
2009-08-23 00:56:47 +04:00
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
|
2011-10-07 20:22:02 +04:00
|
|
|
static inline void rcu_lock_acquire(struct lockdep_map *map)
|
|
|
|
{
|
2014-01-20 22:20:06 +04:00
|
|
|
lock_acquire(map, 0, 0, 2, 0, NULL, _THIS_IP_);
|
2011-10-07 20:22:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_lock_release(struct lockdep_map *map)
|
|
|
|
{
|
|
|
|
lock_release(map, 1, _THIS_IP_);
|
|
|
|
}
|
|
|
|
|
2009-08-23 00:56:47 +04:00
|
|
|
extern struct lockdep_map rcu_lock_map;
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
extern struct lockdep_map rcu_bh_lock_map;
|
|
|
|
extern struct lockdep_map rcu_sched_lock_map;
|
2013-10-28 20:22:24 +04:00
|
|
|
extern struct lockdep_map rcu_callback_map;
|
2014-03-12 20:37:24 +04:00
|
|
|
int debug_lockdep_rcu_enabled(void);
|
2014-07-09 02:17:59 +04:00
|
|
|
int rcu_read_lock_held(void);
|
2013-11-11 19:11:23 +04:00
|
|
|
int rcu_read_lock_bh_held(void);
|
2015-05-26 18:48:34 +03:00
|
|
|
int rcu_read_lock_sched_held(void);
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
|
|
|
|
#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
|
2011-10-07 20:22:03 +04:00
|
|
|
# define rcu_lock_acquire(a) do { } while (0)
|
|
|
|
# define rcu_lock_release(a) do { } while (0)
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
|
|
|
|
static inline int rcu_read_lock_held(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int rcu_read_lock_bh_held(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int rcu_read_lock_sched_held(void)
|
|
|
|
{
|
2016-03-23 18:11:48 +03:00
|
|
|
return !preemptible();
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
}
|
|
|
|
#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROVE_RCU
|
|
|
|
|
2015-06-19 01:50:02 +03:00
|
|
|
/**
|
|
|
|
* RCU_LOCKDEP_WARN - emit lockdep splat if specified condition is met
|
|
|
|
* @c: condition to check
|
|
|
|
* @s: informative message
|
|
|
|
*/
|
|
|
|
#define RCU_LOCKDEP_WARN(c, s) \
|
|
|
|
do { \
|
|
|
|
static bool __section(.data.unlikely) __warned; \
|
|
|
|
if (debug_lockdep_rcu_enabled() && !__warned && (c)) { \
|
|
|
|
__warned = true; \
|
|
|
|
lockdep_rcu_suspicious(__FILE__, __LINE__, s); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2012-01-13 01:49:19 +04:00
|
|
|
#if defined(CONFIG_PROVE_RCU) && !defined(CONFIG_PREEMPT_RCU)
|
|
|
|
static inline void rcu_preempt_sleep_check(void)
|
|
|
|
{
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(lock_is_held(&rcu_lock_map),
|
|
|
|
"Illegal context switch in RCU read-side critical section");
|
2012-01-13 01:49:19 +04:00
|
|
|
}
|
|
|
|
#else /* #ifdef CONFIG_PROVE_RCU */
|
2017-05-03 20:52:10 +03:00
|
|
|
static inline void rcu_preempt_sleep_check(void) { }
|
2012-01-13 01:49:19 +04:00
|
|
|
#endif /* #else #ifdef CONFIG_PROVE_RCU */
|
|
|
|
|
2011-05-24 19:31:09 +04:00
|
|
|
#define rcu_sleep_check() \
|
|
|
|
do { \
|
2012-01-13 01:49:19 +04:00
|
|
|
rcu_preempt_sleep_check(); \
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map), \
|
|
|
|
"Illegal context switch in RCU-bh read-side critical section"); \
|
|
|
|
RCU_LOCKDEP_WARN(lock_is_held(&rcu_sched_lock_map), \
|
|
|
|
"Illegal context switch in RCU-sched read-side critical section"); \
|
2011-05-24 19:31:09 +04:00
|
|
|
} while (0)
|
|
|
|
|
2010-04-29 01:39:09 +04:00
|
|
|
#else /* #ifdef CONFIG_PROVE_RCU */
|
|
|
|
|
2015-06-19 01:50:02 +03:00
|
|
|
#define RCU_LOCKDEP_WARN(c, s) do { } while (0)
|
2011-05-24 19:31:09 +04:00
|
|
|
#define rcu_sleep_check() do { } while (0)
|
2010-04-29 01:39:09 +04:00
|
|
|
|
|
|
|
#endif /* #else #ifdef CONFIG_PROVE_RCU */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper functions for rcu_dereference_check(), rcu_dereference_protected()
|
|
|
|
* and rcu_assign_pointer(). Some of these could be folded into their
|
|
|
|
* callers, but they are left separate in order to ease introduction of
|
2018-07-08 04:12:26 +03:00
|
|
|
* multiple pointers markings to match different RCU implementations
|
|
|
|
* (e.g., __srcu), should this make sense in the future.
|
2010-04-29 01:39:09 +04:00
|
|
|
*/
|
2010-09-14 04:24:21 +04:00
|
|
|
|
|
|
|
#ifdef __CHECKER__
|
|
|
|
#define rcu_dereference_sparse(p, space) \
|
|
|
|
((void)(((typeof(*p) space *)p) == p))
|
|
|
|
#else /* #ifdef __CHECKER__ */
|
|
|
|
#define rcu_dereference_sparse(p, space)
|
|
|
|
#endif /* #else #ifdef __CHECKER__ */
|
|
|
|
|
2010-04-29 01:39:09 +04:00
|
|
|
#define __rcu_access_pointer(p, space) \
|
2013-12-06 04:19:15 +04:00
|
|
|
({ \
|
2015-03-04 01:57:58 +03:00
|
|
|
typeof(*p) *_________p1 = (typeof(*p) *__force)READ_ONCE(p); \
|
2013-12-06 04:19:15 +04:00
|
|
|
rcu_dereference_sparse(p, space); \
|
|
|
|
((typeof(*p) __force __kernel *)(_________p1)); \
|
|
|
|
})
|
2010-04-29 01:39:09 +04:00
|
|
|
#define __rcu_dereference_check(p, c, space) \
|
2013-12-06 04:19:15 +04:00
|
|
|
({ \
|
2014-11-13 22:24:14 +03:00
|
|
|
/* Dependency order vs. p above. */ \
|
2017-10-24 13:22:48 +03:00
|
|
|
typeof(*p) *________p1 = (typeof(*p) *__force)READ_ONCE(p); \
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!(c), "suspicious rcu_dereference_check() usage"); \
|
2013-12-06 04:19:15 +04:00
|
|
|
rcu_dereference_sparse(p, space); \
|
2014-11-13 22:24:14 +03:00
|
|
|
((typeof(*p) __force __kernel *)(________p1)); \
|
2013-12-06 04:19:15 +04:00
|
|
|
})
|
2010-04-29 01:39:09 +04:00
|
|
|
#define __rcu_dereference_protected(p, c, space) \
|
2013-12-06 04:19:15 +04:00
|
|
|
({ \
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!(c), "suspicious rcu_dereference_protected() usage"); \
|
2013-12-06 04:19:15 +04:00
|
|
|
rcu_dereference_sparse(p, space); \
|
|
|
|
((typeof(*p) __force __kernel *)(p)); \
|
|
|
|
})
|
2016-07-01 23:44:53 +03:00
|
|
|
#define rcu_dereference_raw(p) \
|
|
|
|
({ \
|
|
|
|
/* Dependency order vs. p above. */ \
|
2017-10-24 13:22:48 +03:00
|
|
|
typeof(p) ________p1 = READ_ONCE(p); \
|
2016-07-01 23:44:53 +03:00
|
|
|
((typeof(*p) __force __kernel *)(________p1)); \
|
|
|
|
})
|
2010-04-29 01:39:09 +04:00
|
|
|
|
2013-11-11 21:59:34 +04:00
|
|
|
/**
|
|
|
|
* RCU_INITIALIZER() - statically initialize an RCU-protected global variable
|
|
|
|
* @v: The value to statically initialize with.
|
|
|
|
*/
|
|
|
|
#define RCU_INITIALIZER(v) (typeof(*(v)) __force __rcu *)(v)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rcu_assign_pointer() - assign to RCU-protected pointer
|
|
|
|
* @p: pointer to assign to
|
|
|
|
* @v: value to assign (publish)
|
|
|
|
*
|
|
|
|
* Assigns the specified value to the specified RCU-protected
|
|
|
|
* pointer, ensuring that any concurrent RCU readers will see
|
|
|
|
* any prior initialization.
|
|
|
|
*
|
|
|
|
* Inserts memory barriers on architectures that require them
|
|
|
|
* (which is most of them), and also prevents the compiler from
|
|
|
|
* reordering the code that initializes the structure after the pointer
|
|
|
|
* assignment. More importantly, this call documents which pointers
|
|
|
|
* will be dereferenced by RCU read-side code.
|
|
|
|
*
|
|
|
|
* In some special cases, you may use RCU_INIT_POINTER() instead
|
|
|
|
* of rcu_assign_pointer(). RCU_INIT_POINTER() is a bit faster due
|
|
|
|
* to the fact that it does not constrain either the CPU or the compiler.
|
|
|
|
* That said, using RCU_INIT_POINTER() when you should have used
|
|
|
|
* rcu_assign_pointer() is a very bad thing that results in
|
|
|
|
* impossible-to-diagnose memory corruption. So please be careful.
|
|
|
|
* See the RCU_INIT_POINTER() comment header for details.
|
|
|
|
*
|
|
|
|
* Note that rcu_assign_pointer() evaluates each of its arguments only
|
|
|
|
* once, appearances notwithstanding. One of the "extra" evaluations
|
|
|
|
* is in typeof() and the other visible only to sparse (__CHECKER__),
|
|
|
|
* neither of which actually execute the argument. As with most cpp
|
|
|
|
* macros, this execute-arguments-only-once property is important, so
|
|
|
|
* please be careful when making changes to rcu_assign_pointer() and the
|
|
|
|
* other macros that it invokes.
|
|
|
|
*/
|
2016-05-02 04:46:54 +03:00
|
|
|
#define rcu_assign_pointer(p, v) \
|
|
|
|
({ \
|
|
|
|
uintptr_t _r_a_p__v = (uintptr_t)(v); \
|
|
|
|
\
|
|
|
|
if (__builtin_constant_p(v) && (_r_a_p__v) == (uintptr_t)NULL) \
|
|
|
|
WRITE_ONCE((p), (typeof(p))(_r_a_p__v)); \
|
|
|
|
else \
|
|
|
|
smp_store_release(&p, RCU_INITIALIZER((typeof(p))_r_a_p__v)); \
|
|
|
|
_r_a_p__v; \
|
|
|
|
})
|
2010-04-29 01:39:09 +04:00
|
|
|
|
2017-08-29 18:50:11 +03:00
|
|
|
/**
|
|
|
|
* rcu_swap_protected() - swap an RCU and a regular pointer
|
|
|
|
* @rcu_ptr: RCU pointer
|
|
|
|
* @ptr: regular pointer
|
|
|
|
* @c: the conditions under which the dereference will take place
|
|
|
|
*
|
|
|
|
* Perform swap(@rcu_ptr, @ptr) where @rcu_ptr is an RCU-annotated pointer and
|
|
|
|
* @c is the argument that is passed to the rcu_dereference_protected() call
|
|
|
|
* used to read that pointer.
|
|
|
|
*/
|
|
|
|
#define rcu_swap_protected(rcu_ptr, ptr, c) do { \
|
|
|
|
typeof(ptr) __tmp = rcu_dereference_protected((rcu_ptr), (c)); \
|
|
|
|
rcu_assign_pointer((rcu_ptr), (ptr)); \
|
|
|
|
(ptr) = __tmp; \
|
|
|
|
} while (0)
|
|
|
|
|
2010-04-29 01:39:09 +04:00
|
|
|
/**
|
|
|
|
* rcu_access_pointer() - fetch RCU pointer with no dereferencing
|
|
|
|
* @p: The pointer to read
|
|
|
|
*
|
|
|
|
* Return the value of the specified RCU-protected pointer, but omit the
|
2017-10-09 20:30:58 +03:00
|
|
|
* lockdep checks for being in an RCU read-side critical section. This is
|
|
|
|
* useful when the value of this pointer is accessed, but the pointer is
|
|
|
|
* not dereferenced, for example, when testing an RCU-protected pointer
|
|
|
|
* against NULL. Although rcu_access_pointer() may also be used in cases
|
|
|
|
* where update-side locks prevent the value of the pointer from changing,
|
|
|
|
* you should instead use rcu_dereference_protected() for this use case.
|
2012-01-13 05:21:20 +04:00
|
|
|
*
|
|
|
|
* It is also permissible to use rcu_access_pointer() when read-side
|
|
|
|
* access to the pointer was removed at least one grace period ago, as
|
|
|
|
* is the case in the context of the RCU callback that is freeing up
|
|
|
|
* the data, or after a synchronize_rcu() returns. This can be useful
|
|
|
|
* when tearing down multi-linked structures after a grace period
|
|
|
|
* has elapsed.
|
2010-04-29 01:39:09 +04:00
|
|
|
*/
|
|
|
|
#define rcu_access_pointer(p) __rcu_access_pointer((p), __rcu)
|
|
|
|
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_dereference_check() - rcu_dereference with debug checking
|
2010-04-10 02:39:11 +04:00
|
|
|
* @p: The pointer to read, prior to dereferencing
|
|
|
|
* @c: The conditions under which the dereference will take place
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
*
|
2010-04-10 02:39:11 +04:00
|
|
|
* Do an rcu_dereference(), but check that the conditions under which the
|
2010-04-29 01:39:09 +04:00
|
|
|
* dereference will take place are correct. Typically the conditions
|
|
|
|
* indicate the various locking conditions that should be held at that
|
|
|
|
* point. The check should return true if the conditions are satisfied.
|
|
|
|
* An implicit check for being in an RCU read-side critical section
|
|
|
|
* (rcu_read_lock()) is included.
|
2010-04-10 02:39:11 +04:00
|
|
|
*
|
|
|
|
* For example:
|
|
|
|
*
|
2010-04-29 01:39:09 +04:00
|
|
|
* bar = rcu_dereference_check(foo->bar, lockdep_is_held(&foo->lock));
|
2010-04-10 02:39:11 +04:00
|
|
|
*
|
|
|
|
* could be used to indicate to lockdep that foo->bar may only be dereferenced
|
2010-04-29 01:39:09 +04:00
|
|
|
* if either rcu_read_lock() is held, or that the lock required to replace
|
2010-04-10 02:39:11 +04:00
|
|
|
* the bar struct at foo->bar is held.
|
|
|
|
*
|
|
|
|
* Note that the list of conditions may also include indications of when a lock
|
|
|
|
* need not be held, for example during initialisation or destruction of the
|
|
|
|
* target struct:
|
|
|
|
*
|
2010-04-29 01:39:09 +04:00
|
|
|
* bar = rcu_dereference_check(foo->bar, lockdep_is_held(&foo->lock) ||
|
2010-04-10 02:39:11 +04:00
|
|
|
* atomic_read(&foo->usage) == 0);
|
2010-04-29 01:39:09 +04:00
|
|
|
*
|
|
|
|
* Inserts memory barriers on architectures that require them
|
|
|
|
* (currently only the Alpha), prevents the compiler from refetching
|
|
|
|
* (and from merging fetches), and, more importantly, documents exactly
|
|
|
|
* which pointers are protected by RCU and checks that the pointer is
|
|
|
|
* annotated as __rcu.
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
*/
|
|
|
|
#define rcu_dereference_check(p, c) \
|
2015-02-02 22:46:33 +03:00
|
|
|
__rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu)
|
2010-04-29 01:39:09 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* rcu_dereference_bh_check() - rcu_dereference_bh with debug checking
|
|
|
|
* @p: The pointer to read, prior to dereferencing
|
|
|
|
* @c: The conditions under which the dereference will take place
|
|
|
|
*
|
|
|
|
* This is the RCU-bh counterpart to rcu_dereference_check().
|
|
|
|
*/
|
|
|
|
#define rcu_dereference_bh_check(p, c) \
|
2015-02-02 22:46:33 +03:00
|
|
|
__rcu_dereference_check((p), (c) || rcu_read_lock_bh_held(), __rcu)
|
rcu: Introduce lockdep-based checking to RCU read-side primitives
Inspection is proving insufficient to catch all RCU misuses,
which is understandable given that rcu_dereference() might be
protected by any of four different flavors of RCU (RCU, RCU-bh,
RCU-sched, and SRCU), and might also/instead be protected by any
of a number of locking primitives. It is therefore time to
enlist the aid of lockdep.
This set of patches is inspired by earlier work by Peter
Zijlstra and Thomas Gleixner, and takes the following approach:
o Set up separate lockdep classes for RCU, RCU-bh, and RCU-sched.
o Set up separate lockdep classes for each instance of SRCU.
o Create primitives that check for being in an RCU read-side
critical section. These return exact answers if lockdep is
fully enabled, but if unsure, report being in an RCU read-side
critical section. (We want to avoid false positives!)
The primitives are:
For RCU: rcu_read_lock_held(void)
For RCU-bh: rcu_read_lock_bh_held(void)
For RCU-sched: rcu_read_lock_sched_held(void)
For SRCU: srcu_read_lock_held(struct srcu_struct *sp)
o Add rcu_dereference_check(), which takes a second argument
in which one places a boolean expression based on the above
primitives and/or lockdep_is_held().
o A new kernel configuration parameter, CONFIG_PROVE_RCU, enables
rcu_dereference_check(). This depends on CONFIG_PROVE_LOCKING,
and should be quite helpful during the transition period while
CONFIG_PROVE_RCU-unaware patches are in flight.
The existing rcu_dereference() primitive does no checking, but
upcoming patches will change that.
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: laijs@cn.fujitsu.com
Cc: dipankar@in.ibm.com
Cc: mathieu.desnoyers@polymtl.ca
Cc: josh@joshtriplett.org
Cc: dvhltc@us.ibm.com
Cc: niv@us.ibm.com
Cc: peterz@infradead.org
Cc: rostedt@goodmis.org
Cc: Valdis.Kletnieks@vt.edu
Cc: dhowells@redhat.com
LKML-Reference: <1266887105-1528-1-git-send-email-paulmck@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-02-23 04:04:45 +03:00
|
|
|
|
2010-04-10 02:39:10 +04:00
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_dereference_sched_check() - rcu_dereference_sched with debug checking
|
|
|
|
* @p: The pointer to read, prior to dereferencing
|
|
|
|
* @c: The conditions under which the dereference will take place
|
|
|
|
*
|
|
|
|
* This is the RCU-sched counterpart to rcu_dereference_check().
|
|
|
|
*/
|
|
|
|
#define rcu_dereference_sched_check(p, c) \
|
2015-02-02 22:46:33 +03:00
|
|
|
__rcu_dereference_check((p), (c) || rcu_read_lock_sched_held(), \
|
2010-04-29 01:39:09 +04:00
|
|
|
__rcu)
|
|
|
|
|
2013-05-28 22:38:42 +04:00
|
|
|
/*
|
|
|
|
* The tracing infrastructure traces RCU (we want that), but unfortunately
|
|
|
|
* some of the RCU checks causes tracing to lock up the system.
|
|
|
|
*
|
2015-11-02 05:21:47 +03:00
|
|
|
* The no-tracing version of rcu_dereference_raw() must not call
|
2013-05-28 22:38:42 +04:00
|
|
|
* rcu_read_lock_held().
|
|
|
|
*/
|
|
|
|
#define rcu_dereference_raw_notrace(p) __rcu_dereference_check((p), 1, __rcu)
|
|
|
|
|
2010-04-29 01:39:09 +04:00
|
|
|
/**
|
|
|
|
* rcu_dereference_protected() - fetch RCU pointer when updates prevented
|
|
|
|
* @p: The pointer to read, prior to dereferencing
|
|
|
|
* @c: The conditions under which the dereference will take place
|
2010-04-10 02:39:10 +04:00
|
|
|
*
|
|
|
|
* Return the value of the specified RCU-protected pointer, but omit
|
2017-10-09 20:30:58 +03:00
|
|
|
* the READ_ONCE(). This is useful in cases where update-side locks
|
|
|
|
* prevent the value of the pointer from changing. Please note that this
|
|
|
|
* primitive does *not* prevent the compiler from repeating this reference
|
|
|
|
* or combining it with other references, so it should not be used without
|
|
|
|
* protection of appropriate locks.
|
2010-04-29 01:39:09 +04:00
|
|
|
*
|
|
|
|
* This function is only for update-side use. Using this function
|
|
|
|
* when protected only by rcu_read_lock() will result in infrequent
|
|
|
|
* but very ugly failures.
|
2010-04-10 02:39:10 +04:00
|
|
|
*/
|
|
|
|
#define rcu_dereference_protected(p, c) \
|
2010-04-29 01:39:09 +04:00
|
|
|
__rcu_dereference_protected((p), (c), __rcu)
|
2010-04-10 02:39:10 +04:00
|
|
|
|
2009-08-23 00:56:47 +04:00
|
|
|
|
2010-04-10 02:39:10 +04:00
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_dereference() - fetch RCU-protected pointer for dereferencing
|
|
|
|
* @p: The pointer to read, prior to dereferencing
|
2010-04-10 02:39:10 +04:00
|
|
|
*
|
2010-04-29 01:39:09 +04:00
|
|
|
* This is a simple wrapper around rcu_dereference_check().
|
2010-04-10 02:39:10 +04:00
|
|
|
*/
|
2010-04-29 01:39:09 +04:00
|
|
|
#define rcu_dereference(p) rcu_dereference_check(p, 0)
|
2010-04-10 02:39:10 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_dereference_bh() - fetch an RCU-bh-protected pointer for dereferencing
|
|
|
|
* @p: The pointer to read, prior to dereferencing
|
|
|
|
*
|
|
|
|
* Makes rcu_dereference_check() do the dirty work.
|
|
|
|
*/
|
|
|
|
#define rcu_dereference_bh(p) rcu_dereference_bh_check(p, 0)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rcu_dereference_sched() - fetch RCU-sched-protected pointer for dereferencing
|
|
|
|
* @p: The pointer to read, prior to dereferencing
|
|
|
|
*
|
|
|
|
* Makes rcu_dereference_check() do the dirty work.
|
|
|
|
*/
|
|
|
|
#define rcu_dereference_sched(p) rcu_dereference_sched_check(p, 0)
|
|
|
|
|
2015-09-11 02:29:02 +03:00
|
|
|
/**
|
|
|
|
* rcu_pointer_handoff() - Hand off a pointer from RCU to other mechanism
|
|
|
|
* @p: The pointer to hand off
|
|
|
|
*
|
|
|
|
* This is simply an identity function, but it documents where a pointer
|
|
|
|
* is handed off from RCU to some other synchronization mechanism, for
|
|
|
|
* example, reference counting or locking. In C11, it would map to
|
2018-05-07 12:35:46 +03:00
|
|
|
* kill_dependency(). It could be used as follows::
|
|
|
|
*
|
2015-09-11 02:29:02 +03:00
|
|
|
* rcu_read_lock();
|
|
|
|
* p = rcu_dereference(gp);
|
|
|
|
* long_lived = is_long_lived(p);
|
|
|
|
* if (long_lived) {
|
|
|
|
* if (!atomic_inc_not_zero(p->refcnt))
|
|
|
|
* long_lived = false;
|
|
|
|
* else
|
|
|
|
* p = rcu_pointer_handoff(p);
|
|
|
|
* }
|
|
|
|
* rcu_read_unlock();
|
|
|
|
*/
|
|
|
|
#define rcu_pointer_handoff(p) (p)
|
|
|
|
|
2010-04-29 01:39:09 +04:00
|
|
|
/**
|
|
|
|
* rcu_read_lock() - mark the beginning of an RCU read-side critical section
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
2005-05-01 19:59:04 +04:00
|
|
|
* When synchronize_rcu() is invoked on one CPU while other CPUs
|
2005-04-17 02:20:36 +04:00
|
|
|
* are within RCU read-side critical sections, then the
|
2005-05-01 19:59:04 +04:00
|
|
|
* synchronize_rcu() is guaranteed to block until after all the other
|
2005-04-17 02:20:36 +04:00
|
|
|
* CPUs exit their critical sections. Similarly, if call_rcu() is invoked
|
|
|
|
* on one CPU while other CPUs are within RCU read-side critical
|
|
|
|
* sections, invocation of the corresponding RCU callback is deferred
|
|
|
|
* until after the all the other CPUs exit their critical sections.
|
|
|
|
*
|
|
|
|
* Note, however, that RCU callbacks are permitted to run concurrently
|
2010-07-09 04:38:59 +04:00
|
|
|
* with new RCU read-side critical sections. One way that this can happen
|
2005-04-17 02:20:36 +04:00
|
|
|
* is via the following sequence of events: (1) CPU 0 enters an RCU
|
|
|
|
* read-side critical section, (2) CPU 1 invokes call_rcu() to register
|
|
|
|
* an RCU callback, (3) CPU 0 exits the RCU read-side critical section,
|
|
|
|
* (4) CPU 2 enters a RCU read-side critical section, (5) the RCU
|
|
|
|
* callback is invoked. This is legal, because the RCU read-side critical
|
|
|
|
* section that was running concurrently with the call_rcu() (and which
|
|
|
|
* therefore might be referencing something that the corresponding RCU
|
|
|
|
* callback would free up) has completed before the corresponding
|
|
|
|
* RCU callback is invoked.
|
|
|
|
*
|
|
|
|
* RCU read-side critical sections may be nested. Any deferred actions
|
|
|
|
* will be deferred until the outermost RCU read-side critical section
|
|
|
|
* completes.
|
|
|
|
*
|
2010-08-08 08:59:54 +04:00
|
|
|
* You can avoid reading and understanding the next paragraph by
|
|
|
|
* following this rule: don't put anything in an rcu_read_lock() RCU
|
|
|
|
* read-side critical section that would block in a !PREEMPT kernel.
|
|
|
|
* But if you want the full story, read on!
|
|
|
|
*
|
2014-05-05 02:41:21 +04:00
|
|
|
* In non-preemptible RCU implementations (TREE_RCU and TINY_RCU),
|
|
|
|
* it is illegal to block while in an RCU read-side critical section.
|
2014-09-22 22:00:48 +04:00
|
|
|
* In preemptible RCU implementations (PREEMPT_RCU) in CONFIG_PREEMPT
|
2014-05-05 02:41:21 +04:00
|
|
|
* kernel builds, RCU read-side critical sections may be preempted,
|
|
|
|
* but explicit blocking is illegal. Finally, in preemptible RCU
|
|
|
|
* implementations in real-time (with -rt patchset) kernel builds, RCU
|
|
|
|
* read-side critical sections may be preempted and they may also block, but
|
|
|
|
* only when acquiring spinlocks that are subject to priority inheritance.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2009-08-23 00:56:47 +04:00
|
|
|
static inline void rcu_read_lock(void)
|
|
|
|
{
|
|
|
|
__rcu_read_lock();
|
|
|
|
__acquire(RCU);
|
2011-10-07 20:22:03 +04:00
|
|
|
rcu_lock_acquire(&rcu_lock_map);
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!rcu_is_watching(),
|
|
|
|
"rcu_read_lock() used illegally while idle");
|
2009-08-23 00:56:47 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* So where is rcu_write_lock()? It does not exist, as there is no
|
|
|
|
* way for writers to lock out RCU readers. This is a feature, not
|
|
|
|
* a bug -- this property is what provides RCU's performance benefits.
|
|
|
|
* Of course, writers must coordinate with each other. The normal
|
|
|
|
* spinlock primitives work well for this, but any other technique may be
|
|
|
|
* used as well. RCU does not care how the writers keep out of each
|
|
|
|
* others' way, as long as they do so.
|
|
|
|
*/
|
2009-09-28 18:46:32 +04:00
|
|
|
|
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_read_unlock() - marks the end of an RCU read-side critical section.
|
2009-09-28 18:46:32 +04:00
|
|
|
*
|
2014-05-05 02:38:38 +04:00
|
|
|
* In most situations, rcu_read_unlock() is immune from deadlock.
|
|
|
|
* However, in kernels built with CONFIG_RCU_BOOST, rcu_read_unlock()
|
|
|
|
* is responsible for deboosting, which it does via rt_mutex_unlock().
|
|
|
|
* Unfortunately, this function acquires the scheduler's runqueue and
|
|
|
|
* priority-inheritance spinlocks. This means that deadlock could result
|
|
|
|
* if the caller of rcu_read_unlock() already holds one of these locks or
|
2018-05-25 12:05:06 +03:00
|
|
|
* any lock that is ever acquired while holding them.
|
2014-05-05 02:38:38 +04:00
|
|
|
*
|
|
|
|
* That said, RCU readers are never priority boosted unless they were
|
|
|
|
* preempted. Therefore, one way to avoid deadlock is to make sure
|
|
|
|
* that preemption never happens within any RCU read-side critical
|
|
|
|
* section whose outermost rcu_read_unlock() is called with one of
|
|
|
|
* rt_mutex_unlock()'s locks held. Such preemption can be avoided in
|
|
|
|
* a number of ways, for example, by invoking preempt_disable() before
|
|
|
|
* critical section's outermost rcu_read_lock().
|
|
|
|
*
|
|
|
|
* Given that the set of locks acquired by rt_mutex_unlock() might change
|
|
|
|
* at any time, a somewhat more future-proofed approach is to make sure
|
|
|
|
* that that preemption never happens within any RCU read-side critical
|
|
|
|
* section whose outermost rcu_read_unlock() is called with irqs disabled.
|
|
|
|
* This approach relies on the fact that rt_mutex_unlock() currently only
|
|
|
|
* acquires irq-disabled locks.
|
|
|
|
*
|
|
|
|
* The second of these two approaches is best in most situations,
|
|
|
|
* however, the first approach can also be useful, at least to those
|
|
|
|
* developers willing to keep abreast of the set of locks acquired by
|
|
|
|
* rt_mutex_unlock().
|
|
|
|
*
|
2009-09-28 18:46:32 +04:00
|
|
|
* See rcu_read_lock() for more information.
|
|
|
|
*/
|
2009-08-23 00:56:47 +04:00
|
|
|
static inline void rcu_read_unlock(void)
|
|
|
|
{
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!rcu_is_watching(),
|
|
|
|
"rcu_read_unlock() used illegally while idle");
|
2009-08-23 00:56:47 +04:00
|
|
|
__release(RCU);
|
|
|
|
__rcu_read_unlock();
|
2015-01-22 02:26:03 +03:00
|
|
|
rcu_lock_release(&rcu_lock_map); /* Keep acq info for rls diags. */
|
2009-08-23 00:56:47 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
2018-07-02 19:04:27 +03:00
|
|
|
* This is equivalent of rcu_read_lock(), but also disables softirqs.
|
2018-07-08 04:12:26 +03:00
|
|
|
* Note that anything else that disables softirqs can also serve as
|
|
|
|
* an RCU read-side critical section.
|
2011-11-28 22:42:42 +04:00
|
|
|
*
|
|
|
|
* Note that rcu_read_lock_bh() and the matching rcu_read_unlock_bh()
|
|
|
|
* must occur in the same context, for example, it is illegal to invoke
|
|
|
|
* rcu_read_unlock_bh() from one task if the matching rcu_read_lock_bh()
|
|
|
|
* was invoked from some other task.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2009-08-23 00:56:47 +04:00
|
|
|
static inline void rcu_read_lock_bh(void)
|
|
|
|
{
|
2011-08-01 17:22:11 +04:00
|
|
|
local_bh_disable();
|
2009-08-23 00:56:47 +04:00
|
|
|
__acquire(RCU_BH);
|
2011-10-07 20:22:03 +04:00
|
|
|
rcu_lock_acquire(&rcu_bh_lock_map);
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!rcu_is_watching(),
|
|
|
|
"rcu_read_lock_bh() used illegally while idle");
|
2009-08-23 00:56:47 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
|
|
|
|
*
|
|
|
|
* See rcu_read_lock_bh() for more information.
|
|
|
|
*/
|
2009-08-23 00:56:47 +04:00
|
|
|
static inline void rcu_read_unlock_bh(void)
|
|
|
|
{
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!rcu_is_watching(),
|
|
|
|
"rcu_read_unlock_bh() used illegally while idle");
|
2011-10-07 20:22:03 +04:00
|
|
|
rcu_lock_release(&rcu_bh_lock_map);
|
2009-08-23 00:56:47 +04:00
|
|
|
__release(RCU_BH);
|
2011-08-01 17:22:11 +04:00
|
|
|
local_bh_enable();
|
2009-08-23 00:56:47 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-09-29 19:06:46 +04:00
|
|
|
/**
|
2010-04-29 01:39:09 +04:00
|
|
|
* rcu_read_lock_sched() - mark the beginning of a RCU-sched critical section
|
2008-09-29 19:06:46 +04:00
|
|
|
*
|
2018-07-08 04:12:26 +03:00
|
|
|
* This is equivalent of rcu_read_lock(), but disables preemption.
|
|
|
|
* Read-side critical sections can also be introduced by anything else
|
|
|
|
* that disables preemption, including local_irq_disable() and friends.
|
2011-11-28 22:42:42 +04:00
|
|
|
*
|
|
|
|
* Note that rcu_read_lock_sched() and the matching rcu_read_unlock_sched()
|
|
|
|
* must occur in the same context, for example, it is illegal to invoke
|
|
|
|
* rcu_read_unlock_sched() from process context if the matching
|
|
|
|
* rcu_read_lock_sched() was invoked from an NMI handler.
|
2008-09-29 19:06:46 +04:00
|
|
|
*/
|
2009-08-23 00:56:46 +04:00
|
|
|
static inline void rcu_read_lock_sched(void)
|
|
|
|
{
|
|
|
|
preempt_disable();
|
2009-08-23 00:56:47 +04:00
|
|
|
__acquire(RCU_SCHED);
|
2011-10-07 20:22:03 +04:00
|
|
|
rcu_lock_acquire(&rcu_sched_lock_map);
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!rcu_is_watching(),
|
|
|
|
"rcu_read_lock_sched() used illegally while idle");
|
2009-08-23 00:56:46 +04:00
|
|
|
}
|
2009-09-23 20:50:42 +04:00
|
|
|
|
|
|
|
/* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
|
2009-08-24 20:42:00 +04:00
|
|
|
static inline notrace void rcu_read_lock_sched_notrace(void)
|
2009-08-23 00:56:46 +04:00
|
|
|
{
|
|
|
|
preempt_disable_notrace();
|
2009-08-23 00:56:47 +04:00
|
|
|
__acquire(RCU_SCHED);
|
2009-08-23 00:56:46 +04:00
|
|
|
}
|
2008-09-29 19:06:46 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* rcu_read_unlock_sched - marks the end of a RCU-classic critical section
|
|
|
|
*
|
|
|
|
* See rcu_read_lock_sched for more information.
|
|
|
|
*/
|
2009-08-23 00:56:46 +04:00
|
|
|
static inline void rcu_read_unlock_sched(void)
|
|
|
|
{
|
2015-06-19 01:50:02 +03:00
|
|
|
RCU_LOCKDEP_WARN(!rcu_is_watching(),
|
|
|
|
"rcu_read_unlock_sched() used illegally while idle");
|
2011-10-07 20:22:03 +04:00
|
|
|
rcu_lock_release(&rcu_sched_lock_map);
|
2009-08-23 00:56:47 +04:00
|
|
|
__release(RCU_SCHED);
|
2009-08-23 00:56:46 +04:00
|
|
|
preempt_enable();
|
|
|
|
}
|
2009-09-23 20:50:42 +04:00
|
|
|
|
|
|
|
/* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
|
2009-08-24 20:42:00 +04:00
|
|
|
static inline notrace void rcu_read_unlock_sched_notrace(void)
|
2009-08-23 00:56:46 +04:00
|
|
|
{
|
2009-08-23 00:56:47 +04:00
|
|
|
__release(RCU_SCHED);
|
2009-08-23 00:56:46 +04:00
|
|
|
preempt_enable_notrace();
|
|
|
|
}
|
2008-09-29 19:06:46 +04:00
|
|
|
|
2010-04-29 01:39:09 +04:00
|
|
|
/**
|
|
|
|
* RCU_INIT_POINTER() - initialize an RCU protected pointer
|
2017-10-20 00:26:21 +03:00
|
|
|
* @p: The pointer to be initialized.
|
|
|
|
* @v: The value to initialized the pointer to.
|
2010-04-29 01:39:09 +04:00
|
|
|
*
|
2011-08-01 09:33:02 +04:00
|
|
|
* Initialize an RCU-protected pointer in special cases where readers
|
|
|
|
* do not need ordering constraints on the CPU or the compiler. These
|
|
|
|
* special cases are:
|
|
|
|
*
|
2017-10-20 00:26:21 +03:00
|
|
|
* 1. This use of RCU_INIT_POINTER() is NULLing out the pointer *or*
|
2011-08-01 09:33:02 +04:00
|
|
|
* 2. The caller has taken whatever steps are required to prevent
|
2017-10-20 00:26:21 +03:00
|
|
|
* RCU readers from concurrently accessing this pointer *or*
|
2011-08-01 09:33:02 +04:00
|
|
|
* 3. The referenced data structure has already been exposed to
|
2017-10-20 00:26:21 +03:00
|
|
|
* readers either at compile time or via rcu_assign_pointer() *and*
|
|
|
|
*
|
|
|
|
* a. You have not made *any* reader-visible changes to
|
|
|
|
* this structure since then *or*
|
2011-08-01 09:33:02 +04:00
|
|
|
* b. It is OK for readers accessing this structure from its
|
|
|
|
* new location to see the old state of the structure. (For
|
|
|
|
* example, the changes were to statistical counters or to
|
|
|
|
* other state where exact synchronization is not required.)
|
|
|
|
*
|
|
|
|
* Failure to follow these rules governing use of RCU_INIT_POINTER() will
|
|
|
|
* result in impossible-to-diagnose memory corruption. As in the structures
|
|
|
|
* will look OK in crash dumps, but any concurrent RCU readers might
|
|
|
|
* see pre-initialized values of the referenced data structure. So
|
|
|
|
* please be very careful how you use RCU_INIT_POINTER()!!!
|
|
|
|
*
|
|
|
|
* If you are creating an RCU-protected linked structure that is accessed
|
|
|
|
* by a single external-to-structure RCU-protected pointer, then you may
|
|
|
|
* use RCU_INIT_POINTER() to initialize the internal RCU-protected
|
|
|
|
* pointers, but you must use rcu_assign_pointer() to initialize the
|
2017-10-20 00:26:21 +03:00
|
|
|
* external-to-structure pointer *after* you have completely initialized
|
2011-08-01 09:33:02 +04:00
|
|
|
* the reader-accessible portions of the linked structure.
|
2014-04-01 00:13:02 +04:00
|
|
|
*
|
|
|
|
* Note that unlike rcu_assign_pointer(), RCU_INIT_POINTER() provides no
|
|
|
|
* ordering guarantees for either the CPU or the compiler.
|
2010-04-29 01:39:09 +04:00
|
|
|
*/
|
|
|
|
#define RCU_INIT_POINTER(p, v) \
|
2012-05-17 02:42:30 +04:00
|
|
|
do { \
|
2014-09-25 22:03:34 +04:00
|
|
|
rcu_dereference_sparse(p, __rcu); \
|
2015-06-02 18:26:48 +03:00
|
|
|
WRITE_ONCE(p, RCU_INITIALIZER(v)); \
|
2012-05-17 02:42:30 +04:00
|
|
|
} while (0)
|
rcu: introduce kfree_rcu()
Many rcu callbacks functions just call kfree() on the base structure.
These functions are trivial, but their size adds up, and furthermore
when they are used in a kernel module, that module must invoke the
high-latency rcu_barrier() function at module-unload time.
The kfree_rcu() function introduced by this commit addresses this issue.
Rather than encoding a function address in the embedded rcu_head
structure, kfree_rcu() instead encodes the offset of the rcu_head
structure within the base structure. Because the functions are not
allowed in the low-order 4096 bytes of kernel virtual memory, offsets
up to 4095 bytes can be accommodated. If the offset is larger than
4095 bytes, a compile-time error will be generated in __kfree_rcu().
If this error is triggered, you can either fall back to use of call_rcu()
or rearrange the structure to position the rcu_head structure into the
first 4096 bytes.
Note that the allowable offset might decrease in the future, for example,
to allow something like kmem_cache_free_rcu().
The new kfree_rcu() function can replace code as follows:
call_rcu(&p->rcu, simple_kfree_callback);
where "simple_kfree_callback()" might be defined as follows:
void simple_kfree_callback(struct rcu_head *p)
{
struct foo *q = container_of(p, struct foo, rcu);
kfree(q);
}
with the following:
kfree_rcu(&p->rcu, rcu);
Note that the "rcu" is the name of a field in the structure being
freed. The reason for using this rather than passing in a pointer
to the base structure is that the above approach allows better type
checking.
This commit is based on earlier work by Lai Jiangshan and Manfred Spraul:
Lai's V1 patch: http://lkml.org/lkml/2008/9/18/1
Manfred's patch: http://lkml.org/lkml/2009/1/2/115
Signed-off-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Signed-off-by: Manfred Spraul <manfred@colorfullife.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Reviewed-by: David Howells <dhowells@redhat.com>
Reviewed-by: Josh Triplett <josh@joshtriplett.org>
2011-03-18 06:15:47 +03:00
|
|
|
|
2012-05-17 02:23:45 +04:00
|
|
|
/**
|
|
|
|
* RCU_POINTER_INITIALIZER() - statically initialize an RCU protected pointer
|
2017-10-20 00:26:21 +03:00
|
|
|
* @p: The pointer to be initialized.
|
|
|
|
* @v: The value to initialized the pointer to.
|
2012-05-17 02:23:45 +04:00
|
|
|
*
|
|
|
|
* GCC-style initialization for an RCU-protected pointer in a structure field.
|
|
|
|
*/
|
|
|
|
#define RCU_POINTER_INITIALIZER(p, v) \
|
2013-11-11 21:59:34 +04:00
|
|
|
.p = RCU_INITIALIZER(v)
|
rcu: introduce kfree_rcu()
Many rcu callbacks functions just call kfree() on the base structure.
These functions are trivial, but their size adds up, and furthermore
when they are used in a kernel module, that module must invoke the
high-latency rcu_barrier() function at module-unload time.
The kfree_rcu() function introduced by this commit addresses this issue.
Rather than encoding a function address in the embedded rcu_head
structure, kfree_rcu() instead encodes the offset of the rcu_head
structure within the base structure. Because the functions are not
allowed in the low-order 4096 bytes of kernel virtual memory, offsets
up to 4095 bytes can be accommodated. If the offset is larger than
4095 bytes, a compile-time error will be generated in __kfree_rcu().
If this error is triggered, you can either fall back to use of call_rcu()
or rearrange the structure to position the rcu_head structure into the
first 4096 bytes.
Note that the allowable offset might decrease in the future, for example,
to allow something like kmem_cache_free_rcu().
The new kfree_rcu() function can replace code as follows:
call_rcu(&p->rcu, simple_kfree_callback);
where "simple_kfree_callback()" might be defined as follows:
void simple_kfree_callback(struct rcu_head *p)
{
struct foo *q = container_of(p, struct foo, rcu);
kfree(q);
}
with the following:
kfree_rcu(&p->rcu, rcu);
Note that the "rcu" is the name of a field in the structure being
freed. The reason for using this rather than passing in a pointer
to the base structure is that the above approach allows better type
checking.
This commit is based on earlier work by Lai Jiangshan and Manfred Spraul:
Lai's V1 patch: http://lkml.org/lkml/2008/9/18/1
Manfred's patch: http://lkml.org/lkml/2009/1/2/115
Signed-off-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Signed-off-by: Manfred Spraul <manfred@colorfullife.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Reviewed-by: David Howells <dhowells@redhat.com>
Reviewed-by: Josh Triplett <josh@joshtriplett.org>
2011-03-18 06:15:47 +03:00
|
|
|
|
2012-04-19 22:44:39 +04:00
|
|
|
/*
|
|
|
|
* Does the specified offset indicate that the corresponding rcu_head
|
|
|
|
* structure can be handled by kfree_rcu()?
|
|
|
|
*/
|
|
|
|
#define __is_kfree_rcu_offset(offset) ((offset) < 4096)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper macro for kfree_rcu() to prevent argument-expansion eyestrain.
|
|
|
|
*/
|
|
|
|
#define __kfree_rcu(head, offset) \
|
|
|
|
do { \
|
|
|
|
BUILD_BUG_ON(!__is_kfree_rcu_offset(offset)); \
|
2015-07-29 08:29:38 +03:00
|
|
|
kfree_call_rcu(head, (rcu_callback_t)(unsigned long)(offset)); \
|
2012-04-19 22:44:39 +04:00
|
|
|
} while (0)
|
|
|
|
|
rcu: introduce kfree_rcu()
Many rcu callbacks functions just call kfree() on the base structure.
These functions are trivial, but their size adds up, and furthermore
when they are used in a kernel module, that module must invoke the
high-latency rcu_barrier() function at module-unload time.
The kfree_rcu() function introduced by this commit addresses this issue.
Rather than encoding a function address in the embedded rcu_head
structure, kfree_rcu() instead encodes the offset of the rcu_head
structure within the base structure. Because the functions are not
allowed in the low-order 4096 bytes of kernel virtual memory, offsets
up to 4095 bytes can be accommodated. If the offset is larger than
4095 bytes, a compile-time error will be generated in __kfree_rcu().
If this error is triggered, you can either fall back to use of call_rcu()
or rearrange the structure to position the rcu_head structure into the
first 4096 bytes.
Note that the allowable offset might decrease in the future, for example,
to allow something like kmem_cache_free_rcu().
The new kfree_rcu() function can replace code as follows:
call_rcu(&p->rcu, simple_kfree_callback);
where "simple_kfree_callback()" might be defined as follows:
void simple_kfree_callback(struct rcu_head *p)
{
struct foo *q = container_of(p, struct foo, rcu);
kfree(q);
}
with the following:
kfree_rcu(&p->rcu, rcu);
Note that the "rcu" is the name of a field in the structure being
freed. The reason for using this rather than passing in a pointer
to the base structure is that the above approach allows better type
checking.
This commit is based on earlier work by Lai Jiangshan and Manfred Spraul:
Lai's V1 patch: http://lkml.org/lkml/2008/9/18/1
Manfred's patch: http://lkml.org/lkml/2009/1/2/115
Signed-off-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Signed-off-by: Manfred Spraul <manfred@colorfullife.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Reviewed-by: David Howells <dhowells@redhat.com>
Reviewed-by: Josh Triplett <josh@joshtriplett.org>
2011-03-18 06:15:47 +03:00
|
|
|
/**
|
|
|
|
* kfree_rcu() - kfree an object after a grace period.
|
|
|
|
* @ptr: pointer to kfree
|
|
|
|
* @rcu_head: the name of the struct rcu_head within the type of @ptr.
|
|
|
|
*
|
|
|
|
* Many rcu callbacks functions just call kfree() on the base structure.
|
|
|
|
* These functions are trivial, but their size adds up, and furthermore
|
|
|
|
* when they are used in a kernel module, that module must invoke the
|
|
|
|
* high-latency rcu_barrier() function at module-unload time.
|
|
|
|
*
|
|
|
|
* The kfree_rcu() function handles this issue. Rather than encoding a
|
|
|
|
* function address in the embedded rcu_head structure, kfree_rcu() instead
|
|
|
|
* encodes the offset of the rcu_head structure within the base structure.
|
|
|
|
* Because the functions are not allowed in the low-order 4096 bytes of
|
|
|
|
* kernel virtual memory, offsets up to 4095 bytes can be accommodated.
|
|
|
|
* If the offset is larger than 4095 bytes, a compile-time error will
|
|
|
|
* be generated in __kfree_rcu(). If this error is triggered, you can
|
|
|
|
* either fall back to use of call_rcu() or rearrange the structure to
|
|
|
|
* position the rcu_head structure into the first 4096 bytes.
|
|
|
|
*
|
|
|
|
* Note that the allowable offset might decrease in the future, for example,
|
|
|
|
* to allow something like kmem_cache_free_rcu().
|
2012-04-19 22:44:39 +04:00
|
|
|
*
|
|
|
|
* The BUILD_BUG_ON check must not involve any function calls, hence the
|
|
|
|
* checks are done in macros here.
|
rcu: introduce kfree_rcu()
Many rcu callbacks functions just call kfree() on the base structure.
These functions are trivial, but their size adds up, and furthermore
when they are used in a kernel module, that module must invoke the
high-latency rcu_barrier() function at module-unload time.
The kfree_rcu() function introduced by this commit addresses this issue.
Rather than encoding a function address in the embedded rcu_head
structure, kfree_rcu() instead encodes the offset of the rcu_head
structure within the base structure. Because the functions are not
allowed in the low-order 4096 bytes of kernel virtual memory, offsets
up to 4095 bytes can be accommodated. If the offset is larger than
4095 bytes, a compile-time error will be generated in __kfree_rcu().
If this error is triggered, you can either fall back to use of call_rcu()
or rearrange the structure to position the rcu_head structure into the
first 4096 bytes.
Note that the allowable offset might decrease in the future, for example,
to allow something like kmem_cache_free_rcu().
The new kfree_rcu() function can replace code as follows:
call_rcu(&p->rcu, simple_kfree_callback);
where "simple_kfree_callback()" might be defined as follows:
void simple_kfree_callback(struct rcu_head *p)
{
struct foo *q = container_of(p, struct foo, rcu);
kfree(q);
}
with the following:
kfree_rcu(&p->rcu, rcu);
Note that the "rcu" is the name of a field in the structure being
freed. The reason for using this rather than passing in a pointer
to the base structure is that the above approach allows better type
checking.
This commit is based on earlier work by Lai Jiangshan and Manfred Spraul:
Lai's V1 patch: http://lkml.org/lkml/2008/9/18/1
Manfred's patch: http://lkml.org/lkml/2009/1/2/115
Signed-off-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Signed-off-by: Manfred Spraul <manfred@colorfullife.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Reviewed-by: David Howells <dhowells@redhat.com>
Reviewed-by: Josh Triplett <josh@joshtriplett.org>
2011-03-18 06:15:47 +03:00
|
|
|
*/
|
|
|
|
#define kfree_rcu(ptr, rcu_head) \
|
|
|
|
__kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
|
|
|
|
|
2013-06-22 03:37:22 +04:00
|
|
|
|
2016-11-28 23:08:49 +03:00
|
|
|
/*
|
|
|
|
* Place this after a lock-acquisition primitive to guarantee that
|
|
|
|
* an UNLOCK+LOCK pair acts as a full barrier. This guarantee applies
|
|
|
|
* if the UNLOCK and LOCK are executed by the same CPU or if the
|
|
|
|
* UNLOCK and LOCK operate on the same lock variable.
|
|
|
|
*/
|
2017-01-15 00:32:50 +03:00
|
|
|
#ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE
|
2016-11-28 23:08:49 +03:00
|
|
|
#define smp_mb__after_unlock_lock() smp_mb() /* Full ordering for lock. */
|
2017-01-15 00:32:50 +03:00
|
|
|
#else /* #ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE */
|
2016-11-28 23:08:49 +03:00
|
|
|
#define smp_mb__after_unlock_lock() do { } while (0)
|
2017-01-15 00:32:50 +03:00
|
|
|
#endif /* #else #ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE */
|
2016-11-28 23:08:49 +03:00
|
|
|
|
2016-03-22 05:46:04 +03:00
|
|
|
|
2018-07-25 01:28:09 +03:00
|
|
|
/* Has the specified rcu_head structure been handed to call_rcu()? */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rcu_head_init - Initialize rcu_head for rcu_head_after_call_rcu()
|
|
|
|
* @rhp: The rcu_head structure to initialize.
|
|
|
|
*
|
|
|
|
* If you intend to invoke rcu_head_after_call_rcu() to test whether a
|
|
|
|
* given rcu_head structure has already been passed to call_rcu(), then
|
|
|
|
* you must also invoke this rcu_head_init() function on it just after
|
|
|
|
* allocating that structure. Calls to this function must not race with
|
|
|
|
* calls to call_rcu(), rcu_head_after_call_rcu(), or callback invocation.
|
|
|
|
*/
|
|
|
|
static inline void rcu_head_init(struct rcu_head *rhp)
|
|
|
|
{
|
|
|
|
rhp->func = (rcu_callback_t)~0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rcu_head_after_call_rcu - Has this rcu_head been passed to call_rcu()?
|
|
|
|
* @rhp: The rcu_head structure to test.
|
|
|
|
* @func: The function passed to call_rcu() along with @rhp.
|
|
|
|
*
|
|
|
|
* Returns @true if the @rhp has been passed to call_rcu() with @func,
|
|
|
|
* and @false otherwise. Emits a warning in any other case, including
|
|
|
|
* the case where @rhp has already been invoked after a grace period.
|
|
|
|
* Calls to this function must not race with callback invocation. One way
|
|
|
|
* to avoid such races is to enclose the call to rcu_head_after_call_rcu()
|
|
|
|
* in an RCU read-side critical section that includes a read-side fetch
|
|
|
|
* of the pointer to the structure containing @rhp.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
rcu_head_after_call_rcu(struct rcu_head *rhp, rcu_callback_t f)
|
|
|
|
{
|
|
|
|
if (READ_ONCE(rhp->func) == f)
|
|
|
|
return true;
|
|
|
|
WARN_ON_ONCE(READ_ONCE(rhp->func) != (rcu_callback_t)~0L);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-07-06 19:54:25 +03:00
|
|
|
/* Transitional pre-consolidation compatibility definitions. */
|
|
|
|
|
|
|
|
static inline void synchronize_rcu_bh(void)
|
|
|
|
{
|
|
|
|
synchronize_rcu();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void synchronize_rcu_bh_expedited(void)
|
|
|
|
{
|
|
|
|
synchronize_rcu_expedited();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
|
|
|
|
{
|
|
|
|
call_rcu(head, func);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_barrier_bh(void)
|
|
|
|
{
|
|
|
|
rcu_barrier();
|
|
|
|
}
|
|
|
|
|
2018-07-06 21:46:47 +03:00
|
|
|
static inline void synchronize_sched(void)
|
|
|
|
{
|
|
|
|
synchronize_rcu();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void synchronize_sched_expedited(void)
|
|
|
|
{
|
|
|
|
synchronize_rcu_expedited();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
|
|
|
|
{
|
|
|
|
call_rcu(head, func);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_barrier_sched(void)
|
|
|
|
{
|
|
|
|
rcu_barrier();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long get_state_synchronize_sched(void)
|
|
|
|
{
|
|
|
|
return get_state_synchronize_rcu();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void cond_synchronize_sched(unsigned long oldstate)
|
|
|
|
{
|
|
|
|
cond_synchronize_rcu(oldstate);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* __LINUX_RCUPDATE_H */
|