[net-next-2.6.git] / kernel / rcutorture.c

/*
 * Read-Copy Update /proc-based torture test facility
 *
 * 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, 2005
 *
 * Authors: Paul E. McKenney <paulmck@us.ibm.com>
 *
 * See also:  Documentation/RCU/torture.txt
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/err.h>
#include <linux/spinlock.h>
#include <linux/smp.h>
#include <linux/rcupdate.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <asm/atomic.h>
#include <linux/bitops.h>
#include <linux/module.h>
#include <linux/completion.h>
#include <linux/moduleparam.h>
#include <linux/percpu.h>
#include <linux/notifier.h>
#include <linux/cpu.h>
#include <linux/random.h>
#include <linux/delay.h>
#include <linux/byteorder/swabb.h>
#include <linux/stat.h>

MODULE_LICENSE("GPL");

static int nreaders = -1;	/* # reader threads, defaults to 4*ncpus */
static int stat_interval;	/* Interval between stats, in seconds. */
				/*  Defaults to "only at end of test". */
static int verbose;		/* Print more debug info. */
static int test_no_idle_hz;	/* Test RCU's support for tickless idle CPUs. */
static int shuffle_interval = 5; /* Interval between shuffles (in sec)*/

MODULE_PARM(nreaders, "i");
MODULE_PARM_DESC(nreaders, "Number of RCU reader threads");
MODULE_PARM(stat_interval, "i");
MODULE_PARM_DESC(stat_interval, "Number of seconds between stats printk()s");
MODULE_PARM(verbose, "i");
MODULE_PARM_DESC(verbose, "Enable verbose debugging printk()s");
MODULE_PARM(test_no_idle_hz, "i");
MODULE_PARM_DESC(test_no_idle_hz, "Test support for tickless idle CPUs");
MODULE_PARM(shuffle_interval, "i");
MODULE_PARM_DESC(shuffle_interval, "Number of seconds between shuffles");
#define TORTURE_FLAG "rcutorture: "
#define PRINTK_STRING(s) \
	do { printk(KERN_ALERT TORTURE_FLAG s "\n"); } while (0)
#define VERBOSE_PRINTK_STRING(s) \
	do { if (verbose) printk(KERN_ALERT TORTURE_FLAG s "\n"); } while (0)
#define VERBOSE_PRINTK_ERRSTRING(s) \
	do { if (verbose) printk(KERN_ALERT TORTURE_FLAG "!!! " s "\n"); } while (0)

static char printk_buf[4096];

static int nrealreaders;
static struct task_struct *writer_task;
static struct task_struct **reader_tasks;
static struct task_struct *stats_task;
static struct task_struct *shuffler_task;

#define RCU_TORTURE_PIPE_LEN 10

struct rcu_torture {
	struct rcu_head rtort_rcu;
	int rtort_pipe_count;
	struct list_head rtort_free;
	int rtort_mbtest;
};

static int fullstop = 0;	/* stop generating callbacks at test end. */
static LIST_HEAD(rcu_torture_freelist);
static struct rcu_torture *rcu_torture_current = NULL;
static long rcu_torture_current_version = 0;
static struct rcu_torture rcu_tortures[10 * RCU_TORTURE_PIPE_LEN];
static DEFINE_SPINLOCK(rcu_torture_lock);
static DEFINE_PER_CPU(long [RCU_TORTURE_PIPE_LEN + 1], rcu_torture_count) =
	{ 0 };
static DEFINE_PER_CPU(long [RCU_TORTURE_PIPE_LEN + 1], rcu_torture_batch) =
	{ 0 };
static atomic_t rcu_torture_wcount[RCU_TORTURE_PIPE_LEN + 1];
atomic_t n_rcu_torture_alloc;
atomic_t n_rcu_torture_alloc_fail;
atomic_t n_rcu_torture_free;
atomic_t n_rcu_torture_mberror;
atomic_t n_rcu_torture_error;

/*
 * Allocate an element from the rcu_tortures pool.
 */
static struct rcu_torture *
rcu_torture_alloc(void)
{
	struct list_head *p;

	spin_lock_bh(&rcu_torture_lock);
	if (list_empty(&rcu_torture_freelist)) {
		atomic_inc(&n_rcu_torture_alloc_fail);
		spin_unlock_bh(&rcu_torture_lock);
		return NULL;
	}
	atomic_inc(&n_rcu_torture_alloc);
	p = rcu_torture_freelist.next;
	list_del_init(p);
	spin_unlock_bh(&rcu_torture_lock);
	return container_of(p, struct rcu_torture, rtort_free);
}

/*
 * Free an element to the rcu_tortures pool.
 */
static void
rcu_torture_free(struct rcu_torture *p)
{
	atomic_inc(&n_rcu_torture_free);
	spin_lock_bh(&rcu_torture_lock);
	list_add_tail(&p->rtort_free, &rcu_torture_freelist);
	spin_unlock_bh(&rcu_torture_lock);
}

static void
rcu_torture_cb(struct rcu_head *p)
{
	int i;
	struct rcu_torture *rp = container_of(p, struct rcu_torture, rtort_rcu);

	if (fullstop) {
		/* Test is ending, just drop callbacks on the floor. */
		/* The next initialization will pick up the pieces. */
		return;
	}
	i = rp->rtort_pipe_count;
	if (i > RCU_TORTURE_PIPE_LEN)
		i = RCU_TORTURE_PIPE_LEN;
	atomic_inc(&rcu_torture_wcount[i]);
	if (++rp->rtort_pipe_count >= RCU_TORTURE_PIPE_LEN) {
		rp->rtort_mbtest = 0;
		rcu_torture_free(rp);
	} else
		call_rcu(p, rcu_torture_cb);
}

struct rcu_random_state {
	unsigned long rrs_state;
	unsigned long rrs_count;
};

#define RCU_RANDOM_MULT 39916801  /* prime */
#define RCU_RANDOM_ADD	479001701 /* prime */
#define RCU_RANDOM_REFRESH 10000

