Merge branch 'rcu/srcu' of... (ac0e3202) · Commits · 戴 / test

include/linux/srcu.h

+3 −23

Original line number	Diff line number	Diff line
		@@ -151,30 +151,14 @@ void srcu_barrier(struct srcu_struct *sp);
		* 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.
		* 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;
		if (rcu_is_cpu_idle())
		return 0;
		if (!rcu_lockdep_current_cpu_online())
		return 0;
		return lock_is_held(&sp->dep_map);
		}

		@@ -236,8 +220,6 @@ 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;
		}

		@@ -251,8 +233,6 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
		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);
		}

kernel/srcu.c

+16 −21

Original line number	Diff line number	Diff line
		@@ -282,12 +282,8 @@ static int srcu_readers_active(struct srcu_struct *sp)
		*/
		void cleanup_srcu_struct(struct srcu_struct *sp)
		{
		int sum;

		sum = srcu_readers_active(sp);
		WARN_ON(sum); /* Leakage unless caller handles error. */
		if (sum != 0)
		return;
		if (WARN_ON(srcu_readers_active(sp)))
		return; /* Leakage unless caller handles error. */
		free_percpu(sp->per_cpu_ref);
		sp->per_cpu_ref = NULL;
		}
		@@ -302,9 +298,8 @@ int __srcu_read_lock(struct srcu_struct *sp)
		{
		int idx;

		idx = ACCESS_ONCE(sp->completed) & 0x1;
		preempt_disable();
		idx = rcu_dereference_index_check(sp->completed,
		rcu_read_lock_sched_held()) & 0x1;
		ACCESS_ONCE(this_cpu_ptr(sp->per_cpu_ref)->c[idx]) += 1;
		smp_mb(); /* B / / Avoid leaking the critical section. */
		ACCESS_ONCE(this_cpu_ptr(sp->per_cpu_ref)->seq[idx]) += 1;
		@@ -321,10 +316,8 @@ EXPORT_SYMBOL_GPL(__srcu_read_lock);
		*/
		void __srcu_read_unlock(struct srcu_struct *sp, int idx)
		{
		preempt_disable();
		smp_mb(); /* C / / Avoid leaking the critical section. */
		ACCESS_ONCE(this_cpu_ptr(sp->per_cpu_ref)->c[idx]) -= 1;
		preempt_enable();
		this_cpu_dec(sp->per_cpu_ref->c[idx]);
		}
		EXPORT_SYMBOL_GPL(__srcu_read_unlock);

		@@ -423,6 +416,7 @@ static void __synchronize_srcu(struct srcu_struct *sp, int trycount)
		!lock_is_held(&rcu_sched_lock_map),
		"Illegal synchronize_srcu() in same-type SRCU (or RCU) read-side critical section");

		might_sleep();
		init_completion(&rcu.completion);

		head->next = NULL;
		@@ -455,10 +449,12 @@ static void __synchronize_srcu(struct srcu_struct *sp, int trycount)
		* synchronize_srcu - wait for prior SRCU read-side critical-section completion
		* @sp: srcu_struct with which to synchronize.
		*
		* Flip the completed counter, and wait for the old count to drain to zero.
		* As with classic RCU, the updater must use some separate means of
		* synchronizing concurrent updates. Can block; must be called from
		* process context.
		* Wait for the count to drain to zero of both indexes. To avoid the
		* possible starvation of synchronize_srcu(), it waits for the count of
		* the index=((->completed & 1) ^ 1) to drain to zero at first,
		* and then flip the completed and wait for the count of the other index.
		*
		* Can block; must be called from process context.
		*
		* Note that it is illegal to call synchronize_srcu() from the corresponding
		* SRCU read-side critical section; doing so will result in deadlock.
		@@ -480,12 +476,11 @@ EXPORT_SYMBOL_GPL(synchronize_srcu);
		* Wait for an SRCU grace period to elapse, but be more aggressive about
		* spinning rather than blocking when waiting.
		*
		* Note that it is illegal to call this function while holding any lock
		* that is acquired by a CPU-hotplug notifier. It is also illegal to call
		* synchronize_srcu_expedited() from the corresponding SRCU read-side
		* critical section; doing so will result in deadlock. However, it is
		* perfectly legal to call synchronize_srcu_expedited() on one srcu_struct
		* from some other srcu_struct's read-side critical section, as long as
		* Note that it is also illegal to call synchronize_srcu_expedited()
		* from the corresponding SRCU read-side critical section;
		* doing so will result in deadlock. However, it is perfectly legal
		* to call synchronize_srcu_expedited() on one srcu_struct from some
		* other srcu_struct's read-side critical section, as long as
		* the resulting graph of srcu_structs is acyclic.
		*/
		void synchronize_srcu_expedited(struct srcu_struct *sp)

Admin message