Merge branches 'doc.2021.07.20c', 'fixes.2021.08.06a', 'nocb.2021.07.20c',... (b770efc4) · Commits · EulixOS / Software / Kernel

include/linux/rculist.h

+17 −18

Original line number	Diff line number	Diff line
		@@ -10,15 +10,6 @@
		#include <linux/list.h>
		#include <linux/rcupdate.h>

		/*
		* Why is there no list_empty_rcu()? Because list_empty() serves this
		* purpose. The list_empty() function fetches the RCU-protected pointer
		* and compares it to the address of the list head, but neither dereferences
		* this pointer itself nor provides this pointer to the caller. Therefore,
		* it is not necessary to use rcu_dereference(), so that list_empty() can
		* be used anywhere you would want to use a list_empty_rcu().
		*/

		/*
		* INIT_LIST_HEAD_RCU - Initialize a list_head visible to RCU readers
		* @list: list to be initialized
		@@ -318,21 +309,29 @@ static inline void list_splice_tail_init_rcu(struct list_head *list,
		/*
		* Where are list_empty_rcu() and list_first_entry_rcu()?
		*
		* Implementing those functions following their counterparts list_empty() and
		* list_first_entry() is not advisable because they lead to subtle race
		* conditions as the following snippet shows:
		* They do not exist because they would lead to subtle race conditions:
		*
		* if (!list_empty_rcu(mylist)) {
		* struct foo *bar = list_first_entry_rcu(mylist, struct foo, list_member);
		* do_something(bar);
		* }
		*
		* The list may not be empty when list_empty_rcu checks it, but it may be when
		* list_first_entry_rcu rereads the ->next pointer.
		*
		* Rereading the ->next pointer is not a problem for list_empty() and
		* list_first_entry() because they would be protected by a lock that blocks
		* writers.
		* The list might be non-empty when list_empty_rcu() checks it, but it
		* might have become empty by the time that list_first_entry_rcu() rereads
		* the ->next pointer, which would result in a SEGV.
		*
		* When not using RCU, it is OK for list_first_entry() to re-read that
		* pointer because both functions should be protected by some lock that
		* blocks writers.
		*
		* When using RCU, list_empty() uses READ_ONCE() to fetch the
		* RCU-protected ->next pointer and then compares it to the address of the
		* list head. However, it neither dereferences this pointer nor provides
		* this pointer to its caller. Thus, READ_ONCE() suffices (that is,
		* rcu_dereference() is not needed), which means that list_empty() can be
		* used anywhere you would want to use list_empty_rcu(). Just don't
		* expect anything useful to happen if you do a subsequent lockless
		* call to list_first_entry_rcu()!!!
		*
		* See list_first_or_null_rcu for an alternative.
		*/