#define DEFINE_RCU_RANDOM(name) struct rcu_random_state name = { 0, 0 }

/*
 * Crude but fast random-number generator.  Uses a linear congruential
 * generator, with occasional help from get_random_bytes().
 */
static long
rcu_random(struct rcu_random_state *rrsp)
{
	long refresh;

	if (--rrsp->rrs_count < 0) {
		get_random_bytes(&refresh, sizeof(refresh));
		rrsp->rrs_state += refresh;
		rrsp->rrs_count = RCU_RANDOM_REFRESH;
	}
	rrsp->rrs_state = rrsp->rrs_state * RCU_RANDOM_MULT + RCU_RANDOM_ADD;
	return swahw32(rrsp->rrs_state);
}

/*
 * RCU torture writer kthread.  Repeatedly substitutes a new structure
 * for that pointed to by rcu_torture_current, freeing the old structure
 * after a series of grace periods (the "pipeline").
 */
static int
rcu_torture_writer(void *arg)
{
	int i;
	long oldbatch = rcu_batches_completed();
	struct rcu_torture *rp;
	struct rcu_torture *old_rp;
	static DEFINE_RCU_RANDOM(rand);

	VERBOSE_PRINTK_STRING("rcu_torture_writer task started");
	set_user_nice(current, 19);

	do {
		schedule_timeout_uninterruptible(1);
		if (rcu_batches_completed() == oldbatch)
			continue;
		if ((rp = rcu_torture_alloc()) == NULL)
			continue;
		rp->rtort_pipe_count = 0;
		udelay(rcu_random(&rand) & 0x3ff);
		old_rp = rcu_torture_current;
		rp->rtort_mbtest = 1;
		rcu_assign_pointer(rcu_torture_current, rp);
		smp_wmb();
		if (old_rp != NULL) {
			i = old_rp->rtort_pipe_count;
			if (i > RCU_TORTURE_PIPE_LEN)
				i = RCU_TORTURE_PIPE_LEN;
			atomic_inc(&rcu_torture_wcount[i]);
			old_rp->rtort_pipe_count++;
			call_rcu(&old_rp->rtort_rcu, rcu_torture_cb);
		}
		rcu_torture_current_version++;
		oldbatch = rcu_batches_completed();
	} while (!kthread_should_stop() && !fullstop);
	VERBOSE_PRINTK_STRING("rcu_torture_writer task stopping");
	while (!kthread_should_stop())
		schedule_timeout_uninterruptible(1);
	return 0;
}

/*
 * RCU torture reader kthread.  Repeatedly dereferences rcu_torture_current,
 * incrementing the corresponding element of the pipeline array.  The
 * counter in the element should never be greater than 1, otherwise, the
 * RCU implementation is broken.
 */
static int
rcu_torture_reader(void *arg)
{
	int completed;
	DEFINE_RCU_RANDOM(rand);
	struct rcu_torture *p;
	int pipe_count;

	VERBOSE_PRINTK_STRING("rcu_torture_reader task started");
	set_user_nice(current, 19);

	do {
		rcu_read_lock();
		completed = rcu_batches_completed();
		p = rcu_dereference(rcu_torture_current);
		if (p == NULL) {
			/* Wait for rcu_torture_writer to get underway */
			rcu_read_unlock();
			schedule_timeout_interruptible(HZ);
			continue;
		}
		if (p->rtort_mbtest == 0)
			atomic_inc(&n_rcu_torture_mberror);
		udelay(rcu_random(&rand) & 0x7f);
		preempt_disable();
		pipe_count = p->rtort_pipe_count;
		if (pipe_count > RCU_TORTURE_PIPE_LEN) {
			/* Should not happen, but... */
			pipe_count = RCU_TORTURE_PIPE_LEN;
		}
		++__get_cpu_var(rcu_torture_count)[pipe_count];
		completed = rcu_batches_completed() - completed;
		if (completed > RCU_TORTURE_PIPE_LEN) {
			/* Should not happen, but... */
			completed = RCU_TORTURE_PIPE_LEN;
		}
		++__get_cpu_var(rcu_torture_batch)[completed];
		preempt_enable();
		rcu_read_unlock();
		schedule();
	} while (!kthread_should_stop() && !fullstop);
	VERBOSE_PRINTK_STRING("rcu_torture_reader task stopping");
	while (!kthread_should_stop())
		schedule_timeout_uninterruptible(1);
	return 0;
}

/*
 * Create an RCU-torture statistics message in the specified buffer.
 */
static int
rcu_torture_printk(char *page)
{
	int cnt = 0;
	int cpu;
	int i;
	long pipesummary[RCU_TORTURE_PIPE_LEN + 1] = { 0 };
	long batchsummary[RCU_TORTURE_PIPE_LEN + 1] = { 0 };

	for_each_cpu(cpu) {
		for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++) {
			pipesummary[i] += per_cpu(rcu_torture_count, cpu)[i];
			batchsummary[i] += per_cpu(rcu_torture_batch, cpu)[i];
		}
	}
	for (i = RCU_TORTURE_PIPE_LEN - 1; i >= 0; i--) {
		if (pipesummary[i] != 0)
			break;
	}
	cnt += sprintf(&page[cnt], "rcutorture: ");
	cnt += sprintf(&page[cnt],
		       "rtc: %p ver: %ld tfle: %d rta: %d rtaf: %d rtf: %d "
		       "rtmbe: %d",
		       rcu_torture_current,
		       rcu_torture_current_version,
		       list_empty(&rcu_torture_freelist),
		       atomic_read(&n_rcu_torture_alloc),
		       atomic_read(&n_rcu_torture_alloc_fail),
		       atomic_read(&n_rcu_torture_free),
		       atomic_read(&n_rcu_torture_mberror));
	if (atomic_read(&n_rcu_torture_mberror) != 0)
		cnt += sprintf(&page[cnt], " !!!");
	cnt += sprintf(&page[cnt], "\nrcutorture: ");
	if (i > 1) {
		cnt += sprintf(&page[cnt], "!!! ");
		atomic_inc(&n_rcu_torture_error);
	}
	cnt += sprintf(&page[cnt], "Reader Pipe: ");
	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++)
		cnt += sprintf(&page[cnt], " %ld", pipesummary[i]);
	cnt += sprintf(&page[cnt], "\nrcutorture: ");
	cnt += sprintf(&page[cnt], "Reader Batch: ");
	for (i = 0; i < RCU_TORTURE_PIPE_LEN; i++)
		cnt += sprintf(&page[cnt], " %ld", batchsummary[i]);
	cnt += sprintf(&page[cnt], "\nrcutorture: ");
	cnt += sprintf(&page[cnt], "Free-Block Circulation: ");
	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++) {
		cnt += sprintf(&page[cnt], " %d",
			       atomic_read(&rcu_torture_wcount[i]));
	}
	cnt += sprintf(&page[cnt], "\n");
	return cnt;
}

