Commit 4a5f133c authored by Paul E. McKenney's avatar Paul E. McKenney
Browse files

rcutorture: Add races with task-exit processing 



Several variants of Linux-kernel RCU interact with task-exit processing,
including preemptible RCU, Tasks RCU, and Tasks Trace RCU.  This commit
therefore adds testing of this interaction to rcutorture by adding
rcutorture.read_exit_burst and rcutorture.read_exit_delay kernel-boot
parameters.  These kernel parameters control the frequency and spacing
of special read-then-exit kthreads that are spawned.

[ paulmck: Apply feedback from Dan Carpenter's static checker. ]
[ paulmck: Reduce latency to avoid false-positive shutdown hangs. ]
Signed-off-by: default avatarPaul E. McKenney <paulmck@kernel.org>
parent d02c6b52

Documentation/admin-guide/kernel-parameters.txt

+14 −0
Original line number Diff line number Diff line
@@ -4258,6 +4258,20 @@ 
			Set time (jiffies) between CPU-hotplug operations,

			or zero to disable CPU-hotplug testing.



	rcutorture.read_exit= [KNL]

			Set the number of read-then-exit kthreads used

			to test the interaction of RCU updaters and

			task-exit processing.



	rcutorture.read_exit_burst= [KNL]

			The number of times in a given read-then-exit

			episode that a set of read-then-exit kthreads

			is spawned.



	rcutorture.read_exit_delay= [KNL]

			The delay, in seconds, between successive

			read-then-exit testing episodes.



	rcutorture.shuffle_interval= [KNL]

			Set task-shuffle interval (s).  Shuffling tasks

			allows some CPUs to go into dyntick-idle mode

include/linux/torture.h

+5 −0
Original line number Diff line number Diff line
@@ -55,6 +55,11 @@ struct torture_random_state { 
#define DEFINE_TORTURE_RANDOM_PERCPU(name) \

	DEFINE_PER_CPU(struct torture_random_state, name)

unsigned long torture_random(struct torture_random_state *trsp);

static inline void torture_random_init(struct torture_random_state *trsp)

{

	trsp->trs_state = 0;

	trsp->trs_count = 0;

}



/* Task shuffler, which causes CPUs to occasionally go idle. */

void torture_shuffle_task_register(struct task_struct *tp);

kernel/rcu/rcutorture.c

+109 −3
Original line number Diff line number Diff line
@@ -109,6 +109,10 @@ torture_param(int, object_debug, 0, 
torture_param(int, onoff_holdoff, 0, "Time after boot before CPU hotplugs (s)");

torture_param(int, onoff_interval, 0,

	     "Time between CPU hotplugs (jiffies), 0=disable");

torture_param(int, read_exit_delay, 13,

	      "Delay between read-then-exit episodes (s)");

torture_param(int, read_exit_burst, 16,

	      "# of read-then-exit bursts per episode, zero to disable");

torture_param(int, shuffle_interval, 3, "Number of seconds between shuffles");

torture_param(int, shutdown_secs, 0, "Shutdown time (s), <= zero to disable.");

torture_param(int, stall_cpu, 0, "Stall duration (s), zero to disable.");
@@ -146,6 +150,7 @@ static struct task_struct *stall_task; 
static struct task_struct *fwd_prog_task;

static struct task_struct **barrier_cbs_tasks;

static struct task_struct *barrier_task;

static struct task_struct *read_exit_task;



#define RCU_TORTURE_PIPE_LEN 10
@@ -177,6 +182,7 @@ static long n_rcu_torture_boosts; 
static atomic_long_t n_rcu_torture_timers;

static long n_barrier_attempts;

static long n_barrier_successes; /* did rcu_barrier test succeed? */

static unsigned long n_read_exits;

static struct list_head rcu_torture_removed;

static unsigned long shutdown_jiffies;
@@ -1539,10 +1545,11 @@ rcu_torture_stats_print(void) 
		n_rcu_torture_boosts,

		atomic_long_read(&n_rcu_torture_timers));

	torture_onoff_stats();

	pr_cont("barrier: %ld/%ld:%ld\n",

	pr_cont("barrier: %ld/%ld:%ld ",

		data_race(n_barrier_successes),

		data_race(n_barrier_attempts),

		data_race(n_rcu_torture_barrier_error));

	pr_cont("read-exits: %ld\n", data_race(n_read_exits));



	pr_alert("%s%s ", torture_type, TORTURE_FLAG);

	if (atomic_read(&n_rcu_torture_mberror) ||
@@ -1634,7 +1641,8 @@ rcu_torture_print_module_parms(struct rcu_torture_ops *cur_ops, const char *tag) 
		 "stall_cpu=%d stall_cpu_holdoff=%d stall_cpu_irqsoff=%d "

		 "stall_cpu_block=%d "

		 "n_barrier_cbs=%d "

		 "onoff_interval=%d onoff_holdoff=%d\n",

		 "onoff_interval=%d onoff_holdoff=%d "

		 "read_exit_delay=%d read_exit_burst=%d\n",

		 torture_type, tag, nrealreaders, nfakewriters,

		 stat_interval, verbose, test_no_idle_hz, shuffle_interval,

		 stutter, irqreader, fqs_duration, fqs_holdoff, fqs_stutter,
@@ -1643,7 +1651,8 @@ rcu_torture_print_module_parms(struct rcu_torture_ops *cur_ops, const char *tag) 
		 stall_cpu, stall_cpu_holdoff, stall_cpu_irqsoff,

		 stall_cpu_block,

		 n_barrier_cbs,

		 onoff_interval, onoff_holdoff);

		 onoff_interval, onoff_holdoff,

		 read_exit_delay, read_exit_burst);

}



static int rcutorture_booster_cleanup(unsigned int cpu)
@@ -2338,6 +2347,99 @@ static bool rcu_torture_can_boost(void) 
	return true;

}



