rhashtable: split rhashtable.h
[linux-block.git] / lib / test_rhashtable.c
CommitLineData
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>
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>
cdd4de37 26#include <linux/random.h>
f4a3e90b 27#include <linux/vmalloc.h>
9d6dbe1b 28
1aa661f5 29#define MAX_ENTRIES 1000000
67b7cbf4 30#define TEST_INSERT_FAIL INT_MAX
1aa661f5 31
f651616e
FW
32static int parm_entries = 50000;
33module_param(parm_entries, int, 0);
34MODULE_PARM_DESC(parm_entries, "Number of entries to add (default: 50000)");
1aa661f5
TG
35
36static int runs = 4;
37module_param(runs, int, 0);
38MODULE_PARM_DESC(runs, "Number of test runs per variant (default: 4)");
39
95e435af 40static int max_size = 0;
1aa661f5 41module_param(max_size, int, 0);
3b3bf80b 42MODULE_PARM_DESC(max_size, "Maximum table size (default: calculated)");
1aa661f5
TG
43
44static bool shrinking = false;
45module_param(shrinking, bool, 0);
46MODULE_PARM_DESC(shrinking, "Enable automatic shrinking (default: off)");
47
48static int size = 8;
49module_param(size, int, 0);
50MODULE_PARM_DESC(size, "Initial size hint of table (default: 8)");
9d6dbe1b 51
f4a3e90b
PS
52static int tcount = 10;
53module_param(tcount, int, 0);
54MODULE_PARM_DESC(tcount, "Number of threads to spawn (default: 10)");
55
d662e037
PS
56static bool enomem_retry = false;
57module_param(enomem_retry, bool, 0);
58MODULE_PARM_DESC(enomem_retry, "Retry insert even if -ENOMEM was returned (default: off)");
59
e859afe1
PS
60struct test_obj_val {
61 int id;
62 int tid;
63};
64
9d6dbe1b 65struct test_obj {
e859afe1 66 struct test_obj_val value;
9d6dbe1b
GU
67 struct rhash_head node;
68};
69
cdd4de37
FW
70struct test_obj_rhl {
71 struct test_obj_val value;
72 struct rhlist_head list_node;
73};
74
f4a3e90b 75struct thread_data {
f651616e 76 unsigned int entries;
f4a3e90b
PS
77 int id;
78 struct task_struct *task;
79 struct test_obj *objs;
80};
81
499ac3b6
PB
82static u32 my_hashfn(const void *data, u32 len, u32 seed)
83{
84 const struct test_obj_rhl *obj = data;
85
86 return (obj->value.id % 10) << RHT_HASH_RESERVED_SPACE;
87}
88
89static int my_cmpfn(struct rhashtable_compare_arg *arg, const void *obj)
90{
91 const struct test_obj_rhl *test_obj = obj;
92 const struct test_obj_val *val = arg->key;
93
94 return test_obj->value.id - val->id;
95}
96
1aa661f5 97static struct rhashtable_params test_rht_params = {
b182aa6e
HX
98 .head_offset = offsetof(struct test_obj, node),
99 .key_offset = offsetof(struct test_obj, value),
e859afe1 100 .key_len = sizeof(struct test_obj_val),
b182aa6e 101 .hashfn = jhash,
b182aa6e
HX
102 .nulls_base = (3U << RHT_BASE_SHIFT),
103};
104
499ac3b6
PB
105static struct rhashtable_params test_rht_params_dup = {
106 .head_offset = offsetof(struct test_obj_rhl, list_node),
107 .key_offset = offsetof(struct test_obj_rhl, value),
108 .key_len = sizeof(struct test_obj_val),
109 .hashfn = jhash,
110 .obj_hashfn = my_hashfn,
111 .obj_cmpfn = my_cmpfn,
112 .nelem_hint = 128,
113 .automatic_shrinking = false,
114};
115
f4a3e90b
PS
116static struct semaphore prestart_sem;
117static struct semaphore startup_sem = __SEMAPHORE_INITIALIZER(startup_sem, 0);
118
7e936bd7 119static int insert_retry(struct rhashtable *ht, struct test_obj *obj,
9e9089e5
PS
120 const struct rhashtable_params params)
121{
d662e037 122 int err, retries = -1, enomem_retries = 0;
9e9089e5
PS
123
124 do {
125 retries++;
126 cond_resched();
7e936bd7 127 err = rhashtable_insert_fast(ht, &obj->node, params);
d662e037
PS
128 if (err == -ENOMEM && enomem_retry) {
129 enomem_retries++;
130 err = -EBUSY;
131 }
9e9089e5
PS
132 } while (err == -EBUSY);
133
d662e037
PS
134 if (enomem_retries)
135 pr_info(" %u insertions retried after -ENOMEM\n",
136 enomem_retries);
137
9e9089e5
PS
138 return err ? : retries;
139}
140
f651616e
FW
141static int __init test_rht_lookup(struct rhashtable *ht, struct test_obj *array,
142 unsigned int entries)
9d6dbe1b
GU
143{
144 unsigned int i;
145
f651616e 146 for (i = 0; i < entries; i++) {
9d6dbe1b
GU
147 struct test_obj *obj;
148 bool expected = !(i % 2);
e859afe1
PS
149 struct test_obj_val key = {
150 .id = i,
151 };
9d6dbe1b 152
e859afe1 153 if (array[i / 2].value.id == TEST_INSERT_FAIL)
67b7cbf4
TG
154 expected = false;
155
b182aa6e 156 obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
9d6dbe1b
GU
157
158 if (expected && !obj) {
e859afe1 159 pr_warn("Test failed: Could not find key %u\n", key.id);
9d6dbe1b
GU
160 return -ENOENT;
161 } else if (!expected && obj) {
162 pr_warn("Test failed: Unexpected entry found for key %u\n",
e859afe1 163 key.id);
9d6dbe1b
GU
164 return -EEXIST;
165 } else if (expected && obj) {
e859afe1 166 if (obj->value.id != i) {
c2c8a901 167 pr_warn("Test failed: Lookup value mismatch %u!=%u\n",
e859afe1 168 obj->value.id, i);
9d6dbe1b
GU
169 return -EINVAL;
170 }
171 }
685a015e
TG
172
173 cond_resched_rcu();
9d6dbe1b
GU
174 }
175
176 return 0;
177}
178
f651616e 179static void test_bucket_stats(struct rhashtable *ht, unsigned int entries)
9d6dbe1b 180{
246b23a7
TG
181 unsigned int err, total = 0, chain_len = 0;
182 struct rhashtable_iter hti;
9d6dbe1b 183 struct rhash_head *pos;
9d6dbe1b 184
8f6fd83c 185 err = rhashtable_walk_init(ht, &hti, GFP_KERNEL);
246b23a7
TG
186 if (err) {
187 pr_warn("Test failed: allocation error");
188 return;
189 }
9d6dbe1b 190
97a6ec4a 191 rhashtable_walk_start(&hti);
9d6dbe1b 192
246b23a7
TG
193 while ((pos = rhashtable_walk_next(&hti))) {
194 if (PTR_ERR(pos) == -EAGAIN) {
195 pr_info("Info: encountered resize\n");
196 chain_len++;
197 continue;
198 } else if (IS_ERR(pos)) {
199 pr_warn("Test failed: rhashtable_walk_next() error: %ld\n",
200 PTR_ERR(pos));
201 break;
9d6dbe1b
GU
202 }
203
246b23a7 204 total++;
9d6dbe1b
GU
205 }
206
246b23a7
TG
207 rhashtable_walk_stop(&hti);
208 rhashtable_walk_exit(&hti);
209
210 pr_info(" Traversal complete: counted=%u, nelems=%u, entries=%d, table-jumps=%u\n",
211 total, atomic_read(&ht->nelems), entries, chain_len);
9d6dbe1b 212
1aa661f5 213 if (total != atomic_read(&ht->nelems) || total != entries)
9d6dbe1b
GU
214 pr_warn("Test failed: Total count mismatch ^^^");
215}
216
f651616e
FW
217static s64 __init test_rhashtable(struct rhashtable *ht, struct test_obj *array,
218 unsigned int entries)
9d6dbe1b 219{
9d6dbe1b 220 struct test_obj *obj;
9d6dbe1b 221 int err;
9e9089e5 222 unsigned int i, insert_retries = 0;
1aa661f5 223 s64 start, end;
9d6dbe1b
GU
224
225 /*
226 * Insertion Test:
1aa661f5 227 * Insert entries into table with all keys even numbers
9d6dbe1b 228 */
1aa661f5
TG
229 pr_info(" Adding %d keys\n", entries);
230 start = ktime_get_ns();
231 for (i = 0; i < entries; i++) {
fcc57020 232 struct test_obj *obj = &array[i];
9d6dbe1b 233
e859afe1 234 obj->value.id = i * 2;
7e936bd7 235 err = insert_retry(ht, obj, test_rht_params);
9e9089e5
PS
236 if (err > 0)
237 insert_retries += err;
238 else if (err)
fcc57020 239 return err;
9d6dbe1b
GU
240 }
241
9e9089e5
PS
242 if (insert_retries)
243 pr_info(" %u insertions retried due to memory pressure\n",
244 insert_retries);
67b7cbf4 245
f651616e 246 test_bucket_stats(ht, entries);
9d6dbe1b 247 rcu_read_lock();
f651616e 248 test_rht_lookup(ht, array, entries);
9d6dbe1b
GU
249 rcu_read_unlock();
250
f651616e 251 test_bucket_stats(ht, entries);
9d6dbe1b 252
1aa661f5
TG
253 pr_info(" Deleting %d keys\n", entries);
254 for (i = 0; i < entries; i++) {
78369255
PS
255 struct test_obj_val key = {
256 .id = i * 2,
257 };
9d6dbe1b 258
e859afe1 259 if (array[i].value.id != TEST_INSERT_FAIL) {
67b7cbf4
TG
260 obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
261 BUG_ON(!obj);
9d6dbe1b 262
67b7cbf4
TG
263 rhashtable_remove_fast(ht, &obj->node, test_rht_params);
264 }
685a015e
TG
265
266 cond_resched();
9d6dbe1b
GU
267 }
268
1aa661f5
TG
269 end = ktime_get_ns();
270 pr_info(" Duration of test: %lld ns\n", end - start);
271
272 return end - start;
9d6dbe1b
GU
273}
274
b7f5e5c7 275static struct rhashtable ht;
411d788a 276static struct rhltable rhlt;
cdd4de37
FW
277
278static int __init test_rhltable(unsigned int entries)
279{
280 struct test_obj_rhl *rhl_test_objects;
281 unsigned long *obj_in_table;
282 unsigned int i, j, k;
283 int ret, err;
284
285 if (entries == 0)
286 entries = 1;
287
fad953ce
KC
288 rhl_test_objects = vzalloc(array_size(entries,
289 sizeof(*rhl_test_objects)));
cdd4de37
FW
290 if (!rhl_test_objects)
291 return -ENOMEM;
292
293 ret = -ENOMEM;
fad953ce
KC
294 obj_in_table = vzalloc(array_size(sizeof(unsigned long),
295 BITS_TO_LONGS(entries)));
cdd4de37
FW
296 if (!obj_in_table)
297 goto out_free;
298
299 /* nulls_base not supported in rhlist interface */
300 test_rht_params.nulls_base = 0;
301 err = rhltable_init(&rhlt, &test_rht_params);
302 if (WARN_ON(err))
303 goto out_free;
304
305 k = prandom_u32();
306 ret = 0;
307 for (i = 0; i < entries; i++) {
308 rhl_test_objects[i].value.id = k;
309 err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,
310 test_rht_params);
311 if (WARN(err, "error %d on element %d\n", err, i))
312 break;
313 if (err == 0)
314 set_bit(i, obj_in_table);
315 }
316
317 if (err)
318 ret = err;
319
320 pr_info("test %d add/delete pairs into rhlist\n", entries);
321 for (i = 0; i < entries; i++) {
322 struct rhlist_head *h, *pos;
323 struct test_obj_rhl *obj;
324 struct test_obj_val key = {
325 .id = k,
326 };
327 bool found;
328
329 rcu_read_lock();
330 h = rhltable_lookup(&rhlt, &key, test_rht_params);
331 if (WARN(!h, "key not found during iteration %d of %d", i, entries)) {
332 rcu_read_unlock();
333 break;
334 }
335
336 if (i) {
337 j = i - 1;
338 rhl_for_each_entry_rcu(obj, pos, h, list_node) {
339 if (WARN(pos == &rhl_test_objects[j].list_node, "old element found, should be gone"))
340 break;
341 }
342 }
343
344 cond_resched_rcu();
345
346 found = false;
347
348 rhl_for_each_entry_rcu(obj, pos, h, list_node) {
349 if (pos == &rhl_test_objects[i].list_node) {
350 found = true;
351 break;
352 }
353 }
354
355 rcu_read_unlock();
356
357 if (WARN(!found, "element %d not found", i))
358 break;
359
360 err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
361 WARN(err, "rhltable_remove: err %d for iteration %d\n", err, i);
362 if (err == 0)
363 clear_bit(i, obj_in_table);
364 }
365
366 if (ret == 0 && err)
367 ret = err;
368
369 for (i = 0; i < entries; i++) {
370 WARN(test_bit(i, obj_in_table), "elem %d allegedly still present", i);
371
372 err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,
373 test_rht_params);
374 if (WARN(err, "error %d on element %d\n", err, i))
375 break;
376 if (err == 0)
377 set_bit(i, obj_in_table);
378 }
379
380 pr_info("test %d random rhlist add/delete operations\n", entries);
381 for (j = 0; j < entries; j++) {
382 u32 i = prandom_u32_max(entries);
383 u32 prand = prandom_u32();
384
385 cond_resched();
386
387 if (prand == 0)
388 prand = prandom_u32();
389
390 if (prand & 1) {
391 prand >>= 1;
392 continue;
393 }
394
395 err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
396 if (test_bit(i, obj_in_table)) {
397 clear_bit(i, obj_in_table);
398 if (WARN(err, "cannot remove element at slot %d", i))
399 continue;
400 } else {
401 if (WARN(err != -ENOENT, "removed non-existant element %d, error %d not %d",
402 i, err, -ENOENT))
403 continue;
404 }
405
406 if (prand & 1) {
407 prand >>= 1;
408 continue;
409 }
410
411 err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
412 if (err == 0) {
413 if (WARN(test_and_set_bit(i, obj_in_table), "succeeded to insert same object %d", i))
414 continue;
415 } else {
416 if (WARN(!test_bit(i, obj_in_table), "failed to insert object %d", i))
417 continue;
418 }
419
420 if (prand & 1) {
421 prand >>= 1;
422 continue;
423 }
424
425 i = prandom_u32_max(entries);
426 if (test_bit(i, obj_in_table)) {
427 err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
428 WARN(err, "cannot remove element at slot %d", i);
429 if (err == 0)
430 clear_bit(i, obj_in_table);
431 } else {
432 err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
433 WARN(err, "failed to insert object %d", i);
434 if (err == 0)
435 set_bit(i, obj_in_table);
436 }
437 }
438
439 for (i = 0; i < entries; i++) {
440 cond_resched();
441 err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
442 if (test_bit(i, obj_in_table)) {
443 if (WARN(err, "cannot remove element at slot %d", i))
444 continue;
445 } else {
446 if (WARN(err != -ENOENT, "removed non-existant element, error %d not %d",
447 err, -ENOENT))
448 continue;
449 }
450 }
451
452 rhltable_destroy(&rhlt);
453out_free:
454 vfree(rhl_test_objects);
455 vfree(obj_in_table);
456 return ret;
457}
b7f5e5c7 458
a6359bd8
FW
459static int __init test_rhashtable_max(struct test_obj *array,
460 unsigned int entries)
461{
462 unsigned int i, insert_retries = 0;
463 int err;
464
465 test_rht_params.max_size = roundup_pow_of_two(entries / 8);
466 err = rhashtable_init(&ht, &test_rht_params);
467 if (err)
468 return err;
469
470 for (i = 0; i < ht.max_elems; i++) {
471 struct test_obj *obj = &array[i];
472
473 obj->value.id = i * 2;
474 err = insert_retry(&ht, obj, test_rht_params);
475 if (err > 0)
476 insert_retries += err;
477 else if (err)
478 return err;
479 }
480
481 err = insert_retry(&ht, &array[ht.max_elems], test_rht_params);
482 if (err == -E2BIG) {
483 err = 0;
484 } else {
485 pr_info("insert element %u should have failed with %d, got %d\n",
486 ht.max_elems, -E2BIG, err);
487 if (err == 0)
488 err = -1;
489 }
490
491 rhashtable_destroy(&ht);
492
493 return err;
494}
495
499ac3b6
PB
496static unsigned int __init print_ht(struct rhltable *rhlt)
497{
498 struct rhashtable *ht;
499 const struct bucket_table *tbl;
500 char buff[512] = "";
501 unsigned int i, cnt = 0;
502
503 ht = &rhlt->ht;
cbab9012
N
504 /* Take the mutex to avoid RCU warning */
505 mutex_lock(&ht->mutex);
499ac3b6
PB
506 tbl = rht_dereference(ht->tbl, ht);
507 for (i = 0; i < tbl->size; i++) {
508 struct rhash_head *pos, *next;
509 struct test_obj_rhl *p;
510
511 pos = rht_dereference(tbl->buckets[i], ht);
512 next = !rht_is_a_nulls(pos) ? rht_dereference(pos->next, ht) : NULL;
513
514 if (!rht_is_a_nulls(pos)) {
515 sprintf(buff, "%s\nbucket[%d] -> ", buff, i);
516 }
517
518 while (!rht_is_a_nulls(pos)) {
519 struct rhlist_head *list = container_of(pos, struct rhlist_head, rhead);
520 sprintf(buff, "%s[[", buff);
521 do {
522 pos = &list->rhead;
523 list = rht_dereference(list->next, ht);
524 p = rht_obj(ht, pos);
525
526 sprintf(buff, "%s val %d (tid=%d)%s", buff, p->value.id, p->value.tid,
527 list? ", " : " ");
528 cnt++;
529 } while (list);
530
531 pos = next,
532 next = !rht_is_a_nulls(pos) ?
533 rht_dereference(pos->next, ht) : NULL;
534
535 sprintf(buff, "%s]]%s", buff, !rht_is_a_nulls(pos) ? " -> " : "");
536 }
537 }
538 printk(KERN_ERR "\n---- ht: ----%s\n-------------\n", buff);
cbab9012 539 mutex_unlock(&ht->mutex);
499ac3b6
PB
540
541 return cnt;
542}
543
544static int __init test_insert_dup(struct test_obj_rhl *rhl_test_objects,
545 int cnt, bool slow)
546{
547 struct rhltable rhlt;
548 unsigned int i, ret;
549 const char *key;
550 int err = 0;
551
552 err = rhltable_init(&rhlt, &test_rht_params_dup);
553 if (WARN_ON(err))
554 return err;
555
556 for (i = 0; i < cnt; i++) {
557 rhl_test_objects[i].value.tid = i;
558 key = rht_obj(&rhlt.ht, &rhl_test_objects[i].list_node.rhead);
559 key += test_rht_params_dup.key_offset;
560
561 if (slow) {
562 err = PTR_ERR(rhashtable_insert_slow(&rhlt.ht, key,
563 &rhl_test_objects[i].list_node.rhead));
564 if (err == -EAGAIN)
565 err = 0;
566 } else
567 err = rhltable_insert(&rhlt,
568 &rhl_test_objects[i].list_node,
569 test_rht_params_dup);
570 if (WARN(err, "error %d on element %d/%d (%s)\n", err, i, cnt, slow? "slow" : "fast"))
571 goto skip_print;
572 }
573
574 ret = print_ht(&rhlt);
575 WARN(ret != cnt, "missing rhltable elements (%d != %d, %s)\n", ret, cnt, slow? "slow" : "fast");
576
577skip_print:
578 rhltable_destroy(&rhlt);
579
580 return 0;
581}
582
583static int __init test_insert_duplicates_run(void)
584{
585 struct test_obj_rhl rhl_test_objects[3] = {};
586
587 pr_info("test inserting duplicates\n");
588
589 /* two different values that map to same bucket */
590 rhl_test_objects[0].value.id = 1;
591 rhl_test_objects[1].value.id = 21;
592
593 /* and another duplicate with same as [0] value
594 * which will be second on the bucket list */
595 rhl_test_objects[2].value.id = rhl_test_objects[0].value.id;
596
597 test_insert_dup(rhl_test_objects, 2, false);
598 test_insert_dup(rhl_test_objects, 3, false);
599 test_insert_dup(rhl_test_objects, 2, true);
600 test_insert_dup(rhl_test_objects, 3, true);
601
602 return 0;
603}
604
f4a3e90b
PS
605static int thread_lookup_test(struct thread_data *tdata)
606{
f651616e 607 unsigned int entries = tdata->entries;
f4a3e90b
PS
608 int i, err = 0;
609
610 for (i = 0; i < entries; i++) {
611 struct test_obj *obj;
e859afe1
PS
612 struct test_obj_val key = {
613 .id = i,
614 .tid = tdata->id,
615 };
f4a3e90b
PS
616
617 obj = rhashtable_lookup_fast(&ht, &key, test_rht_params);
e859afe1
PS
618 if (obj && (tdata->objs[i].value.id == TEST_INSERT_FAIL)) {
619 pr_err(" found unexpected object %d-%d\n", key.tid, key.id);
f4a3e90b 620 err++;
e859afe1
PS
621 } else if (!obj && (tdata->objs[i].value.id != TEST_INSERT_FAIL)) {
622 pr_err(" object %d-%d not found!\n", key.tid, key.id);
f4a3e90b 623 err++;
e859afe1
PS
624 } else if (obj && memcmp(&obj->value, &key, sizeof(key))) {
625 pr_err(" wrong object returned (got %d-%d, expected %d-%d)\n",
626 obj->value.tid, obj->value.id, key.tid, key.id);
f4a3e90b
PS
627 err++;
628 }
cd5b318d
PS
629
630 cond_resched();
f4a3e90b
PS
631 }
632 return err;
633}
634
635static int threadfunc(void *data)
636{
9e9089e5 637 int i, step, err = 0, insert_retries = 0;
f4a3e90b
PS
638 struct thread_data *tdata = data;
639
640 up(&prestart_sem);
641 if (down_interruptible(&startup_sem))
642 pr_err(" thread[%d]: down_interruptible failed\n", tdata->id);
643
f651616e 644 for (i = 0; i < tdata->entries; i++) {
e859afe1
PS
645 tdata->objs[i].value.id = i;
646 tdata->objs[i].value.tid = tdata->id;
7e936bd7 647 err = insert_retry(&ht, &tdata->objs[i], test_rht_params);
9e9089e5
PS
648 if (err > 0) {
649 insert_retries += err;
f4a3e90b
PS
650 } else if (err) {
651 pr_err(" thread[%d]: rhashtable_insert_fast failed\n",
652 tdata->id);
653 goto out;
654 }
655 }
9e9089e5
PS
656 if (insert_retries)
657 pr_info(" thread[%d]: %u insertions retried due to memory pressure\n",
658 tdata->id, insert_retries);
f4a3e90b
PS
659
660 err = thread_lookup_test(tdata);
661 if (err) {
662 pr_err(" thread[%d]: rhashtable_lookup_test failed\n",
663 tdata->id);
664 goto out;
665 }
666
667 for (step = 10; step > 0; step--) {
f651616e 668 for (i = 0; i < tdata->entries; i += step) {
e859afe1 669 if (tdata->objs[i].value.id == TEST_INSERT_FAIL)
f4a3e90b
PS
670 continue;
671 err = rhashtable_remove_fast(&ht, &tdata->objs[i].node,
672 test_rht_params);
673 if (err) {
674 pr_err(" thread[%d]: rhashtable_remove_fast failed\n",
675 tdata->id);
676 goto out;
677 }
e859afe1 678 tdata->objs[i].value.id = TEST_INSERT_FAIL;
cd5b318d
PS
679
680 cond_resched();
f4a3e90b
PS
681 }
682 err = thread_lookup_test(tdata);
683 if (err) {
684 pr_err(" thread[%d]: rhashtable_lookup_test (2) failed\n",
685 tdata->id);
686 goto out;
687 }
688 }
689out:
690 while (!kthread_should_stop()) {
691 set_current_state(TASK_INTERRUPTIBLE);
692 schedule();
693 }
694 return err;
695}
696
9d6dbe1b
GU
697static int __init test_rht_init(void)
698{
f651616e 699 unsigned int entries;
f4a3e90b 700 int i, err, started_threads = 0, failed_threads = 0;
1aa661f5 701 u64 total_time = 0;
f4a3e90b
PS
702 struct thread_data *tdata;
703 struct test_obj *objs;
9d6dbe1b 704
f651616e
FW
705 if (parm_entries < 0)
706 parm_entries = 1;
707
708 entries = min(parm_entries, MAX_ENTRIES);
9d6dbe1b 709
1aa661f5 710 test_rht_params.automatic_shrinking = shrinking;
95e435af 711 test_rht_params.max_size = max_size ? : roundup_pow_of_two(entries);
1aa661f5 712 test_rht_params.nelem_hint = size;
9d6dbe1b 713
fad953ce
KC
714 objs = vzalloc(array_size(sizeof(struct test_obj),
715 test_rht_params.max_size + 1));
7e936bd7
FW
716 if (!objs)
717 return -ENOMEM;
718
1aa661f5
TG
719 pr_info("Running rhashtable test nelem=%d, max_size=%d, shrinking=%d\n",
720 size, max_size, shrinking);
9d6dbe1b 721
1aa661f5
TG
722 for (i = 0; i < runs; i++) {
723 s64 time;
9d6dbe1b 724
1aa661f5 725 pr_info("Test %02d:\n", i);
7e936bd7
FW
726 memset(objs, 0, test_rht_params.max_size * sizeof(struct test_obj));
727
1aa661f5
TG
728 err = rhashtable_init(&ht, &test_rht_params);
729 if (err < 0) {
730 pr_warn("Test failed: Unable to initialize hashtable: %d\n",
731 err);
732 continue;
733 }
734
f651616e 735 time = test_rhashtable(&ht, objs, entries);
1aa661f5
TG
736 rhashtable_destroy(&ht);
737 if (time < 0) {
7e936bd7 738 vfree(objs);
1aa661f5
TG
739 pr_warn("Test failed: return code %lld\n", time);
740 return -EINVAL;
741 }
742
743 total_time += time;
744 }
745
a6359bd8
FW
746 pr_info("test if its possible to exceed max_size %d: %s\n",
747 test_rht_params.max_size, test_rhashtable_max(objs, entries) == 0 ?
748 "no, ok" : "YES, failed");
7e936bd7 749 vfree(objs);
a6359bd8 750
6decd63a
TG
751 do_div(total_time, runs);
752 pr_info("Average test time: %llu\n", total_time);
1aa661f5 753
499ac3b6
PB
754 test_insert_duplicates_run();
755
f4a3e90b
PS
756 if (!tcount)
757 return 0;
758
759 pr_info("Testing concurrent rhashtable access from %d threads\n",
760 tcount);
761 sema_init(&prestart_sem, 1 - tcount);
fad953ce 762 tdata = vzalloc(array_size(tcount, sizeof(struct thread_data)));
f4a3e90b
PS
763 if (!tdata)
764 return -ENOMEM;
fad953ce 765 objs = vzalloc(array3_size(sizeof(struct test_obj), tcount, entries));
f4a3e90b
PS
766 if (!objs) {
767 vfree(tdata);
768 return -ENOMEM;
769 }
770
95e435af
PS
771 test_rht_params.max_size = max_size ? :
772 roundup_pow_of_two(tcount * entries);
f4a3e90b
PS
773 err = rhashtable_init(&ht, &test_rht_params);
774 if (err < 0) {
775 pr_warn("Test failed: Unable to initialize hashtable: %d\n",
776 err);
777 vfree(tdata);
778 vfree(objs);
779 return -EINVAL;
780 }
781 for (i = 0; i < tcount; i++) {
782 tdata[i].id = i;
f651616e 783 tdata[i].entries = entries;
f4a3e90b
PS
784 tdata[i].objs = objs + i * entries;
785 tdata[i].task = kthread_run(threadfunc, &tdata[i],
786 "rhashtable_thrad[%d]", i);
787 if (IS_ERR(tdata[i].task))
788 pr_err(" kthread_run failed for thread %d\n", i);
789 else
790 started_threads++;
791 }
792 if (down_interruptible(&prestart_sem))
793 pr_err(" down interruptible failed\n");
794 for (i = 0; i < tcount; i++)
795 up(&startup_sem);
796 for (i = 0; i < tcount; i++) {
797 if (IS_ERR(tdata[i].task))
798 continue;
799 if ((err = kthread_stop(tdata[i].task))) {
800 pr_warn("Test failed: thread %d returned: %d\n",
801 i, err);
802 failed_threads++;
803 }
804 }
f4a3e90b
PS
805 rhashtable_destroy(&ht);
806 vfree(tdata);
807 vfree(objs);
cdd4de37
FW
808
809 /*
810 * rhltable_remove is very expensive, default values can cause test
811 * to run for 2 minutes or more, use a smaller number instead.
812 */
813 err = test_rhltable(entries / 16);
814 pr_info("Started %d threads, %d failed, rhltable test returns %d\n",
815 started_threads, failed_threads, err);
1aa661f5 816 return 0;
9d6dbe1b
GU
817}
818
6dd0c165
DB
819static void __exit test_rht_exit(void)
820{
821}
822
9d6dbe1b 823module_init(test_rht_init);
6dd0c165 824module_exit(test_rht_exit);
9d6dbe1b
GU
825
826MODULE_LICENSE("GPL v2");