/*
 * Print torture statistics.  Caller must ensure that there is only
 * one call to this function at a given time!!!  This is normally
 * accomplished by relying on the module system to only have one copy
 * of the module loaded, and then by giving the rcu_torture_stats
 * kthread full control (or the init/cleanup functions when rcu_torture_stats
 * thread is not running).
 */
static void
rcu_torture_stats_print(void)
{
	int cnt;

	cnt = rcu_torture_printk(printk_buf);
	printk(KERN_ALERT "%s", printk_buf);
}

/*
 * Periodically prints torture statistics, if periodic statistics printing
 * was specified via the stat_interval module parameter.
 *
 * No need to worry about fullstop here, since this one doesn't reference
 * volatile state or register callbacks.
 */
static int
rcu_torture_stats(void *arg)
{
	VERBOSE_PRINTK_STRING("rcu_torture_stats task started");
	do {
		schedule_timeout_interruptible(stat_interval * HZ);
		rcu_torture_stats_print();
	} while (!kthread_should_stop());
	VERBOSE_PRINTK_STRING("rcu_torture_stats task stopping");
	return 0;
}

static int rcu_idle_cpu;	/* Force all torture tasks off this CPU */

/* Shuffle tasks such that we allow @rcu_idle_cpu to become idle. A special case
 * is when @rcu_idle_cpu = -1, when we allow the tasks to run on all CPUs.
 */
void rcu_torture_shuffle_tasks(void)
{
	cpumask_t tmp_mask = CPU_MASK_ALL;
	int i;

	lock_cpu_hotplug();

	/* No point in shuffling if there is only one online CPU (ex: UP) */
	if (num_online_cpus() == 1) {
		unlock_cpu_hotplug();
		return;
	}

	if (rcu_idle_cpu != -1)
		cpu_clear(rcu_idle_cpu, tmp_mask);

	set_cpus_allowed(current, tmp_mask);

	if (reader_tasks != NULL) {
		for (i = 0; i < nrealreaders; i++)
			if (reader_tasks[i])
				set_cpus_allowed(reader_tasks[i], tmp_mask);
	}

	if (writer_task)
		set_cpus_allowed(writer_task, tmp_mask);

	if (stats_task)
		set_cpus_allowed(stats_task, tmp_mask);

	if (rcu_idle_cpu == -1)
		rcu_idle_cpu = num_online_cpus() - 1;
	else
		rcu_idle_cpu--;

	unlock_cpu_hotplug();
}

/* Shuffle tasks across CPUs, with the intent of allowing each CPU in the
 * system to become idle at a time and cut off its timer ticks. This is meant
 * to test the support for such tickless idle CPU in RCU.
 */
static int
rcu_torture_shuffle(void *arg)
{
	VERBOSE_PRINTK_STRING("rcu_torture_shuffle task started");
	do {
		schedule_timeout_interruptible(shuffle_interval * HZ);
		rcu_torture_shuffle_tasks();
	} while (!kthread_should_stop());
	VERBOSE_PRINTK_STRING("rcu_torture_shuffle task stopping");
	return 0;
}

static void
rcu_torture_cleanup(void)
{
	int i;

	fullstop = 1;
	if (shuffler_task != NULL) {
		VERBOSE_PRINTK_STRING("Stopping rcu_torture_shuffle task");
		kthread_stop(shuffler_task);
	}
	shuffler_task = NULL;

	if (writer_task != NULL) {
		VERBOSE_PRINTK_STRING("Stopping rcu_torture_writer task");
		kthread_stop(writer_task);
	}
	writer_task = NULL;

	if (reader_tasks != NULL) {
		for (i = 0; i < nrealreaders; i++) {
			if (reader_tasks[i] != NULL) {
				VERBOSE_PRINTK_STRING(
					"Stopping rcu_torture_reader task");
				kthread_stop(reader_tasks[i]);
			}
			reader_tasks[i] = NULL;
		}
		kfree(reader_tasks);
		reader_tasks = NULL;
	}
	rcu_torture_current = NULL;

	if (stats_task != NULL) {
		VERBOSE_PRINTK_STRING("Stopping rcu_torture_stats task");
		kthread_stop(stats_task);
	}
	stats_task = NULL;

	/* Wait for all RCU callbacks to fire.  */
	rcu_barrier();

	rcu_torture_stats_print();  /* -After- the stats thread is stopped! */
	printk(KERN_ALERT TORTURE_FLAG
	       "--- End of test: %s\n",
	       atomic_read(&n_rcu_torture_error) == 0 ? "SUCCESS" : "FAILURE");
}

