[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / lib / test_rhashtable.c

/*
 * Resizable, Scalable, Concurrent Hash Table
 *
 * Copyright (c) 2014-2015 Thomas Graf <tgraf@suug.ch>
 * Copyright (c) 2008-2014 Patrick McHardy <kaber@trash.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/**************************************************************************
 * Self Test
 **************************************************************************/

#include <linux/init.h>
#include <linux/jhash.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/rcupdate.h>
#include <linux/rhashtable.h>
#include <linux/semaphore.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/vmalloc.h>

#define MAX_ENTRIES	1000000
#define TEST_INSERT_FAIL INT_MAX

static int entries = 50000;
module_param(entries, int, 0);
MODULE_PARM_DESC(entries, "Number of entries to add (default: 50000)");

static int runs = 4;
module_param(runs, int, 0);
MODULE_PARM_DESC(runs, "Number of test runs per variant (default: 4)");

static int max_size = 65536;
module_param(max_size, int, 0);
MODULE_PARM_DESC(runs, "Maximum table size (default: 65536)");

static bool shrinking = false;
module_param(shrinking, bool, 0);
MODULE_PARM_DESC(shrinking, "Enable automatic shrinking (default: off)");

static int size = 8;
module_param(size, int, 0);
MODULE_PARM_DESC(size, "Initial size hint of table (default: 8)");

static int tcount = 10;
module_param(tcount, int, 0);
MODULE_PARM_DESC(tcount, "Number of threads to spawn (default: 10)");

struct test_obj {
	int			value;
	struct rhash_head	node;
};

struct thread_data {
	int id;
	struct task_struct *task;
	struct test_obj *objs;
};

static struct test_obj array[MAX_ENTRIES];

static struct rhashtable_params test_rht_params = {
	.head_offset = offsetof(struct test_obj, node),
	.key_offset = offsetof(struct test_obj, value),
	.key_len = sizeof(int),
	.hashfn = jhash,
	.nulls_base = (3U << RHT_BASE_SHIFT),
};

static struct semaphore prestart_sem;
static struct semaphore startup_sem = __SEMAPHORE_INITIALIZER(startup_sem, 0);

static int __init test_rht_lookup(struct rhashtable *ht)
{
	unsigned int i;

	for (i = 0; i < entries * 2; i++) {
		struct test_obj *obj;
		bool expected = !(i % 2);
		u32 key = i;

		if (array[i / 2].value == TEST_INSERT_FAIL)
			expected = false;

		obj = rhashtable_lookup_fast(ht, &key, test_rht_params);

		if (expected && !obj) {
			pr_warn("Test failed: Could not find key %u\n", key);
			return -ENOENT;
		} else if (!expected && obj) {
			pr_warn("Test failed: Unexpected entry found for key %u\n",
				key);
			return -EEXIST;
		} else if (expected && obj) {
			if (obj->value != i) {
				pr_warn("Test failed: Lookup value mismatch %u!=%u\n",
					obj->value, i);
				return -EINVAL;
			}
		}

		cond_resched_rcu();
	}

	return 0;
}

static void test_bucket_stats(struct rhashtable *ht)
{
	unsigned int err, total = 0, chain_len = 0;
	struct rhashtable_iter hti;
	struct rhash_head *pos;

	err = rhashtable_walk_init(ht, &hti);
	if (err) {
		pr_warn("Test failed: allocation error");
		return;
	}

	err = rhashtable_walk_start(&hti);
	if (err && err != -EAGAIN) {
		pr_warn("Test failed: iterator failed: %d\n", err);
		return;
	}

	while ((pos = rhashtable_walk_next(&hti))) {
		if (PTR_ERR(pos) == -EAGAIN) {
			pr_info("Info: encountered resize\n");
			chain_len++;
			continue;
		} else if (IS_ERR(pos)) {
			pr_warn("Test failed: rhashtable_walk_next() error: %ld\n",
				PTR_ERR(pos));
			break;
		}

		total++;
	}

	rhashtable_walk_stop(&hti);
	rhashtable_walk_exit(&hti);

	pr_info("  Traversal complete: counted=%u, nelems=%u, entries=%d, table-jumps=%u\n",
		total, atomic_read(&ht->nelems), entries, chain_len);

	if (total != atomic_read(&ht->nelems) || total != entries)
		pr_warn("Test failed: Total count mismatch ^^^");
}

static s64 __init test_rhashtable(struct rhashtable *ht)
{
	struct test_obj *obj;
	int err;
	unsigned int i, insert_fails = 0;
	s64 start, end;

	/*
	 * Insertion Test:
	 * Insert entries into table with all keys even numbers
	 */
	pr_info("  Adding %d keys\n", entries);
	start = ktime_get_ns();
	for (i = 0; i < entries; i++) {
		struct test_obj *obj = &array[i];

		obj->value = i * 2;

		err = rhashtable_insert_fast(ht, &obj->node, test_rht_params);
		if (err == -ENOMEM || err == -EBUSY) {
			/* Mark failed inserts but continue */
			obj->value = TEST_INSERT_FAIL;
			insert_fails++;
		} else if (err) {
			return err;
		}

		cond_resched();
	}

	if (insert_fails)
		pr_info("  %u insertions failed due to memory pressure\n",
			insert_fails);

	test_bucket_stats(ht);
	rcu_read_lock();
	test_rht_lookup(ht);
	rcu_read_unlock();

	test_bucket_stats(ht);

	pr_info("  Deleting %d keys\n", entries);
	for (i = 0; i < entries; i++) {
		u32 key = i * 2;

		if (array[i].value != TEST_INSERT_FAIL) {
			obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
			BUG_ON(!obj);

			rhashtable_remove_fast(ht, &obj->node, test_rht_params);
		}

		cond_resched();
	}

	end = ktime_get_ns();
	pr_info("  Duration of test: %lld ns\n", end - start);

	return end - start;
}

static struct rhashtable ht;

static int thread_lookup_test(struct thread_data *tdata)
{
	int i, err = 0;

	for (i = 0; i < entries; i++) {
		struct test_obj *obj;
		int key = (tdata->id << 16) | i;

		obj = rhashtable_lookup_fast(&ht, &key, test_rht_params);
		if (obj && (tdata->objs[i].value == TEST_INSERT_FAIL)) {
			pr_err("  found unexpected object %d\n", key);
			err++;
		} else if (!obj && (tdata->objs[i].value != TEST_INSERT_FAIL)) {
			pr_err("  object %d not found!\n", key);
			err++;
		} else if (obj && (obj->value != key)) {
			pr_err("  wrong object returned (got %d, expected %d)\n",
			       obj->value, key);
			err++;
		}
	}
	return err;
}

static int threadfunc(void *data)
{
	int i, step, err = 0, insert_fails = 0;
	struct thread_data *tdata = data;

	up(&prestart_sem);
	if (down_interruptible(&startup_sem))
		pr_err("  thread[%d]: down_interruptible failed\n", tdata->id);

	for (i = 0; i < entries; i++) {
		tdata->objs[i].value = (tdata->id << 16) | i;
		err = rhashtable_insert_fast(&ht, &tdata->objs[i].node,
		                             test_rht_params);
		if (err == -ENOMEM || err == -EBUSY) {
			tdata->objs[i].value = TEST_INSERT_FAIL;
			insert_fails++;
		} else if (err) {
			pr_err("  thread[%d]: rhashtable_insert_fast failed\n",
			       tdata->id);
			goto out;
		}
	}
	if (insert_fails)
		pr_info("  thread[%d]: %d insert failures\n",
		        tdata->id, insert_fails);

	err = thread_lookup_test(tdata);
	if (err) {
		pr_err("  thread[%d]: rhashtable_lookup_test failed\n",
		       tdata->id);
		goto out;
	}

	for (step = 10; step > 0; step--) {
		for (i = 0; i < entries; i += step) {
			if (tdata->objs[i].value == TEST_INSERT_FAIL)
				continue;
			err = rhashtable_remove_fast(&ht, &tdata->objs[i].node,
			                             test_rht_params);
			if (err) {
				pr_err("  thread[%d]: rhashtable_remove_fast failed\n",
				       tdata->id);
				goto out;
			}
			tdata->objs[i].value = TEST_INSERT_FAIL;
		}
		err = thread_lookup_test(tdata);
		if (err) {
			pr_err("  thread[%d]: rhashtable_lookup_test (2) failed\n",
			       tdata->id);
			goto out;
		}
	}
out:
	while (!kthread_should_stop()) {
		set_current_state(TASK_INTERRUPTIBLE);
		schedule();
	}
	return err;
}

static int __init test_rht_init(void)
{
	int i, err, started_threads = 0, failed_threads = 0;
	u64 total_time = 0;
	struct thread_data *tdata;
	struct test_obj *objs;

	entries = min(entries, MAX_ENTRIES);

	test_rht_params.automatic_shrinking = shrinking;
	test_rht_params.max_size = max_size;
	test_rht_params.nelem_hint = size;

	pr_info("Running rhashtable test nelem=%d, max_size=%d, shrinking=%d\n",
		size, max_size, shrinking);

	for (i = 0; i < runs; i++) {
		s64 time;

		pr_info("Test %02d:\n", i);
		memset(&array, 0, sizeof(array));
		err = rhashtable_init(&ht, &test_rht_params);
		if (err < 0) {
			pr_warn("Test failed: Unable to initialize hashtable: %d\n",
				err);
			continue;
		}

		time = test_rhashtable(&ht);
		rhashtable_destroy(&ht);
		if (time < 0) {
			pr_warn("Test failed: return code %lld\n", time);
			return -EINVAL;
		}

		total_time += time;
	}

	do_div(total_time, runs);
	pr_info("Average test time: %llu\n", total_time);

	if (!tcount)
		return 0;

	pr_info("Testing concurrent rhashtable access from %d threads\n",
	        tcount);
	sema_init(&prestart_sem, 1 - tcount);
	tdata = vzalloc(tcount * sizeof(struct thread_data));
	if (!tdata)
		return -ENOMEM;
	objs  = vzalloc(tcount * entries * sizeof(struct test_obj));
	if (!objs) {
		vfree(tdata);
		return -ENOMEM;
	}

	err = rhashtable_init(&ht, &test_rht_params);
	if (err < 0) {
		pr_warn("Test failed: Unable to initialize hashtable: %d\n",
			err);
		vfree(tdata);
		vfree(objs);
		return -EINVAL;
	}
	for (i = 0; i < tcount; i++) {
		tdata[i].id = i;
		tdata[i].objs = objs + i * entries;
		tdata[i].task = kthread_run(threadfunc, &tdata[i],
		                            "rhashtable_thrad[%d]", i);
		if (IS_ERR(tdata[i].task))
			pr_err(" kthread_run failed for thread %d\n", i);
		else
			started_threads++;
	}
	if (down_interruptible(&prestart_sem))
		pr_err("  down interruptible failed\n");
	for (i = 0; i < tcount; i++)
		up(&startup_sem);
	for (i = 0; i < tcount; i++) {
		if (IS_ERR(tdata[i].task))
			continue;
		if ((err = kthread_stop(tdata[i].task))) {
			pr_warn("Test failed: thread %d returned: %d\n",
			        i, err);
			failed_threads++;
		}
	}
	pr_info("Started %d threads, %d failed\n",
	        started_threads, failed_threads);
	rhashtable_destroy(&ht);
	vfree(tdata);
	vfree(objs);
	return 0;
}

static void __exit test_rht_exit(void)
{
}

module_init(test_rht_init);
module_exit(test_rht_exit);

MODULE_LICENSE("GPL v2");
Commit	Line	Data
9d6dbe1b GU	1	/*
	2	* Resizable, Scalable, Concurrent Hash Table
	3	*
1aa661f5	4	* Copyright (c) 2014-2015 Thomas Graf <tgraf@suug.ch>
9d6dbe1b GU	5	* Copyright (c) 2008-2014 Patrick McHardy <kaber@trash.net>
9d6dbe1b GU	6	*
9d6dbe1b GU	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	/**************************************************************************
	13	* Self Test
	14	**************************************************************************/
	15
	16	#include <linux/init.h>
	17	#include <linux/jhash.h>
	18	#include <linux/kernel.h>
f4a3e90b	19	#include <linux/kthread.h>
9d6dbe1b GU	20	#include <linux/module.h>
	21	#include <linux/rcupdate.h>
	22	#include <linux/rhashtable.h>
f4a3e90b	23	#include <linux/semaphore.h>
9d6dbe1b	24	#include <linux/slab.h>
685a015e	25	#include <linux/sched.h>
f4a3e90b	26	#include <linux/vmalloc.h>
9d6dbe1b	27
1aa661f5	28	#define MAX_ENTRIES 1000000
67b7cbf4	29	#define TEST_INSERT_FAIL INT_MAX
1aa661f5 TG	30
	31	static int entries = 50000;
	32	module_param(entries, int, 0);
	33	MODULE_PARM_DESC(entries, "Number of entries to add (default: 50000)");
	34
	35	static int runs = 4;
	36	module_param(runs, int, 0);
	37	MODULE_PARM_DESC(runs, "Number of test runs per variant (default: 4)");
	38
	39	static int max_size = 65536;
	40	module_param(max_size, int, 0);
	41	MODULE_PARM_DESC(runs, "Maximum table size (default: 65536)");
	42
	43	static bool shrinking = false;
	44	module_param(shrinking, bool, 0);
	45	MODULE_PARM_DESC(shrinking, "Enable automatic shrinking (default: off)");
	46
	47	static int size = 8;
	48	module_param(size, int, 0);
	49	MODULE_PARM_DESC(size, "Initial size hint of table (default: 8)");
9d6dbe1b	50
f4a3e90b PS	51	static int tcount = 10;
	52	module_param(tcount, int, 0);
	53	MODULE_PARM_DESC(tcount, "Number of threads to spawn (default: 10)");
	54
9d6dbe1b	55	struct test_obj {
9d6dbe1b GU	56	int value;
	57	struct rhash_head node;
	58	};
	59
f4a3e90b PS	60	struct thread_data {
	61	int id;
	62	struct task_struct *task;
	63	struct test_obj *objs;
	64	};
	65
fcc57020 TG	66	static struct test_obj array[MAX_ENTRIES];
fcc57020 TG	67
1aa661f5	68	static struct rhashtable_params test_rht_params = {
b182aa6e HX	69	.head_offset = offsetof(struct test_obj, node),
	70	.key_offset = offsetof(struct test_obj, value),
	71	.key_len = sizeof(int),
	72	.hashfn = jhash,
b182aa6e HX	73	.nulls_base = (3U << RHT_BASE_SHIFT),
	74	};
	75
f4a3e90b PS	76	static struct semaphore prestart_sem;
	77	static struct semaphore startup_sem = __SEMAPHORE_INITIALIZER(startup_sem, 0);
	78
9d6dbe1b GU	79	static int __init test_rht_lookup(struct rhashtable *ht)
	80	{
	81	unsigned int i;
	82
1aa661f5	83	for (i = 0; i < entries * 2; i++) {
9d6dbe1b GU	84	struct test_obj *obj;
	85	bool expected = !(i % 2);
	86	u32 key = i;
	87
67b7cbf4 TG	88	if (array[i / 2].value == TEST_INSERT_FAIL)
	89	expected = false;
	90
b182aa6e	91	obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
9d6dbe1b GU	92
	93	if (expected && !obj) {
	94	pr_warn("Test failed: Could not find key %u\n", key);
	95	return -ENOENT;
	96	} else if (!expected && obj) {
	97	pr_warn("Test failed: Unexpected entry found for key %u\n",
	98	key);
	99	return -EEXIST;
	100	} else if (expected && obj) {
c2c8a901 TG	101	if (obj->value != i) {
	102	pr_warn("Test failed: Lookup value mismatch %u!=%u\n",
	103	obj->value, i);
9d6dbe1b GU	104	return -EINVAL;
	105	}
	106	}
685a015e TG	107
685a015e TG	108	cond_resched_rcu();
9d6dbe1b GU	109	}
	110
	111	return 0;
	112	}
	113
246b23a7	114	static void test_bucket_stats(struct rhashtable *ht)
9d6dbe1b	115	{
246b23a7 TG	116	unsigned int err, total = 0, chain_len = 0;
246b23a7 TG	117	struct rhashtable_iter hti;
9d6dbe1b	118	struct rhash_head *pos;
9d6dbe1b	119
246b23a7 TG	120	err = rhashtable_walk_init(ht, &hti);
	121	if (err) {
	122	pr_warn("Test failed: allocation error");
	123	return;
	124	}
9d6dbe1b	125
246b23a7 TG	126	err = rhashtable_walk_start(&hti);
	127	if (err && err != -EAGAIN) {
	128	pr_warn("Test failed: iterator failed: %d\n", err);
	129	return;
	130	}
9d6dbe1b	131
246b23a7 TG	132	while ((pos = rhashtable_walk_next(&hti))) {
	133	if (PTR_ERR(pos) == -EAGAIN) {
	134	pr_info("Info: encountered resize\n");
	135	chain_len++;
	136	continue;
	137	} else if (IS_ERR(pos)) {
	138	pr_warn("Test failed: rhashtable_walk_next() error: %ld\n",
	139	PTR_ERR(pos));
	140	break;
9d6dbe1b GU	141	}
9d6dbe1b GU	142
246b23a7	143	total++;
9d6dbe1b GU	144	}
9d6dbe1b GU	145
246b23a7 TG	146	rhashtable_walk_stop(&hti);
	147	rhashtable_walk_exit(&hti);
	148
	149	pr_info(" Traversal complete: counted=%u, nelems=%u, entries=%d, table-jumps=%u\n",
	150	total, atomic_read(&ht->nelems), entries, chain_len);
9d6dbe1b	151
1aa661f5	152	if (total != atomic_read(&ht->nelems) \|\| total != entries)
9d6dbe1b GU	153	pr_warn("Test failed: Total count mismatch ^^^");
	154	}
	155
1aa661f5	156	static s64 __init test_rhashtable(struct rhashtable *ht)
9d6dbe1b	157	{
9d6dbe1b	158	struct test_obj *obj;
9d6dbe1b	159	int err;
67b7cbf4	160	unsigned int i, insert_fails = 0;
1aa661f5	161	s64 start, end;
9d6dbe1b GU	162
	163	/*
	164	* Insertion Test:
1aa661f5	165	* Insert entries into table with all keys even numbers
9d6dbe1b	166	*/
1aa661f5 TG	167	pr_info(" Adding %d keys\n", entries);
	168	start = ktime_get_ns();
	169	for (i = 0; i < entries; i++) {
fcc57020	170	struct test_obj *obj = &array[i];
9d6dbe1b	171
9d6dbe1b GU	172	obj->value = i * 2;
9d6dbe1b GU	173
b182aa6e	174	err = rhashtable_insert_fast(ht, &obj->node, test_rht_params);
67b7cbf4 TG	175	if (err == -ENOMEM \|\| err == -EBUSY) {
	176	/* Mark failed inserts but continue */
	177	obj->value = TEST_INSERT_FAIL;
	178	insert_fails++;
	179	} else if (err) {
fcc57020	180	return err;
67b7cbf4	181	}
685a015e TG	182
685a015e TG	183	cond_resched();
9d6dbe1b GU	184	}
9d6dbe1b GU	185
67b7cbf4 TG	186	if (insert_fails)
	187	pr_info(" %u insertions failed due to memory pressure\n",
	188	insert_fails);
	189
246b23a7	190	test_bucket_stats(ht);
9d6dbe1b	191	rcu_read_lock();
9d6dbe1b GU	192	test_rht_lookup(ht);
	193	rcu_read_unlock();
	194
246b23a7	195	test_bucket_stats(ht);
9d6dbe1b	196
1aa661f5 TG	197	pr_info(" Deleting %d keys\n", entries);
1aa661f5 TG	198	for (i = 0; i < entries; i++) {
9d6dbe1b GU	199	u32 key = i * 2;
9d6dbe1b GU	200
67b7cbf4 TG	201	if (array[i].value != TEST_INSERT_FAIL) {
	202	obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
	203	BUG_ON(!obj);
9d6dbe1b	204
67b7cbf4 TG	205	rhashtable_remove_fast(ht, &obj->node, test_rht_params);
67b7cbf4 TG	206	}
685a015e TG	207
685a015e TG	208	cond_resched();
9d6dbe1b GU	209	}
9d6dbe1b GU	210
1aa661f5 TG	211	end = ktime_get_ns();
	212	pr_info(" Duration of test: %lld ns\n", end - start);
	213
	214	return end - start;
9d6dbe1b GU	215	}
9d6dbe1b GU	216
b7f5e5c7 DB	217	static struct rhashtable ht;
b7f5e5c7 DB	218
f4a3e90b PS	219	static int thread_lookup_test(struct thread_data *tdata)
	220	{
	221	int i, err = 0;
	222
	223	for (i = 0; i < entries; i++) {
	224	struct test_obj *obj;
	225	int key = (tdata->id << 16) \| i;
	226
	227	obj = rhashtable_lookup_fast(&ht, &key, test_rht_params);
	228	if (obj && (tdata->objs[i].value == TEST_INSERT_FAIL)) {
	229	pr_err(" found unexpected object %d\n", key);
	230	err++;
	231	} else if (!obj && (tdata->objs[i].value != TEST_INSERT_FAIL)) {
	232	pr_err(" object %d not found!\n", key);
	233	err++;
	234	} else if (obj && (obj->value != key)) {
	235	pr_err(" wrong object returned (got %d, expected %d)\n",
	236	obj->value, key);
	237	err++;
	238	}
	239	}
	240	return err;
	241	}
	242
	243	static int threadfunc(void *data)
	244	{
	245	int i, step, err = 0, insert_fails = 0;
	246	struct thread_data *tdata = data;
	247
	248	up(&prestart_sem);
	249	if (down_interruptible(&startup_sem))
	250	pr_err(" thread[%d]: down_interruptible failed\n", tdata->id);
	251
	252	for (i = 0; i < entries; i++) {
	253	tdata->objs[i].value = (tdata->id << 16) \| i;
	254	err = rhashtable_insert_fast(&ht, &tdata->objs[i].node,
	255	test_rht_params);
	256	if (err == -ENOMEM \|\| err == -EBUSY) {
	257	tdata->objs[i].value = TEST_INSERT_FAIL;
	258	insert_fails++;
	259	} else if (err) {
	260	pr_err(" thread[%d]: rhashtable_insert_fast failed\n",
	261	tdata->id);
	262	goto out;
	263	}
	264	}
	265	if (insert_fails)
	266	pr_info(" thread[%d]: %d insert failures\n",
	267	tdata->id, insert_fails);
	268
	269	err = thread_lookup_test(tdata);
	270	if (err) {
	271	pr_err(" thread[%d]: rhashtable_lookup_test failed\n",
	272	tdata->id);
	273	goto out;
	274	}
	275
	276	for (step = 10; step > 0; step--) {
	277	for (i = 0; i < entries; i += step) {
	278	if (tdata->objs[i].value == TEST_INSERT_FAIL)
	279	continue;
	280	err = rhashtable_remove_fast(&ht, &tdata->objs[i].node,
	281	test_rht_params);
	282	if (err) {
283	pr_err(" thread[%d]: rhashtable_remove_fast failed\n",
284	tdata->id);
285	goto out;
286	}
287	tdata->objs[i].value = TEST_INSERT_FAIL;
288	}
289	err = thread_lookup_test(tdata);
290	if (err) {
291	pr_err(" thread[%d]: rhashtable_lookup_test (2) failed\n",
292	tdata->id);
293	goto out;
294	}
295	}
296	out:
297	while (!kthread_should_stop()) {
298	set_current_state(TASK_INTERRUPTIBLE);
299	schedule();
300	}
301	return err;
302	}
303
9d6dbe1b GU	304	static int __init test_rht_init(void)
9d6dbe1b GU	305	{
f4a3e90b	306	int i, err, started_threads = 0, failed_threads = 0;
1aa661f5	307	u64 total_time = 0;
f4a3e90b PS	308	struct thread_data *tdata;
f4a3e90b PS	309	struct test_obj *objs;
9d6dbe1b	310
1aa661f5	311	entries = min(entries, MAX_ENTRIES);
9d6dbe1b	312
1aa661f5 TG	313	test_rht_params.automatic_shrinking = shrinking;
	314	test_rht_params.max_size = max_size;
	315	test_rht_params.nelem_hint = size;
9d6dbe1b	316
1aa661f5 TG	317	pr_info("Running rhashtable test nelem=%d, max_size=%d, shrinking=%d\n",
1aa661f5 TG	318	size, max_size, shrinking);
9d6dbe1b	319
1aa661f5 TG	320	for (i = 0; i < runs; i++) {
1aa661f5 TG	321	s64 time;
9d6dbe1b	322
1aa661f5	323	pr_info("Test %02d:\n", i);
fcc57020	324	memset(&array, 0, sizeof(array));
1aa661f5 TG	325	err = rhashtable_init(&ht, &test_rht_params);
	326	if (err < 0) {
	327	pr_warn("Test failed: Unable to initialize hashtable: %d\n",
	328	err);
	329	continue;
	330	}
	331
	332	time = test_rhashtable(&ht);
	333	rhashtable_destroy(&ht);
	334	if (time < 0) {
	335	pr_warn("Test failed: return code %lld\n", time);
	336	return -EINVAL;
	337	}
	338
	339	total_time += time;
	340	}
	341
6decd63a TG	342	do_div(total_time, runs);
6decd63a TG	343	pr_info("Average test time: %llu\n", total_time);
1aa661f5	344
f4a3e90b PS	345	if (!tcount)
	346	return 0;
	347
	348	pr_info("Testing concurrent rhashtable access from %d threads\n",
	349	tcount);
	350	sema_init(&prestart_sem, 1 - tcount);
	351	tdata = vzalloc(tcount * sizeof(struct thread_data));
	352	if (!tdata)
	353	return -ENOMEM;
	354	objs = vzalloc(tcount * entries * sizeof(struct test_obj));
	355	if (!objs) {
	356	vfree(tdata);
	357	return -ENOMEM;
	358	}
	359
	360	err = rhashtable_init(&ht, &test_rht_params);
	361	if (err < 0) {
	362	pr_warn("Test failed: Unable to initialize hashtable: %d\n",
	363	err);
	364	vfree(tdata);
	365	vfree(objs);
	366	return -EINVAL;
	367	}
	368	for (i = 0; i < tcount; i++) {
	369	tdata[i].id = i;
	370	tdata[i].objs = objs + i * entries;
	371	tdata[i].task = kthread_run(threadfunc, &tdata[i],
	372	"rhashtable_thrad[%d]", i);
	373	if (IS_ERR(tdata[i].task))
	374	pr_err(" kthread_run failed for thread %d\n", i);
	375	else
	376	started_threads++;
	377	}
	378	if (down_interruptible(&prestart_sem))
	379	pr_err(" down interruptible failed\n");
	380	for (i = 0; i < tcount; i++)
	381	up(&startup_sem);
	382	for (i = 0; i < tcount; i++) {
	383	if (IS_ERR(tdata[i].task))
	384	continue;
	385	if ((err = kthread_stop(tdata[i].task))) {
	386	pr_warn("Test failed: thread %d returned: %d\n",
	387	i, err);
	388	failed_threads++;
	389	}
	390	}
	391	pr_info("Started %d threads, %d failed\n",
	392	started_threads, failed_threads);
	393	rhashtable_destroy(&ht);
	394	vfree(tdata);
	395	vfree(objs);
1aa661f5	396	return 0;
9d6dbe1b GU	397	}
9d6dbe1b GU	398
6dd0c165 DB	399	static void __exit test_rht_exit(void)
	400	{
	401	}
	402
9d6dbe1b	403	module_init(test_rht_init);
6dd0c165	404	module_exit(test_rht_exit);
9d6dbe1b GU	405
9d6dbe1b GU	406	MODULE_LICENSE("GPL v2");