1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Read-Copy Update module-based scalability-test facility 4 * 5 * Copyright (C) IBM Corporation, 2015 6 * 7 * Authors: Paul E. McKenney <paulmck@linux.ibm.com> 8 */ 9 10 #define pr_fmt(fmt) fmt 11 12 #include <linux/types.h> 13 #include <linux/kernel.h> 14 #include <linux/init.h> 15 #include <linux/mm.h> 16 #include <linux/module.h> 17 #include <linux/kthread.h> 18 #include <linux/err.h> 19 #include <linux/spinlock.h> 20 #include <linux/smp.h> 21 #include <linux/rcupdate.h> 22 #include <linux/interrupt.h> 23 #include <linux/sched.h> 24 #include <uapi/linux/sched/types.h> 25 #include <linux/atomic.h> 26 #include <linux/bitops.h> 27 #include <linux/completion.h> 28 #include <linux/moduleparam.h> 29 #include <linux/percpu.h> 30 #include <linux/notifier.h> 31 #include <linux/reboot.h> 32 #include <linux/freezer.h> 33 #include <linux/cpu.h> 34 #include <linux/delay.h> 35 #include <linux/stat.h> 36 #include <linux/srcu.h> 37 #include <linux/slab.h> 38 #include <asm/byteorder.h> 39 #include <linux/torture.h> 40 #include <linux/vmalloc.h> 41 #include <linux/rcupdate_trace.h> 42 43 #include "rcu.h" 44 45 MODULE_LICENSE("GPL"); 46 MODULE_AUTHOR("Paul E. McKenney <paulmck@linux.ibm.com>"); 47 48 #define SCALE_FLAG "-scale:" 49 #define SCALEOUT_STRING(s) \ 50 pr_alert("%s" SCALE_FLAG " %s\n", scale_type, s) 51 #define VERBOSE_SCALEOUT_STRING(s) \ 52 do { if (verbose) pr_alert("%s" SCALE_FLAG " %s\n", scale_type, s); } while (0) 53 #define SCALEOUT_ERRSTRING(s) \ 54 pr_alert("%s" SCALE_FLAG "!!! %s\n", scale_type, s) 55 56 /* 57 * The intended use cases for the nreaders and nwriters module parameters 58 * are as follows: 59 * 60 * 1. Specify only the nr_cpus kernel boot parameter. This will 61 * set both nreaders and nwriters to the value specified by 62 * nr_cpus for a mixed reader/writer test. 63 * 64 * 2. Specify the nr_cpus kernel boot parameter, but set 65 * rcuscale.nreaders to zero. This will set nwriters to the 66 * value specified by nr_cpus for an update-only test. 67 * 68 * 3. Specify the nr_cpus kernel boot parameter, but set 69 * rcuscale.nwriters to zero. This will set nreaders to the 70 * value specified by nr_cpus for a read-only test. 71 * 72 * Various other use cases may of course be specified. 73 * 74 * Note that this test's readers are intended only as a test load for 75 * the writers. The reader scalability statistics will be overly 76 * pessimistic due to the per-critical-section interrupt disabling, 77 * test-end checks, and the pair of calls through pointers. 78 */ 79 80 #ifdef MODULE 81 # define RCUSCALE_SHUTDOWN 0 82 #else 83 # define RCUSCALE_SHUTDOWN 1 84 #endif 85 86 torture_param(bool, gp_async, false, "Use asynchronous GP wait primitives"); 87 torture_param(int, gp_async_max, 1000, "Max # outstanding waits per reader"); 88 torture_param(bool, gp_exp, false, "Use expedited GP wait primitives"); 89 torture_param(int, holdoff, 10, "Holdoff time before test start (s)"); 90 torture_param(int, nreaders, -1, "Number of RCU reader threads"); 91 torture_param(int, nwriters, -1, "Number of RCU updater threads"); 92 torture_param(bool, shutdown, RCUSCALE_SHUTDOWN, 93 "Shutdown at end of scalability tests."); 94 torture_param(int, verbose, 1, "Enable verbose debugging printk()s"); 95 torture_param(int, writer_holdoff, 0, "Holdoff (us) between GPs, zero to disable"); 96 torture_param(int, kfree_rcu_test, 0, "Do we run a kfree_rcu() scale test?"); 97 torture_param(int, kfree_mult, 1, "Multiple of kfree_obj size to allocate."); 98 99 static char *scale_type = "rcu"; 100 module_param(scale_type, charp, 0444); 101 MODULE_PARM_DESC(scale_type, "Type of RCU to scalability-test (rcu, srcu, ...)"); 102 103 static int nrealreaders; 104 static int nrealwriters; 105 static struct task_struct **writer_tasks; 106 static struct task_struct **reader_tasks; 107 static struct task_struct *shutdown_task; 108 109 static u64 **writer_durations; 110 static int *writer_n_durations; 111 static atomic_t n_rcu_scale_reader_started; 112 static atomic_t n_rcu_scale_writer_started; 113 static atomic_t n_rcu_scale_writer_finished; 114 static wait_queue_head_t shutdown_wq; 115 static u64 t_rcu_scale_writer_started; 116 static u64 t_rcu_scale_writer_finished; 117 static unsigned long b_rcu_gp_test_started; 118 static unsigned long b_rcu_gp_test_finished; 119 static DEFINE_PER_CPU(atomic_t, n_async_inflight); 120 121 #define MAX_MEAS 10000 122 #define MIN_MEAS 100 123 124 /* 125 * Operations vector for selecting different types of tests. 126 */ 127 128 struct rcu_scale_ops { 129 int ptype; 130 void (*init)(void); 131 void (*cleanup)(void); 132 int (*readlock)(void); 133 void (*readunlock)(int idx); 134 unsigned long (*get_gp_seq)(void); 135 unsigned long (*gp_diff)(unsigned long new, unsigned long old); 136 unsigned long (*exp_completed)(void); 137 void (*async)(struct rcu_head *head, rcu_callback_t func); 138 void (*gp_barrier)(void); 139 void (*sync)(void); 140 void (*exp_sync)(void); 141 const char *name; 142 }; 143 144 static struct rcu_scale_ops *cur_ops; 145 146 /* 147 * Definitions for rcu scalability testing. 148 */ 149 150 static int rcu_scale_read_lock(void) __acquires(RCU) 151 { 152 rcu_read_lock(); 153 return 0; 154 } 155 156 static void rcu_scale_read_unlock(int idx) __releases(RCU) 157 { 158 rcu_read_unlock(); 159 } 160 161 static unsigned long __maybe_unused rcu_no_completed(void) 162 { 163 return 0; 164 } 165 166 static void rcu_sync_scale_init(void) 167 { 168 } 169 170 static struct rcu_scale_ops rcu_ops = { 171 .ptype = RCU_FLAVOR, 172 .init = rcu_sync_scale_init, 173 .readlock = rcu_scale_read_lock, 174 .readunlock = rcu_scale_read_unlock, 175 .get_gp_seq = rcu_get_gp_seq, 176 .gp_diff = rcu_seq_diff, 177 .exp_completed = rcu_exp_batches_completed, 178 .async = call_rcu, 179 .gp_barrier = rcu_barrier, 180 .sync = synchronize_rcu, 181 .exp_sync = synchronize_rcu_expedited, 182 .name = "rcu" 183 }; 184 185 /* 186 * Definitions for srcu scalability testing. 187 */ 188 189 DEFINE_STATIC_SRCU(srcu_ctl_scale); 190 static struct srcu_struct *srcu_ctlp = &srcu_ctl_scale; 191 192 static int srcu_scale_read_lock(void) __acquires(srcu_ctlp) 193 { 194 return srcu_read_lock(srcu_ctlp); 195 } 196 197 static void srcu_scale_read_unlock(int idx) __releases(srcu_ctlp) 198 { 199 srcu_read_unlock(srcu_ctlp, idx); 200 } 201 202 static unsigned long srcu_scale_completed(void) 203 { 204 return srcu_batches_completed(srcu_ctlp); 205 } 206 207 static void srcu_call_rcu(struct rcu_head *head, rcu_callback_t func) 208 { 209 call_srcu(srcu_ctlp, head, func); 210 } 211 212 static void srcu_rcu_barrier(void) 213 { 214 srcu_barrier(srcu_ctlp); 215 } 216 217 static void srcu_scale_synchronize(void) 218 { 219 synchronize_srcu(srcu_ctlp); 220 } 221 222 static void srcu_scale_synchronize_expedited(void) 223 { 224 synchronize_srcu_expedited(srcu_ctlp); 225 } 226 227 static struct rcu_scale_ops srcu_ops = { 228 .ptype = SRCU_FLAVOR, 229 .init = rcu_sync_scale_init, 230 .readlock = srcu_scale_read_lock, 231 .readunlock = srcu_scale_read_unlock, 232 .get_gp_seq = srcu_scale_completed, 233 .gp_diff = rcu_seq_diff, 234 .exp_completed = srcu_scale_completed, 235 .async = srcu_call_rcu, 236 .gp_barrier = srcu_rcu_barrier, 237 .sync = srcu_scale_synchronize, 238 .exp_sync = srcu_scale_synchronize_expedited, 239 .name = "srcu" 240 }; 241 242 static struct srcu_struct srcud; 243 244 static void srcu_sync_scale_init(void) 245 { 246 srcu_ctlp = &srcud; 247 init_srcu_struct(srcu_ctlp); 248 } 249 250 static void srcu_sync_scale_cleanup(void) 251 { 252 cleanup_srcu_struct(srcu_ctlp); 253 } 254 255 static struct rcu_scale_ops srcud_ops = { 256 .ptype = SRCU_FLAVOR, 257 .init = srcu_sync_scale_init, 258 .cleanup = srcu_sync_scale_cleanup, 259 .readlock = srcu_scale_read_lock, 260 .readunlock = srcu_scale_read_unlock, 261 .get_gp_seq = srcu_scale_completed, 262 .gp_diff = rcu_seq_diff, 263 .exp_completed = srcu_scale_completed, 264 .async = srcu_call_rcu, 265 .gp_barrier = srcu_rcu_barrier, 266 .sync = srcu_scale_synchronize, 267 .exp_sync = srcu_scale_synchronize_expedited, 268 .name = "srcud" 269 }; 270 271 #ifdef CONFIG_TASKS_RCU 272 273 /* 274 * Definitions for RCU-tasks scalability testing. 275 */ 276 277 static int tasks_scale_read_lock(void) 278 { 279 return 0; 280 } 281 282 static void tasks_scale_read_unlock(int idx) 283 { 284 } 285 286 static struct rcu_scale_ops tasks_ops = { 287 .ptype = RCU_TASKS_FLAVOR, 288 .init = rcu_sync_scale_init, 289 .readlock = tasks_scale_read_lock, 290 .readunlock = tasks_scale_read_unlock, 291 .get_gp_seq = rcu_no_completed, 292 .gp_diff = rcu_seq_diff, 293 .async = call_rcu_tasks, 294 .gp_barrier = rcu_barrier_tasks, 295 .sync = synchronize_rcu_tasks, 296 .exp_sync = synchronize_rcu_tasks, 297 .name = "tasks" 298 }; 299 300 #define TASKS_OPS &tasks_ops, 301 302 #else // #ifdef CONFIG_TASKS_RCU 303 304 #define TASKS_OPS 305 306 #endif // #else // #ifdef CONFIG_TASKS_RCU 307 308 #ifdef CONFIG_TASKS_TRACE_RCU 309 310 /* 311 * Definitions for RCU-tasks-trace scalability testing. 312 */ 313 314 static int tasks_trace_scale_read_lock(void) 315 { 316 rcu_read_lock_trace(); 317 return 0; 318 } 319 320 static void tasks_trace_scale_read_unlock(int idx) 321 { 322 rcu_read_unlock_trace(); 323 } 324 325 static struct rcu_scale_ops tasks_tracing_ops = { 326 .ptype = RCU_TASKS_FLAVOR, 327 .init = rcu_sync_scale_init, 328 .readlock = tasks_trace_scale_read_lock, 329 .readunlock = tasks_trace_scale_read_unlock, 330 .get_gp_seq = rcu_no_completed, 331 .gp_diff = rcu_seq_diff, 332 .async = call_rcu_tasks_trace, 333 .gp_barrier = rcu_barrier_tasks_trace, 334 .sync = synchronize_rcu_tasks_trace, 335 .exp_sync = synchronize_rcu_tasks_trace, 336 .name = "tasks-tracing" 337 }; 338 339 #define TASKS_TRACING_OPS &tasks_tracing_ops, 340 341 #else // #ifdef CONFIG_TASKS_TRACE_RCU 342 343 #define TASKS_TRACING_OPS 344 345 #endif // #else // #ifdef CONFIG_TASKS_TRACE_RCU 346 347 static unsigned long rcuscale_seq_diff(unsigned long new, unsigned long old) 348 { 349 if (!cur_ops->gp_diff) 350 return new - old; 351 return cur_ops->gp_diff(new, old); 352 } 353 354 /* 355 * If scalability tests complete, wait for shutdown to commence. 356 */ 357 static void rcu_scale_wait_shutdown(void) 358 { 359 cond_resched_tasks_rcu_qs(); 360 if (atomic_read(&n_rcu_scale_writer_finished) < nrealwriters) 361 return; 362 while (!torture_must_stop()) 363 schedule_timeout_uninterruptible(1); 364 } 365 366 /* 367 * RCU scalability reader kthread. Repeatedly does empty RCU read-side 368 * critical section, minimizing update-side interference. However, the 369 * point of this test is not to evaluate reader scalability, but instead 370 * to serve as a test load for update-side scalability testing. 371 */ 372 static int 373 rcu_scale_reader(void *arg) 374 { 375 unsigned long flags; 376 int idx; 377 long me = (long)arg; 378 379 VERBOSE_SCALEOUT_STRING("rcu_scale_reader task started"); 380 set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids)); 381 set_user_nice(current, MAX_NICE); 382 atomic_inc(&n_rcu_scale_reader_started); 383 384 do { 385 local_irq_save(flags); 386 idx = cur_ops->readlock(); 387 cur_ops->readunlock(idx); 388 local_irq_restore(flags); 389 rcu_scale_wait_shutdown(); 390 } while (!torture_must_stop()); 391 torture_kthread_stopping("rcu_scale_reader"); 392 return 0; 393 } 394 395 /* 396 * Callback function for asynchronous grace periods from rcu_scale_writer(). 397 */ 398 static void rcu_scale_async_cb(struct rcu_head *rhp) 399 { 400 atomic_dec(this_cpu_ptr(&n_async_inflight)); 401 kfree(rhp); 402 } 403 404 /* 405 * RCU scale writer kthread. Repeatedly does a grace period. 406 */ 407 static int 408 rcu_scale_writer(void *arg) 409 { 410 int i = 0; 411 int i_max; 412 long me = (long)arg; 413 struct rcu_head *rhp = NULL; 414 bool started = false, done = false, alldone = false; 415 u64 t; 416 u64 *wdp; 417 u64 *wdpp = writer_durations[me]; 418 419 VERBOSE_SCALEOUT_STRING("rcu_scale_writer task started"); 420 WARN_ON(!wdpp); 421 set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids)); 422 current->flags |= PF_NO_SETAFFINITY; 423 sched_set_fifo_low(current); 424 425 if (holdoff) 426 schedule_timeout_uninterruptible(holdoff * HZ); 427 428 /* 429 * Wait until rcu_end_inkernel_boot() is called for normal GP tests 430 * so that RCU is not always expedited for normal GP tests. 431 * The system_state test is approximate, but works well in practice. 432 */ 433 while (!gp_exp && system_state != SYSTEM_RUNNING) 434 schedule_timeout_uninterruptible(1); 435 436 t = ktime_get_mono_fast_ns(); 437 if (atomic_inc_return(&n_rcu_scale_writer_started) >= nrealwriters) { 438 t_rcu_scale_writer_started = t; 439 if (gp_exp) { 440 b_rcu_gp_test_started = 441 cur_ops->exp_completed() / 2; 442 } else { 443 b_rcu_gp_test_started = cur_ops->get_gp_seq(); 444 } 445 } 446 447 do { 448 if (writer_holdoff) 449 udelay(writer_holdoff); 450 wdp = &wdpp[i]; 451 *wdp = ktime_get_mono_fast_ns(); 452 if (gp_async) { 453 retry: 454 if (!rhp) 455 rhp = kmalloc(sizeof(*rhp), GFP_KERNEL); 456 if (rhp && atomic_read(this_cpu_ptr(&n_async_inflight)) < gp_async_max) { 457 atomic_inc(this_cpu_ptr(&n_async_inflight)); 458 cur_ops->async(rhp, rcu_scale_async_cb); 459 rhp = NULL; 460 } else if (!kthread_should_stop()) { 461 cur_ops->gp_barrier(); 462 goto retry; 463 } else { 464 kfree(rhp); /* Because we are stopping. */ 465 } 466 } else if (gp_exp) { 467 cur_ops->exp_sync(); 468 } else { 469 cur_ops->sync(); 470 } 471 t = ktime_get_mono_fast_ns(); 472 *wdp = t - *wdp; 473 i_max = i; 474 if (!started && 475 atomic_read(&n_rcu_scale_writer_started) >= nrealwriters) 476 started = true; 477 if (!done && i >= MIN_MEAS) { 478 done = true; 479 sched_set_normal(current, 0); 480 pr_alert("%s%s rcu_scale_writer %ld has %d measurements\n", 481 scale_type, SCALE_FLAG, me, MIN_MEAS); 482 if (atomic_inc_return(&n_rcu_scale_writer_finished) >= 483 nrealwriters) { 484 schedule_timeout_interruptible(10); 485 rcu_ftrace_dump(DUMP_ALL); 486 SCALEOUT_STRING("Test complete"); 487 t_rcu_scale_writer_finished = t; 488 if (gp_exp) { 489 b_rcu_gp_test_finished = 490 cur_ops->exp_completed() / 2; 491 } else { 492 b_rcu_gp_test_finished = 493 cur_ops->get_gp_seq(); 494 } 495 if (shutdown) { 496 smp_mb(); /* Assign before wake. */ 497 wake_up(&shutdown_wq); 498 } 499 } 500 } 501 if (done && !alldone && 502 atomic_read(&n_rcu_scale_writer_finished) >= nrealwriters) 503 alldone = true; 504 if (started && !alldone && i < MAX_MEAS - 1) 505 i++; 506 rcu_scale_wait_shutdown(); 507 } while (!torture_must_stop()); 508 if (gp_async) { 509 cur_ops->gp_barrier(); 510 } 511 writer_n_durations[me] = i_max + 1; 512 torture_kthread_stopping("rcu_scale_writer"); 513 return 0; 514 } 515 516 static void 517 rcu_scale_print_module_parms(struct rcu_scale_ops *cur_ops, const char *tag) 518 { 519 pr_alert("%s" SCALE_FLAG 520 "--- %s: nreaders=%d nwriters=%d verbose=%d shutdown=%d\n", 521 scale_type, tag, nrealreaders, nrealwriters, verbose, shutdown); 522 } 523 524 static void 525 rcu_scale_cleanup(void) 526 { 527 int i; 528 int j; 529 int ngps = 0; 530 u64 *wdp; 531 u64 *wdpp; 532 533 /* 534 * Would like warning at start, but everything is expedited 535 * during the mid-boot phase, so have to wait till the end. 536 */ 537 if (rcu_gp_is_expedited() && !rcu_gp_is_normal() && !gp_exp) 538 SCALEOUT_ERRSTRING("All grace periods expedited, no normal ones to measure!"); 539 if (rcu_gp_is_normal() && gp_exp) 540 SCALEOUT_ERRSTRING("All grace periods normal, no expedited ones to measure!"); 541 if (gp_exp && gp_async) 542 SCALEOUT_ERRSTRING("No expedited async GPs, so went with async!"); 543 544 if (torture_cleanup_begin()) 545 return; 546 if (!cur_ops) { 547 torture_cleanup_end(); 548 return; 549 } 550 551 if (reader_tasks) { 552 for (i = 0; i < nrealreaders; i++) 553 torture_stop_kthread(rcu_scale_reader, 554 reader_tasks[i]); 555 kfree(reader_tasks); 556 } 557 558 if (writer_tasks) { 559 for (i = 0; i < nrealwriters; i++) { 560 torture_stop_kthread(rcu_scale_writer, 561 writer_tasks[i]); 562 if (!writer_n_durations) 563 continue; 564 j = writer_n_durations[i]; 565 pr_alert("%s%s writer %d gps: %d\n", 566 scale_type, SCALE_FLAG, i, j); 567 ngps += j; 568 } 569 pr_alert("%s%s start: %llu end: %llu duration: %llu gps: %d batches: %ld\n", 570 scale_type, SCALE_FLAG, 571 t_rcu_scale_writer_started, t_rcu_scale_writer_finished, 572 t_rcu_scale_writer_finished - 573 t_rcu_scale_writer_started, 574 ngps, 575 rcuscale_seq_diff(b_rcu_gp_test_finished, 576 b_rcu_gp_test_started)); 577 for (i = 0; i < nrealwriters; i++) { 578 if (!writer_durations) 579 break; 580 if (!writer_n_durations) 581 continue; 582 wdpp = writer_durations[i]; 583 if (!wdpp) 584 continue; 585 for (j = 0; j < writer_n_durations[i]; j++) { 586 wdp = &wdpp[j]; 587 pr_alert("%s%s %4d writer-duration: %5d %llu\n", 588 scale_type, SCALE_FLAG, 589 i, j, *wdp); 590 if (j % 100 == 0) 591 schedule_timeout_uninterruptible(1); 592 } 593 kfree(writer_durations[i]); 594 } 595 kfree(writer_tasks); 596 kfree(writer_durations); 597 kfree(writer_n_durations); 598 } 599 600 /* Do torture-type-specific cleanup operations. */ 601 if (cur_ops->cleanup != NULL) 602 cur_ops->cleanup(); 603 604 torture_cleanup_end(); 605 } 606 607 /* 608 * Return the number if non-negative. If -1, the number of CPUs. 609 * If less than -1, that much less than the number of CPUs, but 610 * at least one. 611 */ 612 static int compute_real(int n) 613 { 614 int nr; 615 616 if (n >= 0) { 617 nr = n; 618 } else { 619 nr = num_online_cpus() + 1 + n; 620 if (nr <= 0) 621 nr = 1; 622 } 623 return nr; 624 } 625 626 /* 627 * RCU scalability shutdown kthread. Just waits to be awakened, then shuts 628 * down system. 629 */ 630 static int 631 rcu_scale_shutdown(void *arg) 632 { 633 wait_event(shutdown_wq, 634 atomic_read(&n_rcu_scale_writer_finished) >= nrealwriters); 635 smp_mb(); /* Wake before output. */ 636 rcu_scale_cleanup(); 637 kernel_power_off(); 638 return -EINVAL; 639 } 640 641 /* 642 * kfree_rcu() scalability tests: Start a kfree_rcu() loop on all CPUs for number 643 * of iterations and measure total time and number of GP for all iterations to complete. 644 */ 645 646 torture_param(int, kfree_nthreads, -1, "Number of threads running loops of kfree_rcu()."); 647 torture_param(int, kfree_alloc_num, 8000, "Number of allocations and frees done in an iteration."); 648 torture_param(int, kfree_loops, 10, "Number of loops doing kfree_alloc_num allocations and frees."); 649 torture_param(bool, kfree_rcu_test_double, false, "Do we run a kfree_rcu() double-argument scale test?"); 650 torture_param(bool, kfree_rcu_test_single, false, "Do we run a kfree_rcu() single-argument scale test?"); 651 652 static struct task_struct **kfree_reader_tasks; 653 static int kfree_nrealthreads; 654 static atomic_t n_kfree_scale_thread_started; 655 static atomic_t n_kfree_scale_thread_ended; 656 657 struct kfree_obj { 658 char kfree_obj[8]; 659 struct rcu_head rh; 660 }; 661 662 static int 663 kfree_scale_thread(void *arg) 664 { 665 int i, loop = 0; 666 long me = (long)arg; 667 struct kfree_obj *alloc_ptr; 668 u64 start_time, end_time; 669 long long mem_begin, mem_during = 0; 670 bool kfree_rcu_test_both; 671 DEFINE_TORTURE_RANDOM(tr); 672 673 VERBOSE_SCALEOUT_STRING("kfree_scale_thread task started"); 674 set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids)); 675 set_user_nice(current, MAX_NICE); 676 kfree_rcu_test_both = (kfree_rcu_test_single == kfree_rcu_test_double); 677 678 start_time = ktime_get_mono_fast_ns(); 679 680 if (atomic_inc_return(&n_kfree_scale_thread_started) >= kfree_nrealthreads) { 681 if (gp_exp) 682 b_rcu_gp_test_started = cur_ops->exp_completed() / 2; 683 else 684 b_rcu_gp_test_started = cur_ops->get_gp_seq(); 685 } 686 687 do { 688 if (!mem_during) { 689 mem_during = mem_begin = si_mem_available(); 690 } else if (loop % (kfree_loops / 4) == 0) { 691 mem_during = (mem_during + si_mem_available()) / 2; 692 } 693 694 for (i = 0; i < kfree_alloc_num; i++) { 695 alloc_ptr = kmalloc(kfree_mult * sizeof(struct kfree_obj), GFP_KERNEL); 696 if (!alloc_ptr) 697 return -ENOMEM; 698 699 // By default kfree_rcu_test_single and kfree_rcu_test_double are 700 // initialized to false. If both have the same value (false or true) 701 // both are randomly tested, otherwise only the one with value true 702 // is tested. 703 if ((kfree_rcu_test_single && !kfree_rcu_test_double) || 704 (kfree_rcu_test_both && torture_random(&tr) & 0x800)) 705 kfree_rcu(alloc_ptr); 706 else 707 kfree_rcu(alloc_ptr, rh); 708 } 709 710 cond_resched(); 711 } while (!torture_must_stop() && ++loop < kfree_loops); 712 713 if (atomic_inc_return(&n_kfree_scale_thread_ended) >= kfree_nrealthreads) { 714 end_time = ktime_get_mono_fast_ns(); 715 716 if (gp_exp) 717 b_rcu_gp_test_finished = cur_ops->exp_completed() / 2; 718 else 719 b_rcu_gp_test_finished = cur_ops->get_gp_seq(); 720 721 pr_alert("Total time taken by all kfree'ers: %llu ns, loops: %d, batches: %ld, memory footprint: %lldMB\n", 722 (unsigned long long)(end_time - start_time), kfree_loops, 723 rcuscale_seq_diff(b_rcu_gp_test_finished, b_rcu_gp_test_started), 724 (mem_begin - mem_during) >> (20 - PAGE_SHIFT)); 725 726 if (shutdown) { 727 smp_mb(); /* Assign before wake. */ 728 wake_up(&shutdown_wq); 729 } 730 } 731 732 torture_kthread_stopping("kfree_scale_thread"); 733 return 0; 734 } 735 736 static void 737 kfree_scale_cleanup(void) 738 { 739 int i; 740 741 if (torture_cleanup_begin()) 742 return; 743 744 if (kfree_reader_tasks) { 745 for (i = 0; i < kfree_nrealthreads; i++) 746 torture_stop_kthread(kfree_scale_thread, 747 kfree_reader_tasks[i]); 748 kfree(kfree_reader_tasks); 749 } 750 751 torture_cleanup_end(); 752 } 753 754 /* 755 * shutdown kthread. Just waits to be awakened, then shuts down system. 756 */ 757 static int 758 kfree_scale_shutdown(void *arg) 759 { 760 wait_event(shutdown_wq, 761 atomic_read(&n_kfree_scale_thread_ended) >= kfree_nrealthreads); 762 763 smp_mb(); /* Wake before output. */ 764 765 kfree_scale_cleanup(); 766 kernel_power_off(); 767 return -EINVAL; 768 } 769 770 static int __init 771 kfree_scale_init(void) 772 { 773 long i; 774 int firsterr = 0; 775 776 kfree_nrealthreads = compute_real(kfree_nthreads); 777 /* Start up the kthreads. */ 778 if (shutdown) { 779 init_waitqueue_head(&shutdown_wq); 780 firsterr = torture_create_kthread(kfree_scale_shutdown, NULL, 781 shutdown_task); 782 if (torture_init_error(firsterr)) 783 goto unwind; 784 schedule_timeout_uninterruptible(1); 785 } 786 787 pr_alert("kfree object size=%zu\n", kfree_mult * sizeof(struct kfree_obj)); 788 789 kfree_reader_tasks = kcalloc(kfree_nrealthreads, sizeof(kfree_reader_tasks[0]), 790 GFP_KERNEL); 791 if (kfree_reader_tasks == NULL) { 792 firsterr = -ENOMEM; 793 goto unwind; 794 } 795 796 for (i = 0; i < kfree_nrealthreads; i++) { 797 firsterr = torture_create_kthread(kfree_scale_thread, (void *)i, 798 kfree_reader_tasks[i]); 799 if (torture_init_error(firsterr)) 800 goto unwind; 801 } 802 803 while (atomic_read(&n_kfree_scale_thread_started) < kfree_nrealthreads) 804 schedule_timeout_uninterruptible(1); 805 806 torture_init_end(); 807 return 0; 808 809 unwind: 810 torture_init_end(); 811 kfree_scale_cleanup(); 812 return firsterr; 813 } 814 815 static int __init 816 rcu_scale_init(void) 817 { 818 long i; 819 int firsterr = 0; 820 static struct rcu_scale_ops *scale_ops[] = { 821 &rcu_ops, &srcu_ops, &srcud_ops, TASKS_OPS TASKS_TRACING_OPS 822 }; 823 824 if (!torture_init_begin(scale_type, verbose)) 825 return -EBUSY; 826 827 /* Process args and announce that the scalability'er is on the job. */ 828 for (i = 0; i < ARRAY_SIZE(scale_ops); i++) { 829 cur_ops = scale_ops[i]; 830 if (strcmp(scale_type, cur_ops->name) == 0) 831 break; 832 } 833 if (i == ARRAY_SIZE(scale_ops)) { 834 pr_alert("rcu-scale: invalid scale type: \"%s\"\n", scale_type); 835 pr_alert("rcu-scale types:"); 836 for (i = 0; i < ARRAY_SIZE(scale_ops); i++) 837 pr_cont(" %s", scale_ops[i]->name); 838 pr_cont("\n"); 839 firsterr = -EINVAL; 840 cur_ops = NULL; 841 goto unwind; 842 } 843 if (cur_ops->init) 844 cur_ops->init(); 845 846 if (kfree_rcu_test) 847 return kfree_scale_init(); 848 849 nrealwriters = compute_real(nwriters); 850 nrealreaders = compute_real(nreaders); 851 atomic_set(&n_rcu_scale_reader_started, 0); 852 atomic_set(&n_rcu_scale_writer_started, 0); 853 atomic_set(&n_rcu_scale_writer_finished, 0); 854 rcu_scale_print_module_parms(cur_ops, "Start of test"); 855 856 /* Start up the kthreads. */ 857 858 if (shutdown) { 859 init_waitqueue_head(&shutdown_wq); 860 firsterr = torture_create_kthread(rcu_scale_shutdown, NULL, 861 shutdown_task); 862 if (torture_init_error(firsterr)) 863 goto unwind; 864 schedule_timeout_uninterruptible(1); 865 } 866 reader_tasks = kcalloc(nrealreaders, sizeof(reader_tasks[0]), 867 GFP_KERNEL); 868 if (reader_tasks == NULL) { 869 SCALEOUT_ERRSTRING("out of memory"); 870 firsterr = -ENOMEM; 871 goto unwind; 872 } 873 for (i = 0; i < nrealreaders; i++) { 874 firsterr = torture_create_kthread(rcu_scale_reader, (void *)i, 875 reader_tasks[i]); 876 if (torture_init_error(firsterr)) 877 goto unwind; 878 } 879 while (atomic_read(&n_rcu_scale_reader_started) < nrealreaders) 880 schedule_timeout_uninterruptible(1); 881 writer_tasks = kcalloc(nrealwriters, sizeof(reader_tasks[0]), 882 GFP_KERNEL); 883 writer_durations = kcalloc(nrealwriters, sizeof(*writer_durations), 884 GFP_KERNEL); 885 writer_n_durations = 886 kcalloc(nrealwriters, sizeof(*writer_n_durations), 887 GFP_KERNEL); 888 if (!writer_tasks || !writer_durations || !writer_n_durations) { 889 SCALEOUT_ERRSTRING("out of memory"); 890 firsterr = -ENOMEM; 891 goto unwind; 892 } 893 for (i = 0; i < nrealwriters; i++) { 894 writer_durations[i] = 895 kcalloc(MAX_MEAS, sizeof(*writer_durations[i]), 896 GFP_KERNEL); 897 if (!writer_durations[i]) { 898 firsterr = -ENOMEM; 899 goto unwind; 900 } 901 firsterr = torture_create_kthread(rcu_scale_writer, (void *)i, 902 writer_tasks[i]); 903 if (torture_init_error(firsterr)) 904 goto unwind; 905 } 906 torture_init_end(); 907 return 0; 908 909 unwind: 910 torture_init_end(); 911 rcu_scale_cleanup(); 912 if (shutdown) { 913 WARN_ON(!IS_MODULE(CONFIG_RCU_SCALE_TEST)); 914 kernel_power_off(); 915 } 916 return firsterr; 917 } 918 919 module_init(rcu_scale_init); 920 module_exit(rcu_scale_cleanup); 921