static int
rcu_torture_init(void)
{
	int i;
	int cpu;
	int firsterr = 0;

	/* Process args and tell the world that the torturer is on the job. */

	if (nreaders >= 0)
		nrealreaders = nreaders;
	else
		nrealreaders = 2 * num_online_cpus();
	printk(KERN_ALERT TORTURE_FLAG "--- Start of test: nreaders=%d "
		"stat_interval=%d verbose=%d test_no_idle_hz=%d "
		"shuffle_interval = %d\n",
		nrealreaders, stat_interval, verbose, test_no_idle_hz,
		shuffle_interval);
	fullstop = 0;

	/* Set up the freelist. */

	INIT_LIST_HEAD(&rcu_torture_freelist);
	for (i = 0; i < sizeof(rcu_tortures) / sizeof(rcu_tortures[0]); i++) {
		rcu_tortures[i].rtort_mbtest = 0;
		list_add_tail(&rcu_tortures[i].rtort_free,
			      &rcu_torture_freelist);
	}

	/* Initialize the statistics so that each run gets its own numbers. */

	rcu_torture_current = NULL;
	rcu_torture_current_version = 0;
	atomic_set(&n_rcu_torture_alloc, 0);
	atomic_set(&n_rcu_torture_alloc_fail, 0);
	atomic_set(&n_rcu_torture_free, 0);
	atomic_set(&n_rcu_torture_mberror, 0);
	atomic_set(&n_rcu_torture_error, 0);
	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++)
		atomic_set(&rcu_torture_wcount[i], 0);
	for_each_cpu(cpu) {
		for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++) {
			per_cpu(rcu_torture_count, cpu)[i] = 0;
			per_cpu(rcu_torture_batch, cpu)[i] = 0;
		}
	}

	/* Start up the kthreads. */

	VERBOSE_PRINTK_STRING("Creating rcu_torture_writer task");
	writer_task = kthread_run(rcu_torture_writer, NULL,
				  "rcu_torture_writer");
	if (IS_ERR(writer_task)) {
		firsterr = PTR_ERR(writer_task);
		VERBOSE_PRINTK_ERRSTRING("Failed to create writer");
		writer_task = NULL;
		goto unwind;
	}
	reader_tasks = kmalloc(nrealreaders * sizeof(reader_tasks[0]),
			       GFP_KERNEL);
	if (reader_tasks == NULL) {
		VERBOSE_PRINTK_ERRSTRING("out of memory");
		firsterr = -ENOMEM;
		goto unwind;
	}
	for (i = 0; i < nrealreaders; i++) {
		VERBOSE_PRINTK_STRING("Creating rcu_torture_reader task");
		reader_tasks[i] = kthread_run(rcu_torture_reader, NULL,
					      "rcu_torture_reader");
		if (IS_ERR(reader_tasks[i])) {
			firsterr = PTR_ERR(reader_tasks[i]);
			VERBOSE_PRINTK_ERRSTRING("Failed to create reader");
			reader_tasks[i] = NULL;
			goto unwind;
		}
	}
	if (stat_interval > 0) {
		VERBOSE_PRINTK_STRING("Creating rcu_torture_stats task");
		stats_task = kthread_run(rcu_torture_stats, NULL,
					"rcu_torture_stats");
		if (IS_ERR(stats_task)) {
			firsterr = PTR_ERR(stats_task);
			VERBOSE_PRINTK_ERRSTRING("Failed to create stats");
			stats_task = NULL;
			goto unwind;
		}
	}
	if (test_no_idle_hz) {
		rcu_idle_cpu = num_online_cpus() - 1;
		/* Create the shuffler thread */
		shuffler_task = kthread_run(rcu_torture_shuffle, NULL,
					  "rcu_torture_shuffle");
		if (IS_ERR(shuffler_task)) {
			firsterr = PTR_ERR(shuffler_task);
			VERBOSE_PRINTK_ERRSTRING("Failed to create shuffler");
			shuffler_task = NULL;
			goto unwind;
		}
	}
	return 0;

unwind:
	rcu_torture_cleanup();
	return firsterr;
}

module_init(rcu_torture_init);
module_exit(rcu_torture_cleanup);
Commit	Line	Data
a241ec65 PM	1	/*
	2	* Read-Copy Update /proc-based torture test facility
	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, 2005
	19	*
	20	* Authors: Paul E. McKenney <paulmck@us.ibm.com>
	21	*
	22	* See also: Documentation/RCU/torture.txt
	23	*/
	24	#include <linux/types.h>
	25	#include <linux/kernel.h>
	26	#include <linux/init.h>
	27	#include <linux/module.h>
	28	#include <linux/kthread.h>
	29	#include <linux/err.h>
	30	#include <linux/spinlock.h>
	31	#include <linux/smp.h>
	32	#include <linux/rcupdate.h>
	33	#include <linux/interrupt.h>
	34	#include <linux/sched.h>
	35	#include <asm/atomic.h>
	36	#include <linux/bitops.h>
	37	#include <linux/module.h>
	38	#include <linux/completion.h>
	39	#include <linux/moduleparam.h>
	40	#include <linux/percpu.h>
	41	#include <linux/notifier.h>
a241ec65 PM	42	#include <linux/cpu.h>
	43	#include <linux/random.h>
	44	#include <linux/delay.h>
	45	#include <linux/byteorder/swabb.h>
	46	#include <linux/stat.h>
	47
	48	MODULE_LICENSE("GPL");
	49
	50	static int nreaders = -1; /* # reader threads, defaults to 4ncpus /
d84f5203	51	static int stat_interval; /* Interval between stats, in seconds. */
a241ec65	52	/* Defaults to "only at end of test". */
d84f5203 SV	53	static int verbose; /* Print more debug info. */
	54	static int test_no_idle_hz; /* Test RCU's support for tickless idle CPUs. */
	55	static int shuffle_interval = 5; /* Interval between shuffles (in sec)*/
a241ec65 PM	56
	57	MODULE_PARM(nreaders, "i");
	58	MODULE_PARM_DESC(nreaders, "Number of RCU reader threads");
	59	MODULE_PARM(stat_interval, "i");
	60	MODULE_PARM_DESC(stat_interval, "Number of seconds between stats printk()s");
	61	MODULE_PARM(verbose, "i");
	62	MODULE_PARM_DESC(verbose, "Enable verbose debugging printk()s");
d84f5203 SV	63	MODULE_PARM(test_no_idle_hz, "i");
	64	MODULE_PARM_DESC(test_no_idle_hz, "Test support for tickless idle CPUs");
	65	MODULE_PARM(shuffle_interval, "i");
	66	MODULE_PARM_DESC(shuffle_interval, "Number of seconds between shuffles");
