mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Paul E. McKenney](/assets/img/avatar_default.png)
The rcu_dereference_check() family of primitives evaluates the RCU lockdep expression first, and only then evaluates the expression passed in. This works fine normally, but can potentially fail in environments (such as NMI handlers) where lockdep cannot be invoked. The problem is that even if the expression passed in is "1", the compiler would need to prove that the RCU lockdep expression (rcu_read_lock_held(), for example) is free of side effects in order to be able to elide it. Given that rcu_read_lock_held() is sometimes separately compiled, the compiler cannot always use this optimization. This commit therefore reverse the order of evaluation, so that the expression passed in is evaluated first, and the RCU lockdep expression is evaluated only if the passed-in expression evaluated to false, courtesy of the C-language short-circuit boolean evaluation rules. This compells the compiler to forego executing the RCU lockdep expression in cases where the passed-in expression evaluates to "1" at compile time, so that (for example) rcu_dereference_raw() can be guaranteed to execute safely within an NMI handler. Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com> Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
252 lines
8.6 KiB
C
252 lines
8.6 KiB
C
/*
|
|
* Sleepable Read-Copy Update mechanism for mutual exclusion
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you can access it online at
|
|
* http://www.gnu.org/licenses/gpl-2.0.html.
|
|
*
|
|
* Copyright (C) IBM Corporation, 2006
|
|
* Copyright (C) Fujitsu, 2012
|
|
*
|
|
* Author: Paul McKenney <paulmck@us.ibm.com>
|
|
* Lai Jiangshan <laijs@cn.fujitsu.com>
|
|
*
|
|
* For detailed explanation of Read-Copy Update mechanism see -
|
|
* Documentation/RCU/ *.txt
|
|
*
|
|
*/
|
|
|
|
#ifndef _LINUX_SRCU_H
|
|
#define _LINUX_SRCU_H
|
|
|
|
#include <linux/mutex.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <linux/workqueue.h>
|
|
|
|
struct srcu_struct_array {
|
|
unsigned long c[2];
|
|
unsigned long seq[2];
|
|
};
|
|
|
|
struct rcu_batch {
|
|
struct rcu_head *head, **tail;
|
|
};
|
|
|
|
#define RCU_BATCH_INIT(name) { NULL, &(name.head) }
|
|
|
|
struct srcu_struct {
|
|
unsigned long completed;
|
|
struct srcu_struct_array __percpu *per_cpu_ref;
|
|
spinlock_t queue_lock; /* protect ->batch_queue, ->running */
|
|
bool running;
|
|
/* callbacks just queued */
|
|
struct rcu_batch batch_queue;
|
|
/* callbacks try to do the first check_zero */
|
|
struct rcu_batch batch_check0;
|
|
/* callbacks done with the first check_zero and the flip */
|
|
struct rcu_batch batch_check1;
|
|
struct rcu_batch batch_done;
|
|
struct delayed_work work;
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
struct lockdep_map dep_map;
|
|
#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
};
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
int __init_srcu_struct(struct srcu_struct *sp, const char *name,
|
|
struct lock_class_key *key);
|
|
|
|
#define init_srcu_struct(sp) \
|
|
({ \
|
|
static struct lock_class_key __srcu_key; \
|
|
\
|
|
__init_srcu_struct((sp), #sp, &__srcu_key); \
|
|
})
|
|
|
|
#define __SRCU_DEP_MAP_INIT(srcu_name) .dep_map = { .name = #srcu_name },
|
|
#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
int init_srcu_struct(struct srcu_struct *sp);
|
|
|
|
#define __SRCU_DEP_MAP_INIT(srcu_name)
|
|
#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
void process_srcu(struct work_struct *work);
|
|
|
|
#define __SRCU_STRUCT_INIT(name) \
|
|
{ \
|
|
.completed = -300, \
|
|
.per_cpu_ref = &name##_srcu_array, \
|
|
.queue_lock = __SPIN_LOCK_UNLOCKED(name.queue_lock), \
|
|
.running = false, \
|
|
.batch_queue = RCU_BATCH_INIT(name.batch_queue), \
|
|
.batch_check0 = RCU_BATCH_INIT(name.batch_check0), \
|
|
.batch_check1 = RCU_BATCH_INIT(name.batch_check1), \
|
|
.batch_done = RCU_BATCH_INIT(name.batch_done), \
|
|
.work = __DELAYED_WORK_INITIALIZER(name.work, process_srcu, 0),\
|
|
__SRCU_DEP_MAP_INIT(name) \
|
|
}
|
|
|
|
/*
|
|
* define and init a srcu struct at build time.
|
|
* dont't call init_srcu_struct() nor cleanup_srcu_struct() on it.
|
|
*/
|
|
#define __DEFINE_SRCU(name, is_static) \
|
|
static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
|
|
is_static struct srcu_struct name = __SRCU_STRUCT_INIT(name)
|
|
#define DEFINE_SRCU(name) __DEFINE_SRCU(name, /* not static */)
|
|
#define DEFINE_STATIC_SRCU(name) __DEFINE_SRCU(name, static)
|
|
|
|
/**
|
|
* call_srcu() - Queue a callback for invocation after an SRCU grace period
|
|
* @sp: srcu_struct in queue the callback
|
|
* @head: structure to be used for queueing the SRCU callback.
|
|
* @func: function to be invoked after the SRCU grace period
|
|
*
|
|
* The callback function will be invoked some time after a full SRCU
|
|
* grace period elapses, in other words after all pre-existing SRCU
|
|
* read-side critical sections have completed. However, the callback
|
|
* function might well execute concurrently with other SRCU read-side
|
|
* critical sections that started after call_srcu() was invoked. SRCU
|
|
* read-side critical sections are delimited by srcu_read_lock() and
|
|
* srcu_read_unlock(), and may be nested.
|
|
*
|
|
* The callback will be invoked from process context, but must nevertheless
|
|
* be fast and must not block.
|
|
*/
|
|
void call_srcu(struct srcu_struct *sp, struct rcu_head *head,
|
|
void (*func)(struct rcu_head *head));
|
|
|
|
void cleanup_srcu_struct(struct srcu_struct *sp);
|
|
int __srcu_read_lock(struct srcu_struct *sp) __acquires(sp);
|
|
void __srcu_read_unlock(struct srcu_struct *sp, int idx) __releases(sp);
|
|
void synchronize_srcu(struct srcu_struct *sp);
|
|
void synchronize_srcu_expedited(struct srcu_struct *sp);
|
|
unsigned long srcu_batches_completed(struct srcu_struct *sp);
|
|
void srcu_barrier(struct srcu_struct *sp);
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
/**
|
|
* srcu_read_lock_held - might we be in SRCU read-side critical section?
|
|
*
|
|
* If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an SRCU
|
|
* read-side critical section. In absence of CONFIG_DEBUG_LOCK_ALLOC,
|
|
* this assumes we are in an SRCU read-side critical section unless it can
|
|
* prove otherwise.
|
|
*
|
|
* Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
|
|
* and while lockdep is disabled.
|
|
*
|
|
* Note that SRCU is based on its own statemachine and it doesn't
|
|
* relies on normal RCU, it can be called from the CPU which
|
|
* is in the idle loop from an RCU point of view or offline.
|
|
*/
|
|
static inline int srcu_read_lock_held(struct srcu_struct *sp)
|
|
{
|
|
if (!debug_lockdep_rcu_enabled())
|
|
return 1;
|
|
return lock_is_held(&sp->dep_map);
|
|
}
|
|
|
|
#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
static inline int srcu_read_lock_held(struct srcu_struct *sp)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
/**
|
|
* srcu_dereference_check - fetch SRCU-protected pointer for later dereferencing
|
|
* @p: the pointer to fetch and protect for later dereferencing
|
|
* @sp: pointer to the srcu_struct, which is used to check that we
|
|
* really are in an SRCU read-side critical section.
|
|
* @c: condition to check for update-side use
|
|
*
|
|
* If PROVE_RCU is enabled, invoking this outside of an RCU read-side
|
|
* critical section will result in an RCU-lockdep splat, unless @c evaluates
|
|
* to 1. The @c argument will normally be a logical expression containing
|
|
* lockdep_is_held() calls.
|
|
*/
|
|
#define srcu_dereference_check(p, sp, c) \
|
|
__rcu_dereference_check((p), (c) || srcu_read_lock_held(sp), __rcu)
|
|
|
|
/**
|
|
* srcu_dereference - fetch SRCU-protected pointer for later dereferencing
|
|
* @p: the pointer to fetch and protect for later dereferencing
|
|
* @sp: pointer to the srcu_struct, which is used to check that we
|
|
* really are in an SRCU read-side critical section.
|
|
*
|
|
* Makes rcu_dereference_check() do the dirty work. If PROVE_RCU
|
|
* is enabled, invoking this outside of an RCU read-side critical
|
|
* section will result in an RCU-lockdep splat.
|
|
*/
|
|
#define srcu_dereference(p, sp) srcu_dereference_check((p), (sp), 0)
|
|
|
|
/**
|
|
* srcu_read_lock - register a new reader for an SRCU-protected structure.
|
|
* @sp: srcu_struct in which to register the new reader.
|
|
*
|
|
* Enter an SRCU read-side critical section. Note that SRCU read-side
|
|
* critical sections may be nested. However, it is illegal to
|
|
* call anything that waits on an SRCU grace period for the same
|
|
* srcu_struct, whether directly or indirectly. Please note that
|
|
* one way to indirectly wait on an SRCU grace period is to acquire
|
|
* a mutex that is held elsewhere while calling synchronize_srcu() or
|
|
* synchronize_srcu_expedited().
|
|
*
|
|
* Note that srcu_read_lock() and the matching srcu_read_unlock() must
|
|
* occur in the same context, for example, it is illegal to invoke
|
|
* srcu_read_unlock() in an irq handler if the matching srcu_read_lock()
|
|
* was invoked in process context.
|
|
*/
|
|
static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
|
|
{
|
|
int retval = __srcu_read_lock(sp);
|
|
|
|
rcu_lock_acquire(&(sp)->dep_map);
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* srcu_read_unlock - unregister a old reader from an SRCU-protected structure.
|
|
* @sp: srcu_struct in which to unregister the old reader.
|
|
* @idx: return value from corresponding srcu_read_lock().
|
|
*
|
|
* Exit an SRCU read-side critical section.
|
|
*/
|
|
static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
|
|
__releases(sp)
|
|
{
|
|
rcu_lock_release(&(sp)->dep_map);
|
|
__srcu_read_unlock(sp, idx);
|
|
}
|
|
|
|
/**
|
|
* smp_mb__after_srcu_read_unlock - ensure full ordering after srcu_read_unlock
|
|
*
|
|
* Converts the preceding srcu_read_unlock into a two-way memory barrier.
|
|
*
|
|
* Call this after srcu_read_unlock, to guarantee that all memory operations
|
|
* that occur after smp_mb__after_srcu_read_unlock will appear to happen after
|
|
* the preceding srcu_read_unlock.
|
|
*/
|
|
static inline void smp_mb__after_srcu_read_unlock(void)
|
|
{
|
|
/* __srcu_read_unlock has smp_mb() internally so nothing to do here. */
|
|
}
|
|
|
|
#endif
|