static bool read_exit_child_stop;

static bool read_exit_child_stopped;

static wait_queue_head_t read_exit_wq;



// Child kthread which just does an rcutorture reader and exits.

static int rcu_torture_read_exit_child(void *trsp_in)

{

	struct torture_random_state *trsp = trsp_in;



	set_user_nice(current, MAX_NICE);

	// Minimize time between reading and exiting.

	while (!kthread_should_stop())

		schedule_timeout_uninterruptible(1);

	(void)rcu_torture_one_read(trsp);

	return 0;

}



// Parent kthread which creates and destroys read-exit child kthreads.

static int rcu_torture_read_exit(void *unused)

{

	int count = 0;

	bool errexit = false;

	int i;

	struct task_struct *tsp;

	DEFINE_TORTURE_RANDOM(trs);



	// Allocate and initialize.

	set_user_nice(current, MAX_NICE);

	VERBOSE_TOROUT_STRING("rcu_torture_read_exit: Start of test");



	// Each pass through this loop does one read-exit episode.

	do {

		if (++count > read_exit_burst) {

			VERBOSE_TOROUT_STRING("rcu_torture_read_exit: End of episode");

			rcu_barrier(); // Wait for task_struct free, avoid OOM.

			for (i = 0; i < read_exit_delay; i++) {

				schedule_timeout_uninterruptible(HZ);

				if (READ_ONCE(read_exit_child_stop))

					break;

			}

			if (!READ_ONCE(read_exit_child_stop))

				VERBOSE_TOROUT_STRING("rcu_torture_read_exit: Start of episode");

			count = 0;

		}

		if (READ_ONCE(read_exit_child_stop))

			break;

		// Spawn child.

		tsp = kthread_run(rcu_torture_read_exit_child,

				     &trs, "%s",

				     "rcu_torture_read_exit_child");

		if (IS_ERR(tsp)) {

			VERBOSE_TOROUT_ERRSTRING("out of memory");

			errexit = true;

			tsp = NULL;

			break;

		}

		cond_resched();

		kthread_stop(tsp);

		n_read_exits ++;

		stutter_wait("rcu_torture_read_exit");

	} while (!errexit && !READ_ONCE(read_exit_child_stop));



	// Clean up and exit.

	smp_store_release(&read_exit_child_stopped, true); // After reaping.

	smp_mb(); // Store before wakeup.

	wake_up(&read_exit_wq);

	while (!torture_must_stop())

		schedule_timeout_uninterruptible(1);

	torture_kthread_stopping("rcu_torture_read_exit");

	return 0;

}



static int rcu_torture_read_exit_init(void)

{

	if (read_exit_burst <= 0)

		return -EINVAL;

	init_waitqueue_head(&read_exit_wq);

	read_exit_child_stop = false;

	read_exit_child_stopped = false;

	return torture_create_kthread(rcu_torture_read_exit, NULL,

				      read_exit_task);

}



static void rcu_torture_read_exit_cleanup(void)

{

	if (!read_exit_task)

		return;

	WRITE_ONCE(read_exit_child_stop, true);

	smp_mb(); // Above write before wait.

	wait_event(read_exit_wq, smp_load_acquire(&read_exit_child_stopped));

	torture_stop_kthread(rcutorture_read_exit, read_exit_task);

}



static enum cpuhp_state rcutor_hp;



static void
@@ -2359,6 +2461,7 @@ rcu_torture_cleanup(void) 
	}



	show_rcu_gp_kthreads();

	rcu_torture_read_exit_cleanup();

	rcu_torture_barrier_cleanup();

	torture_stop_kthread(rcu_torture_fwd_prog, fwd_prog_task);

	torture_stop_kthread(rcu_torture_stall, stall_task);
@@ -2680,6 +2783,9 @@ rcu_torture_init(void) 
	if (firsterr)

		goto unwind;

	firsterr = rcu_torture_barrier_init();

	if (firsterr)

		goto unwind;

	firsterr = rcu_torture_read_exit_init();

	if (firsterr)

		goto unwind;

	if (object_debug)

CRA Git | Maintained and supported by SUSTech CRA and CCSE