[mirror_ubuntu-bionic-kernel.git] / include / linux / srcu.h

/*
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * 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 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)						\
	static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
	struct srcu_struct name = __SRCU_STRUCT_INIT(name);

#define DEFINE_STATIC_SRCU(name)					\
	static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
	static struct srcu_struct name = __SRCU_STRUCT_INIT(name);

/**
 * 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);
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 if the CPU is in the idle loop from an RCU point of view
 * (ie: that we are in the section between rcu_idle_enter() and
 * rcu_idle_exit()) then srcu_read_lock_held() returns false even if
 * the CPU did an srcu_read_lock().  The reason for this is that RCU
 * ignores CPUs that are in such a section, considering these as in
 * extended quiescent state, so such a CPU is effectively never in an
 * RCU read-side critical section regardless of what RCU primitives it
 * invokes.  This state of affairs is required --- we need to keep an
 * RCU-free window in idle where the CPU may possibly enter into low
 * power mode. This way we can notice an extended quiescent state to
 * other CPUs that started a grace period. Otherwise we would delay any
 * grace period as long as we run in the idle task.
 *
 * Similarly, we avoid claiming an SRCU read lock held if the current
 * CPU is offline.
 */
static inline int srcu_read_lock_held(struct srcu_struct *sp)
{
	if (!debug_lockdep_rcu_enabled())
		return 1;
	if (rcu_is_cpu_idle())
		return 0;
	if (!rcu_lockdep_current_cpu_online())
		return 0;
	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), srcu_read_lock_held(sp) || (c), __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);
	rcu_lockdep_assert(!rcu_is_cpu_idle(),
			   "srcu_read_lock() used illegally while idle");
	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_lockdep_assert(!rcu_is_cpu_idle(),
			   "srcu_read_unlock() used illegally while idle");
	rcu_lock_release(&(sp)->dep_map);
	__srcu_read_unlock(sp, idx);
}

/**
 * srcu_read_lock_raw - 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.  Similar to srcu_read_lock(),
 * but avoids the RCU-lockdep checking.  This means that it is legal to
 * use srcu_read_lock_raw() in one context, for example, in an exception
 * handler, and then have the matching srcu_read_unlock_raw() in another
 * context, for example in the task that took the exception.
 *
 * However, the entire SRCU read-side critical section must reside within a
 * single task.  For example, beware of using srcu_read_lock_raw() in
 * a device interrupt handler and srcu_read_unlock() in the interrupted
 * task:  This will not work if interrupts are threaded.
 */
static inline int srcu_read_lock_raw(struct srcu_struct *sp)
{
	unsigned long flags;
	int ret;

	local_irq_save(flags);
	ret =  __srcu_read_lock(sp);
	local_irq_restore(flags);
	return ret;
}

/**
 * srcu_read_unlock_raw - unregister reader from an SRCU-protected structure.
 * @sp: srcu_struct in which to unregister the old reader.
 * @idx: return value from corresponding srcu_read_lock_raw().
 *
 * Exit an SRCU read-side critical section without lockdep-RCU checking.
 * See srcu_read_lock_raw() for more details.
 */
static inline void srcu_read_unlock_raw(struct srcu_struct *sp, int idx)
{
	unsigned long flags;

	local_irq_save(flags);
	__srcu_read_unlock(sp, idx);
	local_irq_restore(flags);
}

#endif
Commit	Line	Data
621934ee PM	1	/*
	2	* Sleepable Read-Copy Update mechanism for mutual exclusion
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*
	18	* Copyright (C) IBM Corporation, 2006
4e87b2d7	19	* Copyright (C) Fujitsu, 2012
621934ee PM	20	*
621934ee PM	21	* Author: Paul McKenney <paulmck@us.ibm.com>
4e87b2d7	22	* Lai Jiangshan <laijs@cn.fujitsu.com>
621934ee PM	23	*
	24	* For detailed explanation of Read-Copy Update mechanism see -
	25	* Documentation/RCU/ *.txt
	26	*
	27	*/
	28
eabc0694 AS	29	#ifndef _LINUX_SRCU_H
	30	#define _LINUX_SRCU_H
	31