a241ec65 PM	67	#define TORTURE_FLAG "rcutorture: "
	68	#define PRINTK_STRING(s) \
	69	do { printk(KERN_ALERT TORTURE_FLAG s "\n"); } while (0)
	70	#define VERBOSE_PRINTK_STRING(s) \
	71	do { if (verbose) printk(KERN_ALERT TORTURE_FLAG s "\n"); } while (0)
	72	#define VERBOSE_PRINTK_ERRSTRING(s) \
	73	do { if (verbose) printk(KERN_ALERT TORTURE_FLAG "!!! " s "\n"); } while (0)
	74
	75	static char printk_buf[4096];
	76
	77	static int nrealreaders;
	78	static struct task_struct *writer_task;
	79	static struct task_struct **reader_tasks;
	80	static struct task_struct *stats_task;
d84f5203	81	static struct task_struct *shuffler_task;
a241ec65 PM	82
	83	#define RCU_TORTURE_PIPE_LEN 10
	84
	85	struct rcu_torture {
	86	struct rcu_head rtort_rcu;
	87	int rtort_pipe_count;
	88	struct list_head rtort_free;
996417d2	89	int rtort_mbtest;
a241ec65 PM	90	};
	91
	92	static int fullstop = 0; /* stop generating callbacks at test end. */
	93	static LIST_HEAD(rcu_torture_freelist);
	94	static struct rcu_torture *rcu_torture_current = NULL;
	95	static long rcu_torture_current_version = 0;
	96	static struct rcu_torture rcu_tortures[10 * RCU_TORTURE_PIPE_LEN];
	97	static DEFINE_SPINLOCK(rcu_torture_lock);
	98	static DEFINE_PER_CPU(long [RCU_TORTURE_PIPE_LEN + 1], rcu_torture_count) =
	99	{ 0 };
	100	static DEFINE_PER_CPU(long [RCU_TORTURE_PIPE_LEN + 1], rcu_torture_batch) =
	101	{ 0 };
	102	static atomic_t rcu_torture_wcount[RCU_TORTURE_PIPE_LEN + 1];
	103	atomic_t n_rcu_torture_alloc;
	104	atomic_t n_rcu_torture_alloc_fail;
	105	atomic_t n_rcu_torture_free;
996417d2 PM	106	atomic_t n_rcu_torture_mberror;
996417d2 PM	107	atomic_t n_rcu_torture_error;
a241ec65 PM	108
	109	/*
	110	* Allocate an element from the rcu_tortures pool.
	111	*/
