1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Common functions for in-kernel torture tests. 4 * 5 * Copyright (C) IBM Corporation, 2014 6 * 7 * Author: Paul E. McKenney <paulmck@linux.ibm.com> 8 * Based on kernel/rcu/torture.c. 9 */ 10 11 #define pr_fmt(fmt) fmt 12 13 #include <linux/types.h> 14 #include <linux/kernel.h> 15 #include <linux/init.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/interrupt.h> 22 #include <linux/sched.h> 23 #include <linux/sched/clock.h> 24 #include <linux/atomic.h> 25 #include <linux/bitops.h> 26 #include <linux/completion.h> 27 #include <linux/moduleparam.h> 28 #include <linux/percpu.h> 29 #include <linux/notifier.h> 30 #include <linux/reboot.h> 31 #include <linux/freezer.h> 32 #include <linux/cpu.h> 33 #include <linux/delay.h> 34 #include <linux/stat.h> 35 #include <linux/slab.h> 36 #include <linux/trace_clock.h> 37 #include <linux/ktime.h> 38 #include <asm/byteorder.h> 39 #include <linux/torture.h> 40 #include <linux/sched/rt.h> 41 #include "rcu/rcu.h" 42 43 MODULE_DESCRIPTION("Common functions for in-kernel torture tests"); 44 MODULE_LICENSE("GPL"); 45 MODULE_AUTHOR("Paul E. McKenney <paulmck@linux.ibm.com>"); 46 47 static bool disable_onoff_at_boot; 48 module_param(disable_onoff_at_boot, bool, 0444); 49 50 static bool ftrace_dump_at_shutdown; 51 module_param(ftrace_dump_at_shutdown, bool, 0444); 52 53 static int verbose_sleep_frequency; 54 module_param(verbose_sleep_frequency, int, 0444); 55 56 static int verbose_sleep_duration = 1; 57 module_param(verbose_sleep_duration, int, 0444); 58 59 static int random_shuffle; 60 module_param(random_shuffle, int, 0444); 61 62 static char *torture_type; 63 static int verbose; 64 65 /* Mediate rmmod and system shutdown. Concurrent rmmod & shutdown illegal! */ 66 #define FULLSTOP_DONTSTOP 0 /* Normal operation. */ 67 #define FULLSTOP_SHUTDOWN 1 /* System shutdown with torture running. */ 68 #define FULLSTOP_RMMOD 2 /* Normal rmmod of torture. */ 69 static int fullstop = FULLSTOP_RMMOD; 70 static DEFINE_MUTEX(fullstop_mutex); 71 72 static atomic_t verbose_sleep_counter; 73 74 /* 75 * Sleep if needed from VERBOSE_TOROUT*(). 76 */ 77 void verbose_torout_sleep(void) 78 { 79 if (verbose_sleep_frequency > 0 && 80 verbose_sleep_duration > 0 && 81 !(atomic_inc_return(&verbose_sleep_counter) % verbose_sleep_frequency)) 82 schedule_timeout_uninterruptible(verbose_sleep_duration); 83 } 84 EXPORT_SYMBOL_GPL(verbose_torout_sleep); 85 86 /* 87 * Schedule a high-resolution-timer sleep in nanoseconds, with a 32-bit 88 * nanosecond random fuzz. This function and its friends desynchronize 89 * testing from the timer wheel. 90 */ 91 int torture_hrtimeout_ns(ktime_t baset_ns, u32 fuzzt_ns, const enum hrtimer_mode mode, 92 struct torture_random_state *trsp) 93 { 94 ktime_t hto = baset_ns; 95 96 if (trsp && fuzzt_ns) 97 hto += torture_random(trsp) % fuzzt_ns; 98 set_current_state(TASK_IDLE); 99 return schedule_hrtimeout(&hto, mode); 100 } 101 EXPORT_SYMBOL_GPL(torture_hrtimeout_ns); 102 103 /* 104 * Schedule a high-resolution-timer sleep in microseconds, with a 32-bit 105 * nanosecond (not microsecond!) random fuzz. 106 */ 107 int torture_hrtimeout_us(u32 baset_us, u32 fuzzt_ns, struct torture_random_state *trsp) 108 { 109 ktime_t baset_ns = baset_us * NSEC_PER_USEC; 110 111 return torture_hrtimeout_ns(baset_ns, fuzzt_ns, HRTIMER_MODE_REL, trsp); 112 } 113 EXPORT_SYMBOL_GPL(torture_hrtimeout_us); 114 115 /* 116 * Schedule a high-resolution-timer sleep in milliseconds, with a 32-bit 117 * microsecond (not millisecond!) random fuzz. 118 */ 119 int torture_hrtimeout_ms(u32 baset_ms, u32 fuzzt_us, struct torture_random_state *trsp) 120 { 121 ktime_t baset_ns = baset_ms * NSEC_PER_MSEC; 122 u32 fuzzt_ns; 123 124 if ((u32)~0U / NSEC_PER_USEC < fuzzt_us) 125 fuzzt_ns = (u32)~0U; 126 else 127 fuzzt_ns = fuzzt_us * NSEC_PER_USEC; 128 return torture_hrtimeout_ns(baset_ns, fuzzt_ns, HRTIMER_MODE_REL, trsp); 129 } 130 EXPORT_SYMBOL_GPL(torture_hrtimeout_ms); 131 132 /* 133 * Schedule a high-resolution-timer sleep in jiffies, with an 134 * implied one-jiffy random fuzz. This is intended to replace calls to 135 * schedule_timeout_interruptible() and friends. 136 */ 137 int torture_hrtimeout_jiffies(u32 baset_j, struct torture_random_state *trsp) 138 { 139 ktime_t baset_ns = jiffies_to_nsecs(baset_j); 140 141 return torture_hrtimeout_ns(baset_ns, jiffies_to_nsecs(1), HRTIMER_MODE_REL, trsp); 142 } 143 EXPORT_SYMBOL_GPL(torture_hrtimeout_jiffies); 144 145 /* 146 * Schedule a high-resolution-timer sleep in milliseconds, with a 32-bit 147 * millisecond (not second!) random fuzz. 148 */ 149 int torture_hrtimeout_s(u32 baset_s, u32 fuzzt_ms, struct torture_random_state *trsp) 150 { 151 ktime_t baset_ns = baset_s * NSEC_PER_SEC; 152 u32 fuzzt_ns; 153 154 if ((u32)~0U / NSEC_PER_MSEC < fuzzt_ms) 155 fuzzt_ns = (u32)~0U; 156 else 157 fuzzt_ns = fuzzt_ms * NSEC_PER_MSEC; 158 return torture_hrtimeout_ns(baset_ns, fuzzt_ns, HRTIMER_MODE_REL, trsp); 159 } 160 EXPORT_SYMBOL_GPL(torture_hrtimeout_s); 161 162 #ifdef CONFIG_HOTPLUG_CPU 163 164 /* 165 * Variables for online-offline handling. Only present if CPU hotplug 166 * is enabled, otherwise does nothing. 167 */ 168 169 static struct task_struct *onoff_task; 170 static long onoff_holdoff; 171 static long onoff_interval; 172 static torture_ofl_func *onoff_f; 173 static long n_offline_attempts; 174 static long n_offline_successes; 175 static unsigned long sum_offline; 176 static int min_offline = -1; 177 static int max_offline; 178 static long n_online_attempts; 179 static long n_online_successes; 180 static unsigned long sum_online; 181 static int min_online = -1; 182 static int max_online; 183 184 static int torture_online_cpus = NR_CPUS; 185 186 /* 187 * Some torture testing leverages confusion as to the number of online 188 * CPUs. This function returns the torture-testing view of this number, 189 * which allows torture tests to load-balance appropriately. 190 */ 191 int torture_num_online_cpus(void) 192 { 193 return READ_ONCE(torture_online_cpus); 194 } 195 EXPORT_SYMBOL_GPL(torture_num_online_cpus); 196 197 /* 198 * Attempt to take a CPU offline. Return false if the CPU is already 199 * offline or if it is not subject to CPU-hotplug operations. The 200 * caller can detect other failures by looking at the statistics. 201 */ 202 bool torture_offline(int cpu, long *n_offl_attempts, long *n_offl_successes, 203 unsigned long *sum_offl, int *min_offl, int *max_offl) 204 { 205 unsigned long delta; 206 int ret; 207 char *s; 208 unsigned long starttime; 209 210 if (!cpu_online(cpu) || !cpu_is_hotpluggable(cpu)) 211 return false; 212 if (num_online_cpus() <= 1) 213 return false; /* Can't offline the last CPU. */ 214 215 if (verbose > 1) 216 pr_alert("%s" TORTURE_FLAG 217 "torture_onoff task: offlining %d\n", 218 torture_type, cpu); 219 starttime = jiffies; 220 (*n_offl_attempts)++; 221 ret = remove_cpu(cpu); 222 if (ret) { 223 s = ""; 224 if (!rcu_inkernel_boot_has_ended() && ret == -EBUSY) { 225 // PCI probe frequently disables hotplug during boot. 226 (*n_offl_attempts)--; 227 s = " (-EBUSY forgiven during boot)"; 228 } 229 if (verbose) 230 pr_alert("%s" TORTURE_FLAG 231 "torture_onoff task: offline %d failed%s: errno %d\n", 232 torture_type, cpu, s, ret); 233 } else { 234 if (verbose > 1) 235 pr_alert("%s" TORTURE_FLAG 236 "torture_onoff task: offlined %d\n", 237 torture_type, cpu); 238 if (onoff_f) 239 onoff_f(); 240 (*n_offl_successes)++; 241 delta = jiffies - starttime; 242 *sum_offl += delta; 243 if (*min_offl < 0) { 244 *min_offl = delta; 245 *max_offl = delta; 246 } 247 if (*min_offl > delta) 248 *min_offl = delta; 249 if (*max_offl < delta) 250 *max_offl = delta; 251 WRITE_ONCE(torture_online_cpus, torture_online_cpus - 1); 252 WARN_ON_ONCE(torture_online_cpus <= 0); 253 } 254 255 return true; 256 } 257 EXPORT_SYMBOL_GPL(torture_offline); 258 259 /* 260 * Attempt to bring a CPU online. Return false if the CPU is already 261 * online or if it is not subject to CPU-hotplug operations. The 262 * caller can detect other failures by looking at the statistics. 263 */ 264 bool torture_online(int cpu, long *n_onl_attempts, long *n_onl_successes, 265 unsigned long *sum_onl, int *min_onl, int *max_onl) 266 { 267 unsigned long delta; 268 int ret; 269 char *s; 270 unsigned long starttime; 271 272 if (cpu_online(cpu) || !cpu_is_hotpluggable(cpu)) 273 return false; 274 275 if (verbose > 1) 276 pr_alert("%s" TORTURE_FLAG 277 "torture_onoff task: onlining %d\n", 278 torture_type, cpu); 279 starttime = jiffies; 280 (*n_onl_attempts)++; 281 ret = add_cpu(cpu); 282 if (ret) { 283 s = ""; 284 if (!rcu_inkernel_boot_has_ended() && ret == -EBUSY) { 285 // PCI probe frequently disables hotplug during boot. 286 (*n_onl_attempts)--; 287 s = " (-EBUSY forgiven during boot)"; 288 } 289 if (verbose) 290 pr_alert("%s" TORTURE_FLAG 291 "torture_onoff task: online %d failed%s: errno %d\n", 292 torture_type, cpu, s, ret); 293 } else { 294 if (verbose > 1) 295 pr_alert("%s" TORTURE_FLAG 296 "torture_onoff task: onlined %d\n", 297 torture_type, cpu); 298 (*n_onl_successes)++; 299 delta = jiffies - starttime; 300 *sum_onl += delta; 301 if (*min_onl < 0) { 302 *min_onl = delta; 303 *max_onl = delta; 304 } 305 if (*min_onl > delta) 306 *min_onl = delta; 307 if (*max_onl < delta) 308 *max_onl = delta; 309 WRITE_ONCE(torture_online_cpus, torture_online_cpus + 1); 310 } 311 312 return true; 313 } 314 EXPORT_SYMBOL_GPL(torture_online); 315 316 /* 317 * Get everything online at the beginning and ends of tests. 318 */ 319 static void torture_online_all(char *phase) 320 { 321 int cpu; 322 int ret; 323 324 for_each_possible_cpu(cpu) { 325 if (cpu_online(cpu)) 326 continue; 327 ret = add_cpu(cpu); 328 if (ret && verbose) { 329 pr_alert("%s" TORTURE_FLAG 330 "%s: %s online %d: errno %d\n", 331 __func__, phase, torture_type, cpu, ret); 332 } 333 } 334 } 335 336 /* 337 * Execute random CPU-hotplug operations at the interval specified 338 * by the onoff_interval. 339 */ 340 static int 341 torture_onoff(void *arg) 342 { 343 int cpu; 344 int maxcpu = -1; 345 DEFINE_TORTURE_RANDOM(rand); 346 347 VERBOSE_TOROUT_STRING("torture_onoff task started"); 348 for_each_online_cpu(cpu) 349 maxcpu = cpu; 350 WARN_ON(maxcpu < 0); 351 torture_online_all("Initial"); 352 if (maxcpu == 0) { 353 VERBOSE_TOROUT_STRING("Only one CPU, so CPU-hotplug testing is disabled"); 354 goto stop; 355 } 356 357 if (onoff_holdoff > 0) { 358 VERBOSE_TOROUT_STRING("torture_onoff begin holdoff"); 359 torture_hrtimeout_jiffies(onoff_holdoff, &rand); 360 VERBOSE_TOROUT_STRING("torture_onoff end holdoff"); 361 } 362 while (!rcu_inkernel_boot_has_ended()) 363 schedule_timeout_interruptible(HZ / 10); 364 while (!torture_must_stop()) { 365 if (disable_onoff_at_boot && !rcu_inkernel_boot_has_ended()) { 366 torture_hrtimeout_jiffies(HZ / 10, &rand); 367 continue; 368 } 369 cpu = torture_random(&rand) % (maxcpu + 1); 370 if (!torture_offline(cpu, 371 &n_offline_attempts, &n_offline_successes, 372 &sum_offline, &min_offline, &max_offline)) 373 torture_online(cpu, 374 &n_online_attempts, &n_online_successes, 375 &sum_online, &min_online, &max_online); 376 torture_hrtimeout_jiffies(onoff_interval, &rand); 377 } 378 379 stop: 380 torture_kthread_stopping("torture_onoff"); 381 torture_online_all("Final"); 382 return 0; 383 } 384 385 #endif /* #ifdef CONFIG_HOTPLUG_CPU */ 386 387 /* 388 * Initiate online-offline handling. 389 */ 390 int torture_onoff_init(long ooholdoff, long oointerval, torture_ofl_func *f) 391 { 392 #ifdef CONFIG_HOTPLUG_CPU 393 onoff_holdoff = ooholdoff; 394 onoff_interval = oointerval; 395 onoff_f = f; 396 if (onoff_interval <= 0) 397 return 0; 398 return torture_create_kthread(torture_onoff, NULL, onoff_task); 399 #else /* #ifdef CONFIG_HOTPLUG_CPU */ 400 return 0; 401 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */ 402 } 403 EXPORT_SYMBOL_GPL(torture_onoff_init); 404 405 /* 406 * Clean up after online/offline testing. 407 */ 408 static void torture_onoff_cleanup(void) 409 { 410 #ifdef CONFIG_HOTPLUG_CPU 411 if (onoff_task == NULL) 412 return; 413 VERBOSE_TOROUT_STRING("Stopping torture_onoff task"); 414 kthread_stop(onoff_task); 415 onoff_task = NULL; 416 #endif /* #ifdef CONFIG_HOTPLUG_CPU */ 417 } 418 419 /* 420 * Print online/offline testing statistics. 421 */ 422 void torture_onoff_stats(void) 423 { 424 #ifdef CONFIG_HOTPLUG_CPU 425 pr_cont("onoff: %ld/%ld:%ld/%ld %d,%d:%d,%d %lu:%lu (HZ=%d) ", 426 n_online_successes, n_online_attempts, 427 n_offline_successes, n_offline_attempts, 428 min_online, max_online, 429 min_offline, max_offline, 430 sum_online, sum_offline, HZ); 431 #endif /* #ifdef CONFIG_HOTPLUG_CPU */ 432 } 433 EXPORT_SYMBOL_GPL(torture_onoff_stats); 434 435 /* 436 * Were all the online/offline operations successful? 437 */ 438 bool torture_onoff_failures(void) 439 { 440 #ifdef CONFIG_HOTPLUG_CPU 441 return n_online_successes != n_online_attempts || 442 n_offline_successes != n_offline_attempts; 443 #else /* #ifdef CONFIG_HOTPLUG_CPU */ 444 return false; 445 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */ 446 } 447 EXPORT_SYMBOL_GPL(torture_onoff_failures); 448 449 #define TORTURE_RANDOM_MULT 39916801 /* prime */ 450 #define TORTURE_RANDOM_ADD 479001701 /* prime */ 451 #define TORTURE_RANDOM_REFRESH 10000 452 453 /* 454 * Crude but fast random-number generator. Uses a linear congruential 455 * generator, with occasional help from cpu_clock(). 456 */ 457 unsigned long 458 torture_random(struct torture_random_state *trsp) 459 { 460 if (--trsp->trs_count < 0) { 461 trsp->trs_state += (unsigned long)local_clock() + raw_smp_processor_id(); 462 trsp->trs_count = TORTURE_RANDOM_REFRESH; 463 } 464 trsp->trs_state = trsp->trs_state * TORTURE_RANDOM_MULT + 465 TORTURE_RANDOM_ADD; 466 return swahw32(trsp->trs_state); 467 } 468 EXPORT_SYMBOL_GPL(torture_random); 469 470 /* 471 * Variables for shuffling. The idea is to ensure that each CPU stays 472 * idle for an extended period to test interactions with dyntick idle, 473 * as well as interactions with any per-CPU variables. 474 */ 475 struct shuffle_task { 476 struct list_head st_l; 477 struct task_struct *st_t; 478 }; 479 480 static long shuffle_interval; /* In jiffies. */ 481 static struct task_struct *shuffler_task; 482 static cpumask_var_t shuffle_tmp_mask; 483 static int shuffle_idle_cpu; /* Force all torture tasks off this CPU */ 484 static struct list_head shuffle_task_list = LIST_HEAD_INIT(shuffle_task_list); 485 static DEFINE_MUTEX(shuffle_task_mutex); 486 487 /* 488 * Register a task to be shuffled. If there is no memory, just splat 489 * and don't bother registering. 490 */ 491 void torture_shuffle_task_register(struct task_struct *tp) 492 { 493 struct shuffle_task *stp; 494 495 if (WARN_ON_ONCE(tp == NULL)) 496 return; 497 stp = kmalloc_obj(*stp); 498 if (WARN_ON_ONCE(stp == NULL)) 499 return; 500 stp->st_t = tp; 501 mutex_lock(&shuffle_task_mutex); 502 list_add(&stp->st_l, &shuffle_task_list); 503 mutex_unlock(&shuffle_task_mutex); 504 } 505 EXPORT_SYMBOL_GPL(torture_shuffle_task_register); 506 507 /* 508 * Unregister all tasks, for example, at the end of the torture run. 509 */ 510 static void torture_shuffle_task_unregister_all(void) 511 { 512 struct shuffle_task *stp; 513 struct shuffle_task *p; 514 515 mutex_lock(&shuffle_task_mutex); 516 list_for_each_entry_safe(stp, p, &shuffle_task_list, st_l) { 517 list_del(&stp->st_l); 518 kfree(stp); 519 } 520 mutex_unlock(&shuffle_task_mutex); 521 } 522 523 /* Shuffle tasks such that we allow shuffle_idle_cpu to become idle. 524 * A special case is when shuffle_idle_cpu = -1, in which case we allow 525 * the tasks to run on all CPUs. 526 */ 527 static void torture_shuffle_tasks(struct torture_random_state *trp) 528 { 529 struct shuffle_task *stp; 530 531 cpumask_setall(shuffle_tmp_mask); 532 cpus_read_lock(); 533 534 /* No point in shuffling if there is only one online CPU (ex: UP) */ 535 if (num_online_cpus() == 1) { 536 cpus_read_unlock(); 537 return; 538 } 539 540 /* Advance to the next CPU. Upon overflow, don't idle any CPUs. */ 541 shuffle_idle_cpu = cpumask_next(shuffle_idle_cpu, shuffle_tmp_mask); 542 if (shuffle_idle_cpu >= nr_cpu_ids) 543 shuffle_idle_cpu = -1; 544 else 545 cpumask_clear_cpu(shuffle_idle_cpu, shuffle_tmp_mask); 546 547 mutex_lock(&shuffle_task_mutex); 548 list_for_each_entry(stp, &shuffle_task_list, st_l) { 549 if (!random_shuffle || torture_random(trp) & 0x1) 550 set_cpus_allowed_ptr(stp->st_t, shuffle_tmp_mask); 551 } 552 mutex_unlock(&shuffle_task_mutex); 553 554 cpus_read_unlock(); 555 } 556 557 /* Shuffle tasks across CPUs, with the intent of allowing each CPU in the 558 * system to become idle at a time and cut off its timer ticks. This is meant 559 * to test the support for such tickless idle CPU in RCU. 560 */ 561 static int torture_shuffle(void *arg) 562 { 563 DEFINE_TORTURE_RANDOM(rand); 564 565 VERBOSE_TOROUT_STRING("torture_shuffle task started"); 566 do { 567 torture_hrtimeout_jiffies(shuffle_interval, &rand); 568 torture_shuffle_tasks(&rand); 569 torture_shutdown_absorb("torture_shuffle"); 570 } while (!torture_must_stop()); 571 torture_kthread_stopping("torture_shuffle"); 572 return 0; 573 } 574 575 /* 576 * Start the shuffler, with shuffint in jiffies. 577 */ 578 int torture_shuffle_init(long shuffint) 579 { 580 int ret; 581 582 shuffle_interval = shuffint; 583 584 shuffle_idle_cpu = -1; 585 586 if (!alloc_cpumask_var(&shuffle_tmp_mask, GFP_KERNEL)) { 587 TOROUT_ERRSTRING("Failed to alloc mask"); 588 return -ENOMEM; 589 } 590 591 /* Create the shuffler thread */ 592 ret = torture_create_kthread(torture_shuffle, NULL, shuffler_task); 593 if (ret) 594 free_cpumask_var(shuffle_tmp_mask); 595 return ret; 596 } 597 EXPORT_SYMBOL_GPL(torture_shuffle_init); 598 599 /* 600 * Stop the shuffling. 601 */ 602 static void torture_shuffle_cleanup(void) 603 { 604 torture_shuffle_task_unregister_all(); 605 if (shuffler_task) { 606 VERBOSE_TOROUT_STRING("Stopping torture_shuffle task"); 607 kthread_stop(shuffler_task); 608 free_cpumask_var(shuffle_tmp_mask); 609 } 610 shuffler_task = NULL; 611 } 612 613 /* 614 * Variables for auto-shutdown. This allows "lights out" torture runs 615 * to be fully scripted. 616 */ 617 static struct task_struct *shutdown_task; 618 static ktime_t shutdown_time; /* time to system shutdown. */ 619 static void (*torture_shutdown_hook)(void); 620 621 /* 622 * Absorb kthreads into a kernel function that won't return, so that 623 * they won't ever access module text or data again. 624 */ 625 void torture_shutdown_absorb(const char *title) 626 { 627 while (READ_ONCE(fullstop) == FULLSTOP_SHUTDOWN) { 628 pr_notice("torture thread %s parking due to system shutdown\n", 629 title); 630 schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT); 631 } 632 } 633 EXPORT_SYMBOL_GPL(torture_shutdown_absorb); 634 635 /* 636 * Cause the torture test to shutdown the system after the test has 637 * run for the time specified by the shutdown_secs parameter. 638 */ 639 static int torture_shutdown(void *arg) 640 { 641 ktime_t ktime_snap; 642 643 VERBOSE_TOROUT_STRING("torture_shutdown task started"); 644 ktime_snap = ktime_get(); 645 while (ktime_before(ktime_snap, shutdown_time) && 646 !torture_must_stop()) { 647 if (verbose) 648 pr_alert("%s" TORTURE_FLAG 649 "torture_shutdown task: %llu ms remaining\n", 650 torture_type, 651 ktime_ms_delta(shutdown_time, ktime_snap)); 652 set_current_state(TASK_INTERRUPTIBLE); 653 schedule_hrtimeout(&shutdown_time, HRTIMER_MODE_ABS); 654 ktime_snap = ktime_get(); 655 } 656 if (torture_must_stop()) { 657 torture_kthread_stopping("torture_shutdown"); 658 return 0; 659 } 660 661 /* OK, shut down the system. */ 662 663 VERBOSE_TOROUT_STRING("torture_shutdown task shutting down system"); 664 shutdown_task = NULL; /* Avoid self-kill deadlock. */ 665 if (torture_shutdown_hook) 666 torture_shutdown_hook(); 667 else 668 VERBOSE_TOROUT_STRING("No torture_shutdown_hook(), skipping."); 669 if (ftrace_dump_at_shutdown) 670 rcu_ftrace_dump(DUMP_ALL); 671 kernel_power_off(); /* Shut down the system. */ 672 return 0; 673 } 674 675 /* 676 * Start up the shutdown task. 677 */ 678 int torture_shutdown_init(int ssecs, void (*cleanup)(void)) 679 { 680 torture_shutdown_hook = cleanup; 681 if (ssecs > 0) { 682 shutdown_time = ktime_add(ktime_get(), ktime_set(ssecs, 0)); 683 return torture_create_kthread(torture_shutdown, NULL, 684 shutdown_task); 685 } 686 return 0; 687 } 688 EXPORT_SYMBOL_GPL(torture_shutdown_init); 689 690 /* 691 * Detect and respond to a system shutdown. 692 */ 693 static int torture_shutdown_notify(struct notifier_block *unused1, 694 unsigned long unused2, void *unused3) 695 { 696 mutex_lock(&fullstop_mutex); 697 if (READ_ONCE(fullstop) == FULLSTOP_DONTSTOP) { 698 VERBOSE_TOROUT_STRING("Unscheduled system shutdown detected"); 699 WRITE_ONCE(fullstop, FULLSTOP_SHUTDOWN); 700 } else { 701 pr_warn("Concurrent rmmod and shutdown illegal!\n"); 702 } 703 mutex_unlock(&fullstop_mutex); 704 return NOTIFY_DONE; 705 } 706 707 static struct notifier_block torture_shutdown_nb = { 708 .notifier_call = torture_shutdown_notify, 709 }; 710 711 /* 712 * Shut down the shutdown task. Say what??? Heh! This can happen if 713 * the torture module gets an rmmod before the shutdown time arrives. ;-) 714 */ 715 static void torture_shutdown_cleanup(void) 716 { 717 unregister_reboot_notifier(&torture_shutdown_nb); 718 if (shutdown_task != NULL) { 719 VERBOSE_TOROUT_STRING("Stopping torture_shutdown task"); 720 kthread_stop(shutdown_task); 721 } 722 shutdown_task = NULL; 723 } 724 725 /* 726 * Variables for stuttering, which means to periodically pause and 727 * restart testing in order to catch bugs that appear when load is 728 * suddenly applied to or removed from the system. 729 */ 730 static struct task_struct *stutter_task; 731 static ktime_t stutter_till_abs_time; 732 static int stutter; 733 static int stutter_gap; 734 735 /* 736 * Block until the stutter interval ends. This must be called periodically 737 * by all running kthreads that need to be subject to stuttering. 738 */ 739 bool stutter_wait(const char *title) 740 { 741 bool ret = false; 742 ktime_t till_ns; 743 744 cond_resched_tasks_rcu_qs(); 745 till_ns = READ_ONCE(stutter_till_abs_time); 746 if (till_ns && ktime_before(ktime_get(), till_ns)) { 747 torture_hrtimeout_ns(till_ns, 0, HRTIMER_MODE_ABS, NULL); 748 ret = true; 749 } 750 torture_shutdown_absorb(title); 751 return ret; 752 } 753 EXPORT_SYMBOL_GPL(stutter_wait); 754 755 /* 756 * Cause the torture test to "stutter", starting and stopping all 757 * threads periodically. 758 */ 759 static int torture_stutter(void *arg) 760 { 761 ktime_t till_ns; 762 763 VERBOSE_TOROUT_STRING("torture_stutter task started"); 764 do { 765 if (!torture_must_stop() && stutter > 1) { 766 till_ns = ktime_add_ns(ktime_get(), 767 jiffies_to_nsecs(stutter)); 768 WRITE_ONCE(stutter_till_abs_time, till_ns); 769 torture_hrtimeout_jiffies(stutter - 1, NULL); 770 } 771 if (!torture_must_stop()) 772 torture_hrtimeout_jiffies(stutter_gap, NULL); 773 torture_shutdown_absorb("torture_stutter"); 774 } while (!torture_must_stop()); 775 torture_kthread_stopping("torture_stutter"); 776 return 0; 777 } 778 779 /* 780 * Initialize and kick off the torture_stutter kthread. 781 */ 782 int torture_stutter_init(const int s, const int sgap) 783 { 784 stutter = s; 785 stutter_gap = sgap; 786 return torture_create_kthread(torture_stutter, NULL, stutter_task); 787 } 788 EXPORT_SYMBOL_GPL(torture_stutter_init); 789 790 /* 791 * Cleanup after the torture_stutter kthread. 792 */ 793 static void torture_stutter_cleanup(void) 794 { 795 if (!stutter_task) 796 return; 797 VERBOSE_TOROUT_STRING("Stopping torture_stutter task"); 798 kthread_stop(stutter_task); 799 stutter_task = NULL; 800 } 801 802 static unsigned long torture_init_jiffies; 803 804 static void 805 torture_print_module_parms(void) 806 { 807 pr_alert("torture module --- %s: disable_onoff_at_boot=%d ftrace_dump_at_shutdown=%d verbose_sleep_frequency=%d verbose_sleep_duration=%d random_shuffle=%d%s\n", 808 torture_type, disable_onoff_at_boot, ftrace_dump_at_shutdown, verbose_sleep_frequency, verbose_sleep_duration, random_shuffle, 809 rcu_inkernel_boot_has_ended() ? "" : " still booting"); 810 } 811 812 /* 813 * Initialize torture module. Please note that this is -not- invoked via 814 * the usual module_init() mechanism, but rather by an explicit call from 815 * the client torture module. This call must be paired with a later 816 * torture_init_end(). 817 * 818 * The runnable parameter points to a flag that controls whether or not 819 * the test is currently runnable. If there is no such flag, pass in NULL. 820 */ 821 bool torture_init_begin(char *ttype, int v) 822 { 823 mutex_lock(&fullstop_mutex); 824 if (torture_type != NULL) { 825 pr_alert("%s: Refusing %s init: %s running.\n", 826 __func__, ttype, torture_type); 827 pr_alert("%s: One torture test at a time!\n", __func__); 828 mutex_unlock(&fullstop_mutex); 829 return false; 830 } 831 torture_type = ttype; 832 verbose = v; 833 fullstop = FULLSTOP_DONTSTOP; 834 WRITE_ONCE(torture_init_jiffies, jiffies); // Lockless reads. 835 torture_print_module_parms(); 836 return true; 837 } 838 EXPORT_SYMBOL_GPL(torture_init_begin); 839 840 /* 841 * Tell the torture module that initialization is complete. 842 */ 843 void torture_init_end(void) 844 { 845 mutex_unlock(&fullstop_mutex); 846 register_reboot_notifier(&torture_shutdown_nb); 847 } 848 EXPORT_SYMBOL_GPL(torture_init_end); 849 850 /* 851 * Get the torture_init_begin()-time value of the jiffies counter. 852 */ 853 unsigned long get_torture_init_jiffies(void) 854 { 855 return READ_ONCE(torture_init_jiffies); 856 } 857 EXPORT_SYMBOL_GPL(get_torture_init_jiffies); 858 859 /* 860 * Clean up torture module. Please note that this is -not- invoked via 861 * the usual module_exit() mechanism, but rather by an explicit call from 862 * the client torture module. Returns true if a race with system shutdown 863 * is detected, otherwise, all kthreads started by functions in this file 864 * will be shut down. 865 * 866 * This must be called before the caller starts shutting down its own 867 * kthreads. 868 * 869 * Both torture_cleanup_begin() and torture_cleanup_end() must be paired, 870 * in order to correctly perform the cleanup. They are separated because 871 * threads can still need to reference the torture_type type, thus nullify 872 * only after completing all other relevant calls. 873 */ 874 bool torture_cleanup_begin(void) 875 { 876 mutex_lock(&fullstop_mutex); 877 if (READ_ONCE(fullstop) == FULLSTOP_SHUTDOWN) { 878 pr_warn("Concurrent rmmod and shutdown illegal!\n"); 879 mutex_unlock(&fullstop_mutex); 880 schedule_timeout_uninterruptible(10); 881 return true; 882 } 883 WRITE_ONCE(fullstop, FULLSTOP_RMMOD); 884 mutex_unlock(&fullstop_mutex); 885 torture_shutdown_cleanup(); 886 torture_shuffle_cleanup(); 887 torture_stutter_cleanup(); 888 torture_onoff_cleanup(); 889 return false; 890 } 891 EXPORT_SYMBOL_GPL(torture_cleanup_begin); 892 893 void torture_cleanup_end(void) 894 { 895 mutex_lock(&fullstop_mutex); 896 torture_type = NULL; 897 mutex_unlock(&fullstop_mutex); 898 } 899 EXPORT_SYMBOL_GPL(torture_cleanup_end); 900 901 /* 902 * Is it time for the current torture test to stop? 903 */ 904 bool torture_must_stop(void) 905 { 906 return torture_must_stop_irq() || kthread_should_stop(); 907 } 908 EXPORT_SYMBOL_GPL(torture_must_stop); 909 910 /* 911 * Is it time for the current torture test to stop? This is the irq-safe 912 * version, hence no check for kthread_should_stop(). 913 */ 914 bool torture_must_stop_irq(void) 915 { 916 return READ_ONCE(fullstop) != FULLSTOP_DONTSTOP; 917 } 918 EXPORT_SYMBOL_GPL(torture_must_stop_irq); 919 920 /* 921 * Each kthread must wait for kthread_should_stop() before returning from 922 * its top-level function, otherwise segfaults ensue. This function 923 * prints a "stopping" message and waits for kthread_should_stop(), and 924 * should be called from all torture kthreads immediately prior to 925 * returning. 926 */ 927 void torture_kthread_stopping(char *title) 928 { 929 char buf[128]; 930 931 snprintf(buf, sizeof(buf), "%s is stopping", title); 932 VERBOSE_TOROUT_STRING(buf); 933 while (!kthread_should_stop()) { 934 torture_shutdown_absorb(title); 935 schedule_timeout_uninterruptible(HZ / 20); 936 } 937 } 938 EXPORT_SYMBOL_GPL(torture_kthread_stopping); 939 940 /* 941 * Create a generic torture kthread that is immediately runnable. If you 942 * need the kthread to be stopped so that you can do something to it before 943 * it starts, you will need to open-code your own. 944 */ 945 int _torture_create_kthread(int (*fn)(void *arg), void *arg, char *s, char *m, 946 char *f, struct task_struct **tp, void (*cbf)(struct task_struct *tp)) 947 { 948 int ret = 0; 949 950 VERBOSE_TOROUT_STRING(m); 951 *tp = kthread_create(fn, arg, "%s", s); 952 if (IS_ERR(*tp)) { 953 ret = PTR_ERR(*tp); 954 TOROUT_ERRSTRING(f); 955 *tp = NULL; 956 return ret; 957 } 958 959 if (cbf) 960 cbf(*tp); 961 962 wake_up_process(*tp); // Process is sleeping, so ordering provided. 963 torture_shuffle_task_register(*tp); 964 return ret; 965 } 966 EXPORT_SYMBOL_GPL(_torture_create_kthread); 967 968 /* 969 * Stop a generic kthread, emitting a message. 970 */ 971 void _torture_stop_kthread(char *m, struct task_struct **tp) 972 { 973 if (*tp == NULL) 974 return; 975 VERBOSE_TOROUT_STRING(m); 976 kthread_stop(*tp); 977 *tp = NULL; 978 } 979 EXPORT_SYMBOL_GPL(_torture_stop_kthread); 980 981 /* 982 * Set the specified task's niceness value, saturating at limits. 983 * Saturating noisily, but saturating. 984 */ 985 void torture_sched_set_normal(struct task_struct *t, int nice) 986 { 987 int realnice = nice; 988 989 if (WARN_ON_ONCE(realnice > MAX_NICE)) 990 realnice = MAX_NICE; 991 if (WARN_ON_ONCE(realnice < MIN_NICE)) 992 realnice = MIN_NICE; 993 sched_set_normal(t, realnice); 994 } 995 EXPORT_SYMBOL_GPL(torture_sched_set_normal); 996