d14aada8	32	#include <linux/mutex.h>
ff195cb6	33	#include <linux/rcupdate.h>
931ea9d1	34	#include <linux/workqueue.h>
d14aada8	35
621934ee	36	struct srcu_struct_array {
cef50120	37	unsigned long c[2];
b52ce066	38	unsigned long seq[2];
621934ee PM	39	};
621934ee PM	40
931ea9d1 LJ	41	struct rcu_batch {
	42	struct rcu_head head, *tail;
	43	};
	44
55c6659a LJ	45	#define RCU_BATCH_INIT(name) { NULL, &(name.head) }
55c6659a LJ	46
621934ee	47	struct srcu_struct {
cef50120	48	unsigned completed;
43cf38eb	49	struct srcu_struct_array __percpu *per_cpu_ref;
931ea9d1 LJ	50	spinlock_t queue_lock; /* protect ->batch_queue, ->running */
	51	bool running;
	52	/* callbacks just queued */
	53	struct rcu_batch batch_queue;
	54	/* callbacks try to do the first check_zero */
	55	struct rcu_batch batch_check0;
	56	/* callbacks done with the first check_zero and the flip */
	57	struct rcu_batch batch_check1;
	58	struct rcu_batch batch_done;
	59	struct delayed_work work;
632ee200 PM	60	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	61	struct lockdep_map dep_map;
	62	#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
621934ee PM	63	};
621934ee PM	64
632ee200 PM	65	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	66
	67	int __init_srcu_struct(struct srcu_struct sp, const char name,
	68	struct lock_class_key *key);
	69
	70	#define init_srcu_struct(sp) \
	71	({ \
	72	static struct lock_class_key __srcu_key; \
	73	\
	74	__init_srcu_struct((sp), #sp, &__srcu_key); \
	75	})
	76
55c6659a	77	#define __SRCU_DEP_MAP_INIT(srcu_name) .dep_map = { .name = #srcu_name },
632ee200 PM	78	#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
632ee200 PM	79
e6a92013	80	int init_srcu_struct(struct srcu_struct *sp);
632ee200	81
55c6659a	82	#define __SRCU_DEP_MAP_INIT(srcu_name)
632ee200 PM	83	#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
632ee200 PM	84
f2ebfbc9 LJ	85	void process_srcu(struct work_struct *work);
f2ebfbc9 LJ	86
55c6659a LJ	87	#define __SRCU_STRUCT_INIT(name) \
	88	{ \
	89	.completed = -300, \
	90	.per_cpu_ref = &name##_srcu_array, \
	91	.queue_lock = __SPIN_LOCK_UNLOCKED(name.queue_lock), \
	92	.running = false, \
	93	.batch_queue = RCU_BATCH_INIT(name.batch_queue), \
	94	.batch_check0 = RCU_BATCH_INIT(name.batch_check0), \
	95	.batch_check1 = RCU_BATCH_INIT(name.batch_check1), \
	96	.batch_done = RCU_BATCH_INIT(name.batch_done), \
	97	.work = __DELAYED_WORK_INITIALIZER(name.work, process_srcu, 0),\
	98	__SRCU_DEP_MAP_INIT(name) \
	99	}
	100
	101	/*
	102	* define and init a srcu struct at build time.
	103	* dont't call init_srcu_struct() nor cleanup_srcu_struct() on it.
	104	*/
	105	#define DEFINE_SRCU(name) \
	106	static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
	107	struct srcu_struct name = __SRCU_STRUCT_INIT(name);
	108
	109	#define DEFINE_STATIC_SRCU(name) \
	110	static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
	111	static struct srcu_struct name = __SRCU_STRUCT_INIT(name);
	112
931ea9d1 LJ	113	/**
	114	* call_srcu() - Queue a callback for invocation after an SRCU grace period
	115	* @sp: srcu_struct in queue the callback
	116	* @head: structure to be used for queueing the SRCU callback.
	117	* @func: function to be invoked after the SRCU grace period
	118	*
	119	* The callback function will be invoked some time after a full SRCU
	120	* grace period elapses, in other words after all pre-existing SRCU
	121	* read-side critical sections have completed. However, the callback
	122	* function might well execute concurrently with other SRCU read-side
	123	* critical sections that started after call_srcu() was invoked. SRCU
	124	* read-side critical sections are delimited by srcu_read_lock() and
	125	* srcu_read_unlock(), and may be nested.
	126	*
	127	* The callback will be invoked from process context, but must nevertheless
	128	* be fast and must not block.
	129	*/
	130	void call_srcu(struct srcu_struct sp, struct rcu_head head,
	131	void (func)(struct rcu_head head));
	132
621934ee	133	void cleanup_srcu_struct(struct srcu_struct *sp);
632ee200 PM	134	int __srcu_read_lock(struct srcu_struct *sp) __acquires(sp);
632ee200 PM	135	void __srcu_read_unlock(struct srcu_struct *sp, int idx) __releases(sp);
621934ee	136	void synchronize_srcu(struct srcu_struct *sp);
0cd397d3	137	void synchronize_srcu_expedited(struct srcu_struct *sp);
621934ee	138	long srcu_batches_completed(struct srcu_struct *sp);
931ea9d1	139	void srcu_barrier(struct srcu_struct *sp);
eabc0694	140
632ee200 PM	141	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	142
	143	/**
	144	* srcu_read_lock_held - might we be in SRCU read-side critical section?
	145	*
d20200b5 PM	146	* If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an SRCU
d20200b5 PM	147	* read-side critical section. In absence of CONFIG_DEBUG_LOCK_ALLOC,
632ee200 PM	148	* this assumes we are in an SRCU read-side critical section unless it can
632ee200 PM	149	* prove otherwise.
ff195cb6	150	*
867f236b PM	151	* Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
	152	* and while lockdep is disabled.
	153	*
ff195cb6 PM	154	* Note that if the CPU is in the idle loop from an RCU point of view
	155	* (ie: that we are in the section between rcu_idle_enter() and
	156	* rcu_idle_exit()) then srcu_read_lock_held() returns false even if
	157	* the CPU did an srcu_read_lock(). The reason for this is that RCU
	158	* ignores CPUs that are in such a section, considering these as in
	159	* extended quiescent state, so such a CPU is effectively never in an
	160	* RCU read-side critical section regardless of what RCU primitives it
	161	* invokes. This state of affairs is required --- we need to keep an
	162	* RCU-free window in idle where the CPU may possibly enter into low
	163	* power mode. This way we can notice an extended quiescent state to
	164	* other CPUs that started a grace period. Otherwise we would delay any
	165	* grace period as long as we run in the idle task.
c0d6d01b PM	166	*
	167	* Similarly, we avoid claiming an SRCU read lock held if the current
	168	* CPU is offline.
632ee200 PM	169	*/
	170	static inline int srcu_read_lock_held(struct srcu_struct *sp)
	171	{
867f236b	172	if (!debug_lockdep_rcu_enabled())
ff195cb6	173	return 1;
c0d6d01b PM	174	if (rcu_is_cpu_idle())
	175	return 0;
	176	if (!rcu_lockdep_current_cpu_online())
	177	return 0;
ff195cb6	178	return lock_is_held(&sp->dep_map);
632ee200 PM	179	}
	180
	181	#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
	182
	183	static inline int srcu_read_lock_held(struct srcu_struct *sp)
	184	{
	185	return 1;
	186	}
	187
	188	#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
	189
c26d34a5	190	/**
ca5ecddf PM	191	* srcu_dereference_check - fetch SRCU-protected pointer for later dereferencing
	192	* @p: the pointer to fetch and protect for later dereferencing
	193	* @sp: pointer to the srcu_struct, which is used to check that we
	194	* really are in an SRCU read-side critical section.
	195	* @c: condition to check for update-side use
c26d34a5	196	*
ca5ecddf PM	197	* If PROVE_RCU is enabled, invoking this outside of an RCU read-side
	198	* critical section will result in an RCU-lockdep splat, unless @c evaluates
	199	* to 1. The @c argument will normally be a logical expression containing
	200	* lockdep_is_held() calls.
c26d34a5	201	*/
ca5ecddf PM	202	#define srcu_dereference_check(p, sp, c) \
	203	__rcu_dereference_check((p), srcu_read_lock_held(sp) \|\| (c), __rcu)
	204
	205	/**
	206	* srcu_dereference - fetch SRCU-protected pointer for later dereferencing
	207	* @p: the pointer to fetch and protect for later dereferencing
	208	* @sp: pointer to the srcu_struct, which is used to check that we
	209	* really are in an SRCU read-side critical section.
	210	*
	211	* Makes rcu_dereference_check() do the dirty work. If PROVE_RCU
	212	* is enabled, invoking this outside of an RCU read-side critical
	213	* section will result in an RCU-lockdep splat.
	214	*/
	215	#define srcu_dereference(p, sp) srcu_dereference_check((p), (sp), 0)
c26d34a5	216
632ee200 PM	217	/**
	218	* srcu_read_lock - register a new reader for an SRCU-protected structure.
	219	* @sp: srcu_struct in which to register the new reader.
	220	*
	221	* Enter an SRCU read-side critical section. Note that SRCU read-side
73d4da4d PM	222	* critical sections may be nested. However, it is illegal to
	223	* call anything that waits on an SRCU grace period for the same
	224	* srcu_struct, whether directly or indirectly. Please note that
	225	* one way to indirectly wait on an SRCU grace period is to acquire
	226	* a mutex that is held elsewhere while calling synchronize_srcu() or
	227	* synchronize_srcu_expedited().
3842a083 PM	228	*
	229	* Note that srcu_read_lock() and the matching srcu_read_unlock() must
	230	* occur in the same context, for example, it is illegal to invoke
	231	* srcu_read_unlock() in an irq handler if the matching srcu_read_lock()
	232	* was invoked in process context.
632ee200 PM	233	*/
	234	static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
	235	{
	236	int retval = __srcu_read_lock(sp);
	237
ff195cb6	238	rcu_lock_acquire(&(sp)->dep_map);
bde23c68 HC	239	rcu_lockdep_assert(!rcu_is_cpu_idle(),
bde23c68 HC	240	"srcu_read_lock() used illegally while idle");
632ee200 PM	241	return retval;
	242	}
	243
	244	/**
	245	* srcu_read_unlock - unregister a old reader from an SRCU-protected structure.
	246	* @sp: srcu_struct in which to unregister the old reader.
	247	* @idx: return value from corresponding srcu_read_lock().
	248	*
	249	* Exit an SRCU read-side critical section.
	250	*/
	251	static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
	252	__releases(sp)
	253	{
bde23c68 HC	254	rcu_lockdep_assert(!rcu_is_cpu_idle(),
bde23c68 HC	255	"srcu_read_unlock() used illegally while idle");
ff195cb6	256	rcu_lock_release(&(sp)->dep_map);
632ee200 PM	257	__srcu_read_unlock(sp, idx);
	258	}
	259
0c53dd8b PM	260	/**
	261	* srcu_read_lock_raw - register a new reader for an SRCU-protected structure.
	262	* @sp: srcu_struct in which to register the new reader.
	263	*
	264	* Enter an SRCU read-side critical section. Similar to srcu_read_lock(),
	265	* but avoids the RCU-lockdep checking. This means that it is legal to
	266	* use srcu_read_lock_raw() in one context, for example, in an exception
	267	* handler, and then have the matching srcu_read_unlock_raw() in another
	268	* context, for example in the task that took the exception.
	269	*
	270	* However, the entire SRCU read-side critical section must reside within a
	271	* single task. For example, beware of using srcu_read_lock_raw() in
	272	* a device interrupt handler and srcu_read_unlock() in the interrupted
	273	* task: This will not work if interrupts are threaded.
	274	*/
	275	static inline int srcu_read_lock_raw(struct srcu_struct *sp)
	276	{
	277	unsigned long flags;
	278	int ret;
	279
	280	local_irq_save(flags);
	281	ret = __srcu_read_lock(sp);
	282	local_irq_restore(flags);
	283	return ret;
	284	}
	285
	286	/**
	287	* srcu_read_unlock_raw - unregister reader from an SRCU-protected structure.
	288	* @sp: srcu_struct in which to unregister the old reader.
	289	* @idx: return value from corresponding srcu_read_lock_raw().
	290	*
	291	* Exit an SRCU read-side critical section without lockdep-RCU checking.
	292	* See srcu_read_lock_raw() for more details.
	293	*/
	294	static inline void srcu_read_unlock_raw(struct srcu_struct *sp, int idx)
	295	{
	296	unsigned long flags;
	297
	298	local_irq_save(flags);
	299	__srcu_read_unlock(sp, idx);
	300	local_irq_restore(flags);
	301	}
	302
eabc0694	303	#endif