97a41e26	112	static struct rcu_torture *
a241ec65 PM	113	rcu_torture_alloc(void)
	114	{
	115	struct list_head *p;
	116
adac1665	117	spin_lock_bh(&rcu_torture_lock);
a241ec65 PM	118	if (list_empty(&rcu_torture_freelist)) {
a241ec65 PM	119	atomic_inc(&n_rcu_torture_alloc_fail);
adac1665	120	spin_unlock_bh(&rcu_torture_lock);
a241ec65 PM	121	return NULL;
	122	}
	123	atomic_inc(&n_rcu_torture_alloc);
	124	p = rcu_torture_freelist.next;
	125	list_del_init(p);
adac1665	126	spin_unlock_bh(&rcu_torture_lock);
a241ec65 PM	127	return container_of(p, struct rcu_torture, rtort_free);
	128	}
	129
	130	/*
	131	* Free an element to the rcu_tortures pool.
	132	*/
	133	static void
	134	rcu_torture_free(struct rcu_torture *p)
	135	{
	136	atomic_inc(&n_rcu_torture_free);
adac1665	137	spin_lock_bh(&rcu_torture_lock);
a241ec65	138	list_add_tail(&p->rtort_free, &rcu_torture_freelist);
adac1665	139	spin_unlock_bh(&rcu_torture_lock);
a241ec65 PM	140	}
	141
	142	static void
	143	rcu_torture_cb(struct rcu_head *p)
	144	{
	145	int i;
	146	struct rcu_torture *rp = container_of(p, struct rcu_torture, rtort_rcu);
	147
	148	if (fullstop) {
	149	/* Test is ending, just drop callbacks on the floor. */
	150	/* The next initialization will pick up the pieces. */
	151	return;
	152	}
	153	i = rp->rtort_pipe_count;
	154	if (i > RCU_TORTURE_PIPE_LEN)
	155	i = RCU_TORTURE_PIPE_LEN;
	156	atomic_inc(&rcu_torture_wcount[i]);
996417d2 PM	157	if (++rp->rtort_pipe_count >= RCU_TORTURE_PIPE_LEN) {
996417d2 PM	158	rp->rtort_mbtest = 0;
a241ec65	159	rcu_torture_free(rp);
996417d2	160	} else
a241ec65 PM	161	call_rcu(p, rcu_torture_cb);
	162	}
	163
	164	struct rcu_random_state {
	165	unsigned long rrs_state;
	166	unsigned long rrs_count;
	167	};
	168
	169	#define RCU_RANDOM_MULT 39916801 /* prime */
	170	#define RCU_RANDOM_ADD 479001701 /* prime */
	171	#define RCU_RANDOM_REFRESH 10000
	172
	173	#define DEFINE_RCU_RANDOM(name) struct rcu_random_state name = { 0, 0 }
	174
	175	/*
	176	* Crude but fast random-number generator. Uses a linear congruential
	177	* generator, with occasional help from get_random_bytes().
	178	*/
	179	static long
	180	rcu_random(struct rcu_random_state *rrsp)
	181	{
	182	long refresh;
	183
	184	if (--rrsp->rrs_count < 0) {
	185	get_random_bytes(&refresh, sizeof(refresh));
	186	rrsp->rrs_state += refresh;
	187	rrsp->rrs_count = RCU_RANDOM_REFRESH;
	188	}
	189	rrsp->rrs_state = rrsp->rrs_state * RCU_RANDOM_MULT + RCU_RANDOM_ADD;
	190	return swahw32(rrsp->rrs_state);
	191	}
	192
	193	/*
	194	* RCU torture writer kthread. Repeatedly substitutes a new structure
	195	* for that pointed to by rcu_torture_current, freeing the old structure
	196	* after a series of grace periods (the "pipeline").
	197	*/
	198	static int
	199	rcu_torture_writer(void *arg)
	200	{
	201	int i;
	202	long oldbatch = rcu_batches_completed();
	203	struct rcu_torture *rp;
	204	struct rcu_torture *old_rp;
	205	static DEFINE_RCU_RANDOM(rand);
	206
	207	VERBOSE_PRINTK_STRING("rcu_torture_writer task started");
dbdf65b1 IM	208	set_user_nice(current, 19);
dbdf65b1 IM	209
a241ec65 PM	210	do {
	211	schedule_timeout_uninterruptible(1);
	212	if (rcu_batches_completed() == oldbatch)
	213	continue;
	214	if ((rp = rcu_torture_alloc()) == NULL)
	215	continue;
	216	rp->rtort_pipe_count = 0;
	217	udelay(rcu_random(&rand) & 0x3ff);
	218	old_rp = rcu_torture_current;
996417d2	219	rp->rtort_mbtest = 1;
a241ec65 PM	220	rcu_assign_pointer(rcu_torture_current, rp);
	221	smp_wmb();
	222	if (old_rp != NULL) {
	223	i = old_rp->rtort_pipe_count;
	224	if (i > RCU_TORTURE_PIPE_LEN)
	225	i = RCU_TORTURE_PIPE_LEN;
	226	atomic_inc(&rcu_torture_wcount[i]);
	227	old_rp->rtort_pipe_count++;
	228	call_rcu(&old_rp->rtort_rcu, rcu_torture_cb);
	229	}
	230	rcu_torture_current_version++;
	231	oldbatch = rcu_batches_completed();
	232	} while (!kthread_should_stop() && !fullstop);
	233	VERBOSE_PRINTK_STRING("rcu_torture_writer task stopping");
	234	while (!kthread_should_stop())
	235	schedule_timeout_uninterruptible(1);
	236	return 0;
	237	}
	238
	239	/*
	240	* RCU torture reader kthread. Repeatedly dereferences rcu_torture_current,
	241	* incrementing the corresponding element of the pipeline array. The
	242	* counter in the element should never be greater than 1, otherwise, the
	243	* RCU implementation is broken.
	244	*/
	245	static int
	246	rcu_torture_reader(void *arg)
	247	{
	248	int completed;
	249	DEFINE_RCU_RANDOM(rand);
	250	struct rcu_torture *p;
	251	int pipe_count;
	252
	253	VERBOSE_PRINTK_STRING("rcu_torture_reader task started");
dbdf65b1 IM	254	set_user_nice(current, 19);
dbdf65b1 IM	255
a241ec65 PM	256	do {
	257	rcu_read_lock();
	258	completed = rcu_batches_completed();
	259	p = rcu_dereference(rcu_torture_current);
	260	if (p == NULL) {
	261	/* Wait for rcu_torture_writer to get underway */
	262	rcu_read_unlock();
	263	schedule_timeout_interruptible(HZ);
	264	continue;
	265	}
996417d2 PM	266	if (p->rtort_mbtest == 0)
996417d2 PM	267	atomic_inc(&n_rcu_torture_mberror);
a241ec65 PM	268	udelay(rcu_random(&rand) & 0x7f);
	269	preempt_disable();
	270	pipe_count = p->rtort_pipe_count;
	271	if (pipe_count > RCU_TORTURE_PIPE_LEN) {
	272	/* Should not happen, but... */
	273	pipe_count = RCU_TORTURE_PIPE_LEN;
	274	}
	275	++__get_cpu_var(rcu_torture_count)[pipe_count];
	276	completed = rcu_batches_completed() - completed;
	277	if (completed > RCU_TORTURE_PIPE_LEN) {
	278	/* Should not happen, but... */
	279	completed = RCU_TORTURE_PIPE_LEN;
	280	}
	281	++__get_cpu_var(rcu_torture_batch)[completed];
	282	preempt_enable();
	283	rcu_read_unlock();
	284	schedule();
	285	} while (!kthread_should_stop() && !fullstop);
	286	VERBOSE_PRINTK_STRING("rcu_torture_reader task stopping");
	287	while (!kthread_should_stop())
	288	schedule_timeout_uninterruptible(1);
	289	return 0;
	290	}
	291
	292	/*
	293	* Create an RCU-torture statistics message in the specified buffer.
	294	*/
	295	static int
	296	rcu_torture_printk(char *page)
	297	{
	298	int cnt = 0;
	299	int cpu;
	300	int i;
	301	long pipesummary[RCU_TORTURE_PIPE_LEN + 1] = { 0 };
	302	long batchsummary[RCU_TORTURE_PIPE_LEN + 1] = { 0 };
	303
	304	for_each_cpu(cpu) {
	305	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++) {
	306	pipesummary[i] += per_cpu(rcu_torture_count, cpu)[i];
	307	batchsummary[i] += per_cpu(rcu_torture_batch, cpu)[i];
	308	}
	309	}
	310	for (i = RCU_TORTURE_PIPE_LEN - 1; i >= 0; i--) {
	311	if (pipesummary[i] != 0)
	312	break;
	313	}
	314	cnt += sprintf(&page[cnt], "rcutorture: ");
	315	cnt += sprintf(&page[cnt],
996417d2 PM	316	"rtc: %p ver: %ld tfle: %d rta: %d rtaf: %d rtf: %d "
996417d2 PM	317	"rtmbe: %d",
a241ec65 PM	318	rcu_torture_current,
	319	rcu_torture_current_version,
	320	list_empty(&rcu_torture_freelist),
	321	atomic_read(&n_rcu_torture_alloc),
	322	atomic_read(&n_rcu_torture_alloc_fail),
996417d2 PM	323	atomic_read(&n_rcu_torture_free),
	324	atomic_read(&n_rcu_torture_mberror));
	325	if (atomic_read(&n_rcu_torture_mberror) != 0)
	326	cnt += sprintf(&page[cnt], " !!!");