include/linux/rcupdate.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -53,7 +53,7 @@ void __rcu_read_unlock(void);
		* 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)
		#define rcu_preempt_depth() READ_ONCE(current->rcu_read_lock_nesting)

		#else /* #ifdef CONFIG_PREEMPT_RCU */

		@@ -167,7 +167,7 @@ void synchronize_rcu_tasks(void);
		# define synchronize_rcu_tasks synchronize_rcu
		# endif

		# ifdef CONFIG_TASKS_RCU_TRACE
		# ifdef CONFIG_TASKS_TRACE_RCU
		# define rcu_tasks_trace_qs(t) \
		do { \
		if (!likely(READ_ONCE((t)->trc_reader_checked)) && \

include/linux/rcutiny.h

+0 −3

Original line number	Diff line number	Diff line
		@@ -14,9 +14,6 @@

		#include <asm/param.h> /* for HZ */

		/* Never flag non-existent other CPUs! */
		static inline bool rcu_eqs_special_set(int cpu) { return false; }

		unsigned long get_state_synchronize_rcu(void);
		unsigned long start_poll_synchronize_rcu(void);
		bool poll_state_synchronize_rcu(unsigned long oldstate);

include/linux/srcutiny.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -61,7 +61,7 @@ static inline int __srcu_read_lock(struct srcu_struct *ssp)
		int idx;

		idx = ((READ_ONCE(ssp->srcu_idx) + 1) & 0x2) >> 1;
		WRITE_ONCE(ssp->srcu_lock_nesting[idx], ssp->srcu_lock_nesting[idx] + 1);
		WRITE_ONCE(ssp->srcu_lock_nesting[idx], READ_ONCE(ssp->srcu_lock_nesting[idx]) + 1);
		return idx;
		}

		@@ -81,11 +81,11 @@ static inline void srcu_torture_stats_print(struct srcu_struct *ssp,
		{
		int idx;

		idx = ((READ_ONCE(ssp->srcu_idx) + 1) & 0x2) >> 1;
		idx = ((data_race(READ_ONCE(ssp->srcu_idx)) + 1) & 0x2) >> 1;
		pr_alert("%s%s Tiny SRCU per-CPU(idx=%d): (%hd,%hd)\n",
		tt, tf, idx,
		READ_ONCE(ssp->srcu_lock_nesting[!idx]),
		READ_ONCE(ssp->srcu_lock_nesting[idx]));
		data_race(READ_ONCE(ssp->srcu_lock_nesting[!idx])),
		data_race(READ_ONCE(ssp->srcu_lock_nesting[idx])));
		}

		#endif

kernel/locking/locktorture.c

+13 −12

Original line number	Diff line number	Diff line
		@@ -59,7 +59,7 @@ static struct task_struct **writer_tasks;
		static struct task_struct **reader_tasks;

		static bool lock_is_write_held;
		static bool lock_is_read_held;
		static atomic_t lock_is_read_held;
		static unsigned long last_lock_release;

		struct lock_stress_stats {
		@@ -682,7 +682,7 @@ static int lock_torture_writer(void *arg)
		if (WARN_ON_ONCE(lock_is_write_held))
		lwsp->n_lock_fail++;
		lock_is_write_held = true;
		if (WARN_ON_ONCE(lock_is_read_held))
		if (WARN_ON_ONCE(atomic_read(&lock_is_read_held)))
		lwsp->n_lock_fail++; /* rare, but... */

		lwsp->n_lock_acquired++;
		@@ -717,13 +717,13 @@ static int lock_torture_reader(void *arg)
		schedule_timeout_uninterruptible(1);

		cxt.cur_ops->readlock(tid);
		lock_is_read_held = true;
		atomic_inc(&lock_is_read_held);
		if (WARN_ON_ONCE(lock_is_write_held))
		lrsp->n_lock_fail++; /* rare, but... */

		lrsp->n_lock_acquired++;
		cxt.cur_ops->read_delay(&rand);
		lock_is_read_held = false;
		atomic_dec(&lock_is_read_held);
		cxt.cur_ops->readunlock(tid);

		stutter_wait("lock_torture_reader");
		@@ -738,20 +738,22 @@ static int lock_torture_reader(void *arg)
		static void __torture_print_stats(char *page,
		struct lock_stress_stats *statp, bool write)
		{
		long cur;
		bool fail = false;
		int i, n_stress;
		long max = 0, min = statp ? statp[0].n_lock_acquired : 0;
		long max = 0, min = statp ? data_race(statp[0].n_lock_acquired) : 0;
		long long sum = 0;

		n_stress = write ? cxt.nrealwriters_stress : cxt.nrealreaders_stress;
		for (i = 0; i < n_stress; i++) {
		if (statp[i].n_lock_fail)
		if (data_race(statp[i].n_lock_fail))
		fail = true;
		sum += statp[i].n_lock_acquired;
		if (max < statp[i].n_lock_acquired)
		max = statp[i].n_lock_acquired;
		if (min > statp[i].n_lock_acquired)
		min = statp[i].n_lock_acquired;
		cur = data_race(statp[i].n_lock_acquired);
		sum += cur;
		if (max < cur)
		max = cur;
		if (min > cur)
		min = cur;
		}
		page += sprintf(page,
		"%s: Total: %lld Max/Min: %ld/%ld %s Fail: %d %s\n",
		@@ -996,7 +998,6 @@ static int __init lock_torture_init(void)
		}

		if (nreaders_stress) {
		lock_is_read_held = false;
		cxt.lrsa = kmalloc_array(cxt.nrealreaders_stress,
		sizeof(*cxt.lrsa),
		GFP_KERNEL);