a241ec65	327	cnt += sprintf(&page[cnt], "\nrcutorture: ");
996417d2	328	if (i > 1) {
a241ec65	329	cnt += sprintf(&page[cnt], "!!! ");
996417d2 PM	330	atomic_inc(&n_rcu_torture_error);
996417d2 PM	331	}
a241ec65 PM	332	cnt += sprintf(&page[cnt], "Reader Pipe: ");
	333	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++)
	334	cnt += sprintf(&page[cnt], " %ld", pipesummary[i]);
	335	cnt += sprintf(&page[cnt], "\nrcutorture: ");
	336	cnt += sprintf(&page[cnt], "Reader Batch: ");
	337	for (i = 0; i < RCU_TORTURE_PIPE_LEN; i++)
	338	cnt += sprintf(&page[cnt], " %ld", batchsummary[i]);
	339	cnt += sprintf(&page[cnt], "\nrcutorture: ");
	340	cnt += sprintf(&page[cnt], "Free-Block Circulation: ");
	341	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++) {
	342	cnt += sprintf(&page[cnt], " %d",
	343	atomic_read(&rcu_torture_wcount[i]));
	344	}
	345	cnt += sprintf(&page[cnt], "\n");
	346	return cnt;
	347	}
	348
	349	/*
	350	* Print torture statistics. Caller must ensure that there is only
	351	* one call to this function at a given time!!! This is normally
	352	* accomplished by relying on the module system to only have one copy
	353	* of the module loaded, and then by giving the rcu_torture_stats
	354	* kthread full control (or the init/cleanup functions when rcu_torture_stats
	355	* thread is not running).
	356	*/
	357	static void
	358	rcu_torture_stats_print(void)
	359	{
	360	int cnt;
	361
	362	cnt = rcu_torture_printk(printk_buf);
	363	printk(KERN_ALERT "%s", printk_buf);
	364	}
	365
	366	/*
	367	* Periodically prints torture statistics, if periodic statistics printing
	368	* was specified via the stat_interval module parameter.
	369	*
	370	* No need to worry about fullstop here, since this one doesn't reference
	371	* volatile state or register callbacks.
	372	*/
	373	static int
	374	rcu_torture_stats(void *arg)
	375	{
	376	VERBOSE_PRINTK_STRING("rcu_torture_stats task started");
	377	do {
	378	schedule_timeout_interruptible(stat_interval * HZ);
	379	rcu_torture_stats_print();
	380	} while (!kthread_should_stop());
	381	VERBOSE_PRINTK_STRING("rcu_torture_stats task stopping");
	382	return 0;
	383	}
	384
d84f5203 SV	385	static int rcu_idle_cpu; /* Force all torture tasks off this CPU */
	386
	387	/* Shuffle tasks such that we allow @rcu_idle_cpu to become idle. A special case
	388	* is when @rcu_idle_cpu = -1, when we allow the tasks to run on all CPUs.
	389	*/
	390	void rcu_torture_shuffle_tasks(void)
	391	{
	392	cpumask_t tmp_mask = CPU_MASK_ALL;
	393	int i;
	394
	395	lock_cpu_hotplug();
	396
	397	/* No point in shuffling if there is only one online CPU (ex: UP) */
	398	if (num_online_cpus() == 1) {
	399	unlock_cpu_hotplug();
	400	return;
	401	}
	402
	403	if (rcu_idle_cpu != -1)
	404	cpu_clear(rcu_idle_cpu, tmp_mask);
	405
	406	set_cpus_allowed(current, tmp_mask);
	407
	408	if (reader_tasks != NULL) {
	409	for (i = 0; i < nrealreaders; i++)
	410	if (reader_tasks[i])
	411	set_cpus_allowed(reader_tasks[i], tmp_mask);
	412	}
	413
	414	if (writer_task)
	415	set_cpus_allowed(writer_task, tmp_mask);
	416
	417	if (stats_task)
	418	set_cpus_allowed(stats_task, tmp_mask);
	419
	420	if (rcu_idle_cpu == -1)
	421	rcu_idle_cpu = num_online_cpus() - 1;
	422	else
	423	rcu_idle_cpu--;
	424
	425	unlock_cpu_hotplug();
	426	}
	427
	428	/* Shuffle tasks across CPUs, with the intent of allowing each CPU in the
	429	* system to become idle at a time and cut off its timer ticks. This is meant
	430	* to test the support for such tickless idle CPU in RCU.
	431	*/
	432	static int
	433	rcu_torture_shuffle(void *arg)
	434	{
	435	VERBOSE_PRINTK_STRING("rcu_torture_shuffle task started");
	436	do {
	437	schedule_timeout_interruptible(shuffle_interval * HZ);
	438	rcu_torture_shuffle_tasks();
	439	} while (!kthread_should_stop());
	440	VERBOSE_PRINTK_STRING("rcu_torture_shuffle task stopping");
	441	return 0;
	442	}
	443
a241ec65 PM	444	static void
	445	rcu_torture_cleanup(void)
	446	{
	447	int i;
	448
	449	fullstop = 1;
d84f5203 SV	450	if (shuffler_task != NULL) {
	451	VERBOSE_PRINTK_STRING("Stopping rcu_torture_shuffle task");
	452	kthread_stop(shuffler_task);
	453	}
	454	shuffler_task = NULL;
	455
a241ec65 PM	456	if (writer_task != NULL) {
	457	VERBOSE_PRINTK_STRING("Stopping rcu_torture_writer task");
	458	kthread_stop(writer_task);
	459	}
	460	writer_task = NULL;
	461
	462	if (reader_tasks != NULL) {
	463	for (i = 0; i < nrealreaders; i++) {
	464	if (reader_tasks[i] != NULL) {
	465	VERBOSE_PRINTK_STRING(
	466	"Stopping rcu_torture_reader task");
	467	kthread_stop(reader_tasks[i]);
	468	}
	469	reader_tasks[i] = NULL;
	470	}
	471	kfree(reader_tasks);
	472	reader_tasks = NULL;
	473	}
	474	rcu_torture_current = NULL;
	475
	476	if (stats_task != NULL) {
	477	VERBOSE_PRINTK_STRING("Stopping rcu_torture_stats task");
	478	kthread_stop(stats_task);
	479	}
	480	stats_task = NULL;
	481
	482	/* Wait for all RCU callbacks to fire. */
89d46b87	483	rcu_barrier();
a241ec65	484
a241ec65	485	rcu_torture_stats_print(); /* -After- the stats thread is stopped! */
996417d2 PM	486	printk(KERN_ALERT TORTURE_FLAG
	487	"--- End of test: %s\n",
	488	atomic_read(&n_rcu_torture_error) == 0 ? "SUCCESS" : "FAILURE");
a241ec65 PM	489	}
	490
	491	static int
	492	rcu_torture_init(void)
	493	{
	494	int i;
	495	int cpu;
	496	int firsterr = 0;
	497
	498	/* Process args and tell the world that the torturer is on the job. */
	499
	500	if (nreaders >= 0)
	501	nrealreaders = nreaders;
	502	else
	503	nrealreaders = 2 * num_online_cpus();
d84f5203 SV	504	printk(KERN_ALERT TORTURE_FLAG "--- Start of test: nreaders=%d "
	505	"stat_interval=%d verbose=%d test_no_idle_hz=%d "
	506	"shuffle_interval = %d\n",
	507	nrealreaders, stat_interval, verbose, test_no_idle_hz,
	508	shuffle_interval);
a241ec65 PM	509	fullstop = 0;
	510
	511	/* Set up the freelist. */
	512
	513	INIT_LIST_HEAD(&rcu_torture_freelist);
	514	for (i = 0; i < sizeof(rcu_tortures) / sizeof(rcu_tortures[0]); i++) {
996417d2	515	rcu_tortures[i].rtort_mbtest = 0;
a241ec65 PM	516	list_add_tail(&rcu_tortures[i].rtort_free,
	517	&rcu_torture_freelist);
	518	}
	519
	520	/* Initialize the statistics so that each run gets its own numbers. */
	521
	522	rcu_torture_current = NULL;
	523	rcu_torture_current_version = 0;
	524	atomic_set(&n_rcu_torture_alloc, 0);
	525	atomic_set(&n_rcu_torture_alloc_fail, 0);
	526	atomic_set(&n_rcu_torture_free, 0);
996417d2 PM	527	atomic_set(&n_rcu_torture_mberror, 0);
996417d2 PM	528	atomic_set(&n_rcu_torture_error, 0);
a241ec65 PM	529	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++)
	530	atomic_set(&rcu_torture_wcount[i], 0);
	531	for_each_cpu(cpu) {
	532	for (i = 0; i < RCU_TORTURE_PIPE_LEN + 1; i++) {
	533	per_cpu(rcu_torture_count, cpu)[i] = 0;
	534	per_cpu(rcu_torture_batch, cpu)[i] = 0;
	535	}
	536	}
	537
	538	/* Start up the kthreads. */
	539
	540	VERBOSE_PRINTK_STRING("Creating rcu_torture_writer task");
	541	writer_task = kthread_run(rcu_torture_writer, NULL,
	542	"rcu_torture_writer");
	543	if (IS_ERR(writer_task)) {
	544	firsterr = PTR_ERR(writer_task);
	545	VERBOSE_PRINTK_ERRSTRING("Failed to create writer");
	546	writer_task = NULL;
	547	goto unwind;
	548	}
	549	reader_tasks = kmalloc(nrealreaders * sizeof(reader_tasks[0]),
	550	GFP_KERNEL);
	551	if (reader_tasks == NULL) {
	552	VERBOSE_PRINTK_ERRSTRING("out of memory");
	553	firsterr = -ENOMEM;
	554	goto unwind;
	555	}
	556	for (i = 0; i < nrealreaders; i++) {
	557	VERBOSE_PRINTK_STRING("Creating rcu_torture_reader task");
	558	reader_tasks[i] = kthread_run(rcu_torture_reader, NULL,
	559	"rcu_torture_reader");
	560	if (IS_ERR(reader_tasks[i])) {
	561	firsterr = PTR_ERR(reader_tasks[i]);
	562	VERBOSE_PRINTK_ERRSTRING("Failed to create reader");
	563	reader_tasks[i] = NULL;
	564	goto unwind;
	565	}
	566	}
	567	if (stat_interval > 0) {
	568	VERBOSE_PRINTK_STRING("Creating rcu_torture_stats task");
	569	stats_task = kthread_run(rcu_torture_stats, NULL,
	570	"rcu_torture_stats");
	571	if (IS_ERR(stats_task)) {
	572	firsterr = PTR_ERR(stats_task);
	573	VERBOSE_PRINTK_ERRSTRING("Failed to create stats");
	574	stats_task = NULL;
	575	goto unwind;
	576	}
	577	}
d84f5203 SV	578	if (test_no_idle_hz) {
	579	rcu_idle_cpu = num_online_cpus() - 1;
	580	/* Create the shuffler thread */
	581	shuffler_task = kthread_run(rcu_torture_shuffle, NULL,
	582	"rcu_torture_shuffle");
	583	if (IS_ERR(shuffler_task)) {
	584	firsterr = PTR_ERR(shuffler_task);
	585	VERBOSE_PRINTK_ERRSTRING("Failed to create shuffler");
	586	shuffler_task = NULL;
	587	goto unwind;
	588	}
	589	}
a241ec65 PM	590	return 0;
	591
	592	unwind:
	593	rcu_torture_cleanup();
	594	return firsterr;
	595	}
	596
	597	module_init(rcu_torture_init);
	598	module_exit(rcu_torture_cleanup);