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 "rcu/rcu.h" 41 42 MODULE_LICENSE("GPL"); 43 MODULE_AUTHOR("Paul E. McKenney <paulmck@linux.ibm.com>"); 44 45 static char *torture_type; 46 static int verbose; 47 48 /* Mediate rmmod and system shutdown. Concurrent rmmod & shutdown illegal! */ 49 #define FULLSTOP_DONTSTOP 0 /* Normal operation. */ 50 #define FULLSTOP_SHUTDOWN 1 /* System shutdown with torture running. */ 51 #define FULLSTOP_RMMOD 2 /* Normal rmmod of torture. */ 52 static int fullstop = FULLSTOP_RMMOD; 53 static DEFINE_MUTEX(fullstop_mutex); 54 55 #ifdef CONFIG_HOTPLUG_CPU 56 57 /* 58 * Variables for online-offline handling. Only present if CPU hotplug 59 * is enabled, otherwise does nothing. 60 */ 61 62 static struct task_struct *onoff_task; 63 static long onoff_holdoff; 64 static long onoff_interval; 65 static torture_ofl_func *onoff_f; 66 static long n_offline_attempts; 67 static long n_offline_successes; 68 static unsigned long sum_offline; 69 static int min_offline = -1; 70 static int max_offline; 71 static long n_online_attempts; 72 static long n_online_successes; 73 static unsigned long sum_online; 74 static int min_online = -1; 75 static int max_online; 76 77 /* 78 * Attempt to take a CPU offline. Return false if the CPU is already 79 * offline or if it is not subject to CPU-hotplug operations. The 80 * caller can detect other failures by looking at the statistics. 81 */ 82 bool torture_offline(int cpu, long *n_offl_attempts, long *n_offl_successes, 83 unsigned long *sum_offl, int *min_offl, int *max_offl) 84 { 85 unsigned long delta; 86 int ret; 87 unsigned long starttime; 88 89 if (!cpu_online(cpu) || !cpu_is_hotpluggable(cpu)) 90 return false; 91 92 if (verbose > 1) 93 pr_alert("%s" TORTURE_FLAG 94 "torture_onoff task: offlining %d\n", 95 torture_type, cpu); 96 starttime = jiffies; 97 (*n_offl_attempts)++; 98 ret = cpu_down(cpu); 99 if (ret) { 100 if (verbose) 101 pr_alert("%s" TORTURE_FLAG 102 "torture_onoff task: offline %d failed: errno %d\n", 103 torture_type, cpu, ret); 104 } else { 105 if (verbose > 1) 106 pr_alert("%s" TORTURE_FLAG 107 "torture_onoff task: offlined %d\n", 108 torture_type, cpu); 109 if (onoff_f) 110 onoff_f(); 111 (*n_offl_successes)++; 112 delta = jiffies - starttime; 113 *sum_offl += delta; 114 if (*min_offl < 0) { 115 *min_offl = delta; 116 *max_offl = delta; 117 } 118 if (*min_offl > delta) 119 *min_offl = delta; 120 if (*max_offl < delta) 121 *max_offl = delta; 122 } 123 124 return true; 125 } 126 EXPORT_SYMBOL_GPL(torture_offline); 127 128 /* 129 * Attempt to bring a CPU online. Return false if the CPU is already 130 * online or if it is not subject to CPU-hotplug operations. The 131 * caller can detect other failures by looking at the statistics. 132 */ 133 bool torture_online(int cpu, long *n_onl_attempts, long *n_onl_successes, 134 unsigned long *sum_onl, int *min_onl, int *max_onl) 135 { 136 unsigned long delta; 137 int ret; 138 unsigned long starttime; 139 140 if (cpu_online(cpu) || !cpu_is_hotpluggable(cpu)) 141 return false; 142 143 if (verbose > 1) 144 pr_alert("%s" TORTURE_FLAG 145 "torture_onoff task: onlining %d\n", 146 torture_type, cpu); 147 starttime = jiffies; 148 (*n_onl_attempts)++; 149 ret = cpu_up(cpu); 150 if (ret) { 151 if (verbose) 152 pr_alert("%s" TORTURE_FLAG 153 "torture_onoff task: online %d failed: errno %d\n", 154 torture_type, cpu, ret); 155 } else { 156 if (verbose > 1) 157 pr_alert("%s" TORTURE_FLAG 158 "torture_onoff task: onlined %d\n", 159 torture_type, cpu); 160 (*n_onl_successes)++; 161 delta = jiffies - starttime; 162 *sum_onl += delta; 163 if (*min_onl < 0) { 164 *min_onl = delta; 165 *max_onl = delta; 166 } 167 if (*min_onl > delta) 168 *min_onl = delta; 169 if (*max_onl < delta) 170 *max_onl = delta; 171 } 172 173 return true; 174 } 175 EXPORT_SYMBOL_GPL(torture_online); 176 177 /* 178 * Execute random CPU-hotplug operations at the interval specified 179 * by the onoff_interval. 180 */ 181 static int 182 torture_onoff(void *arg) 183 { 184 int cpu; 185 int maxcpu = -1; 186 DEFINE_TORTURE_RANDOM(rand); 187 int ret; 188 189 VERBOSE_TOROUT_STRING("torture_onoff task started"); 190 for_each_online_cpu(cpu) 191 maxcpu = cpu; 192 WARN_ON(maxcpu < 0); 193 if (!IS_MODULE(CONFIG_TORTURE_TEST)) 194 for_each_possible_cpu(cpu) { 195 if (cpu_online(cpu)) 196 continue; 197 ret = cpu_up(cpu); 198 if (ret && verbose) { 199 pr_alert("%s" TORTURE_FLAG 200 "%s: Initial online %d: errno %d\n", 201 __func__, torture_type, cpu, ret); 202 } 203 } 204 205 if (maxcpu == 0) { 206 VERBOSE_TOROUT_STRING("Only one CPU, so CPU-hotplug testing is disabled"); 207 goto stop; 208 } 209 210 if (onoff_holdoff > 0) { 211 VERBOSE_TOROUT_STRING("torture_onoff begin holdoff"); 212 schedule_timeout_interruptible(onoff_holdoff); 213 VERBOSE_TOROUT_STRING("torture_onoff end holdoff"); 214 } 215 while (!torture_must_stop()) { 216 cpu = (torture_random(&rand) >> 4) % (maxcpu + 1); 217 if (!torture_offline(cpu, 218 &n_offline_attempts, &n_offline_successes, 219 &sum_offline, &min_offline, &max_offline)) 220 torture_online(cpu, 221 &n_online_attempts, &n_online_successes, 222 &sum_online, &min_online, &max_online); 223 schedule_timeout_interruptible(onoff_interval); 224 } 225 226 stop: 227 torture_kthread_stopping("torture_onoff"); 228 return 0; 229 } 230 231 #endif /* #ifdef CONFIG_HOTPLUG_CPU */ 232 233 /* 234 * Initiate online-offline handling. 235 */ 236 int torture_onoff_init(long ooholdoff, long oointerval, torture_ofl_func *f) 237 { 238 #ifdef CONFIG_HOTPLUG_CPU 239 onoff_holdoff = ooholdoff; 240 onoff_interval = oointerval; 241 onoff_f = f; 242 if (onoff_interval <= 0) 243 return 0; 244 return torture_create_kthread(torture_onoff, NULL, onoff_task); 245 #else /* #ifdef CONFIG_HOTPLUG_CPU */ 246 return 0; 247 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */ 248 } 249 EXPORT_SYMBOL_GPL(torture_onoff_init); 250 251 /* 252 * Clean up after online/offline testing. 253 */ 254 static void torture_onoff_cleanup(void) 255 { 256 #ifdef CONFIG_HOTPLUG_CPU 257 if (onoff_task == NULL) 258 return; 259 VERBOSE_TOROUT_STRING("Stopping torture_onoff task"); 260 kthread_stop(onoff_task); 261 onoff_task = NULL; 262 #endif /* #ifdef CONFIG_HOTPLUG_CPU */ 263 } 264 EXPORT_SYMBOL_GPL(torture_onoff_cleanup); 265 266 /* 267 * Print online/offline testing statistics. 268 */ 269 void torture_onoff_stats(void) 270 { 271 #ifdef CONFIG_HOTPLUG_CPU 272 pr_cont("onoff: %ld/%ld:%ld/%ld %d,%d:%d,%d %lu:%lu (HZ=%d) ", 273 n_online_successes, n_online_attempts, 274 n_offline_successes, n_offline_attempts, 275 min_online, max_online, 276 min_offline, max_offline, 277 sum_online, sum_offline, HZ); 278 #endif /* #ifdef CONFIG_HOTPLUG_CPU */ 279 } 280 EXPORT_SYMBOL_GPL(torture_onoff_stats); 281 282 /* 283 * Were all the online/offline operations successful? 284 */ 285 bool torture_onoff_failures(void) 286 { 287 #ifdef CONFIG_HOTPLUG_CPU 288 return n_online_successes != n_online_attempts || 289 n_offline_successes != n_offline_attempts; 290 #else /* #ifdef CONFIG_HOTPLUG_CPU */ 291 return false; 292 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */ 293 } 294 EXPORT_SYMBOL_GPL(torture_onoff_failures); 295 296 #define TORTURE_RANDOM_MULT 39916801 /* prime */ 297 #define TORTURE_RANDOM_ADD 479001701 /* prime */ 298 #define TORTURE_RANDOM_REFRESH 10000 299 300 /* 301 * Crude but fast random-number generator. Uses a linear congruential 302 * generator, with occasional help from cpu_clock(). 303 */ 304 unsigned long 305 torture_random(struct torture_random_state *trsp) 306 { 307 if (--trsp->trs_count < 0) { 308 trsp->trs_state += (unsigned long)local_clock(); 309 trsp->trs_count = TORTURE_RANDOM_REFRESH; 310 } 311 trsp->trs_state = trsp->trs_state * TORTURE_RANDOM_MULT + 312 TORTURE_RANDOM_ADD; 313 return swahw32(trsp->trs_state); 314 } 315 EXPORT_SYMBOL_GPL(torture_random); 316 317 /* 318 * Variables for shuffling. The idea is to ensure that each CPU stays 319 * idle for an extended period to test interactions with dyntick idle, 320 * as well as interactions with any per-CPU variables. 321 */ 322 struct shuffle_task { 323 struct list_head st_l; 324 struct task_struct *st_t; 325 }; 326 327 static long shuffle_interval; /* In jiffies. */ 328 static struct task_struct *shuffler_task; 329 static cpumask_var_t shuffle_tmp_mask; 330 static int shuffle_idle_cpu; /* Force all torture tasks off this CPU */ 331 static struct list_head shuffle_task_list = LIST_HEAD_INIT(shuffle_task_list); 332 static DEFINE_MUTEX(shuffle_task_mutex); 333 334 /* 335 * Register a task to be shuffled. If there is no memory, just splat 336 * and don't bother registering. 337 */ 338 void torture_shuffle_task_register(struct task_struct *tp) 339 { 340 struct shuffle_task *stp; 341 342 if (WARN_ON_ONCE(tp == NULL)) 343 return; 344 stp = kmalloc(sizeof(*stp), GFP_KERNEL); 345 if (WARN_ON_ONCE(stp == NULL)) 346 return; 347 stp->st_t = tp; 348 mutex_lock(&shuffle_task_mutex); 349 list_add(&stp->st_l, &shuffle_task_list); 350 mutex_unlock(&shuffle_task_mutex); 351 } 352 EXPORT_SYMBOL_GPL(torture_shuffle_task_register); 353 354 /* 355 * Unregister all tasks, for example, at the end of the torture run. 356 */ 357 static void torture_shuffle_task_unregister_all(void) 358 { 359 struct shuffle_task *stp; 360 struct shuffle_task *p; 361 362 mutex_lock(&shuffle_task_mutex); 363 list_for_each_entry_safe(stp, p, &shuffle_task_list, st_l) { 364 list_del(&stp->st_l); 365 kfree(stp); 366 } 367 mutex_unlock(&shuffle_task_mutex); 368 } 369 370 /* Shuffle tasks such that we allow shuffle_idle_cpu to become idle. 371 * A special case is when shuffle_idle_cpu = -1, in which case we allow 372 * the tasks to run on all CPUs. 373 */ 374 static void torture_shuffle_tasks(void) 375 { 376 struct shuffle_task *stp; 377 378 cpumask_setall(shuffle_tmp_mask); 379 get_online_cpus(); 380 381 /* No point in shuffling if there is only one online CPU (ex: UP) */ 382 if (num_online_cpus() == 1) { 383 put_online_cpus(); 384 return; 385 } 386 387 /* Advance to the next CPU. Upon overflow, don't idle any CPUs. */ 388 shuffle_idle_cpu = cpumask_next(shuffle_idle_cpu, shuffle_tmp_mask); 389 if (shuffle_idle_cpu >= nr_cpu_ids) 390 shuffle_idle_cpu = -1; 391 else 392 cpumask_clear_cpu(shuffle_idle_cpu, shuffle_tmp_mask); 393 394 mutex_lock(&shuffle_task_mutex); 395 list_for_each_entry(stp, &shuffle_task_list, st_l) 396 set_cpus_allowed_ptr(stp->st_t, shuffle_tmp_mask); 397 mutex_unlock(&shuffle_task_mutex); 398 399 put_online_cpus(); 400 } 401 402 /* Shuffle tasks across CPUs, with the intent of allowing each CPU in the 403 * system to become idle at a time and cut off its timer ticks. This is meant 404 * to test the support for such tickless idle CPU in RCU. 405 */ 406 static int torture_shuffle(void *arg) 407 { 408 VERBOSE_TOROUT_STRING("torture_shuffle task started"); 409 do { 410 schedule_timeout_interruptible(shuffle_interval); 411 torture_shuffle_tasks(); 412 torture_shutdown_absorb("torture_shuffle"); 413 } while (!torture_must_stop()); 414 torture_kthread_stopping("torture_shuffle"); 415 return 0; 416 } 417 418 /* 419 * Start the shuffler, with shuffint in jiffies. 420 */ 421 int torture_shuffle_init(long shuffint) 422 { 423 shuffle_interval = shuffint; 424 425 shuffle_idle_cpu = -1; 426 427 if (!alloc_cpumask_var(&shuffle_tmp_mask, GFP_KERNEL)) { 428 VERBOSE_TOROUT_ERRSTRING("Failed to alloc mask"); 429 return -ENOMEM; 430 } 431 432 /* Create the shuffler thread */ 433 return torture_create_kthread(torture_shuffle, NULL, shuffler_task); 434 } 435 EXPORT_SYMBOL_GPL(torture_shuffle_init); 436 437 /* 438 * Stop the shuffling. 439 */ 440 static void torture_shuffle_cleanup(void) 441 { 442 torture_shuffle_task_unregister_all(); 443 if (shuffler_task) { 444 VERBOSE_TOROUT_STRING("Stopping torture_shuffle task"); 445 kthread_stop(shuffler_task); 446 free_cpumask_var(shuffle_tmp_mask); 447 } 448 shuffler_task = NULL; 449 } 450 EXPORT_SYMBOL_GPL(torture_shuffle_cleanup); 451 452 /* 453 * Variables for auto-shutdown. This allows "lights out" torture runs 454 * to be fully scripted. 455 */ 456 static struct task_struct *shutdown_task; 457 static ktime_t shutdown_time; /* time to system shutdown. */ 458 static void (*torture_shutdown_hook)(void); 459 460 /* 461 * Absorb kthreads into a kernel function that won't return, so that 462 * they won't ever access module text or data again. 463 */ 464 void torture_shutdown_absorb(const char *title) 465 { 466 while (READ_ONCE(fullstop) == FULLSTOP_SHUTDOWN) { 467 pr_notice("torture thread %s parking due to system shutdown\n", 468 title); 469 schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT); 470 } 471 } 472 EXPORT_SYMBOL_GPL(torture_shutdown_absorb); 473 474 /* 475 * Cause the torture test to shutdown the system after the test has 476 * run for the time specified by the shutdown_secs parameter. 477 */ 478 static int torture_shutdown(void *arg) 479 { 480 ktime_t ktime_snap; 481 482 VERBOSE_TOROUT_STRING("torture_shutdown task started"); 483 ktime_snap = ktime_get(); 484 while (ktime_before(ktime_snap, shutdown_time) && 485 !torture_must_stop()) { 486 if (verbose) 487 pr_alert("%s" TORTURE_FLAG 488 "torture_shutdown task: %llu ms remaining\n", 489 torture_type, 490 ktime_ms_delta(shutdown_time, ktime_snap)); 491 set_current_state(TASK_INTERRUPTIBLE); 492 schedule_hrtimeout(&shutdown_time, HRTIMER_MODE_ABS); 493 ktime_snap = ktime_get(); 494 } 495 if (torture_must_stop()) { 496 torture_kthread_stopping("torture_shutdown"); 497 return 0; 498 } 499 500 /* OK, shut down the system. */ 501 502 VERBOSE_TOROUT_STRING("torture_shutdown task shutting down system"); 503 shutdown_task = NULL; /* Avoid self-kill deadlock. */ 504 if (torture_shutdown_hook) 505 torture_shutdown_hook(); 506 else 507 VERBOSE_TOROUT_STRING("No torture_shutdown_hook(), skipping."); 508 rcu_ftrace_dump(DUMP_ALL); 509 kernel_power_off(); /* Shut down the system. */ 510 return 0; 511 } 512 513 /* 514 * Start up the shutdown task. 515 */ 516 int torture_shutdown_init(int ssecs, void (*cleanup)(void)) 517 { 518 torture_shutdown_hook = cleanup; 519 if (ssecs > 0) { 520 shutdown_time = ktime_add(ktime_get(), ktime_set(ssecs, 0)); 521 return torture_create_kthread(torture_shutdown, NULL, 522 shutdown_task); 523 } 524 return 0; 525 } 526 EXPORT_SYMBOL_GPL(torture_shutdown_init); 527 528 /* 529 * Detect and respond to a system shutdown. 530 */ 531 static int torture_shutdown_notify(struct notifier_block *unused1, 532 unsigned long unused2, void *unused3) 533 { 534 mutex_lock(&fullstop_mutex); 535 if (READ_ONCE(fullstop) == FULLSTOP_DONTSTOP) { 536 VERBOSE_TOROUT_STRING("Unscheduled system shutdown detected"); 537 WRITE_ONCE(fullstop, FULLSTOP_SHUTDOWN); 538 } else { 539 pr_warn("Concurrent rmmod and shutdown illegal!\n"); 540 } 541 mutex_unlock(&fullstop_mutex); 542 return NOTIFY_DONE; 543 } 544 545 static struct notifier_block torture_shutdown_nb = { 546 .notifier_call = torture_shutdown_notify, 547 }; 548 549 /* 550 * Shut down the shutdown task. Say what??? Heh! This can happen if 551 * the torture module gets an rmmod before the shutdown time arrives. ;-) 552 */ 553 static void torture_shutdown_cleanup(void) 554 { 555 unregister_reboot_notifier(&torture_shutdown_nb); 556 if (shutdown_task != NULL) { 557 VERBOSE_TOROUT_STRING("Stopping torture_shutdown task"); 558 kthread_stop(shutdown_task); 559 } 560 shutdown_task = NULL; 561 } 562 563 /* 564 * Variables for stuttering, which means to periodically pause and 565 * restart testing in order to catch bugs that appear when load is 566 * suddenly applied to or removed from the system. 567 */ 568 static struct task_struct *stutter_task; 569 static int stutter_pause_test; 570 static int stutter; 571 572 /* 573 * Block until the stutter interval ends. This must be called periodically 574 * by all running kthreads that need to be subject to stuttering. 575 */ 576 bool stutter_wait(const char *title) 577 { 578 int spt; 579 580 cond_resched_tasks_rcu_qs(); 581 spt = READ_ONCE(stutter_pause_test); 582 for (; spt; spt = READ_ONCE(stutter_pause_test)) { 583 if (spt == 1) { 584 schedule_timeout_interruptible(1); 585 } else if (spt == 2) { 586 while (READ_ONCE(stutter_pause_test)) 587 cond_resched(); 588 } else { 589 schedule_timeout_interruptible(round_jiffies_relative(HZ)); 590 } 591 torture_shutdown_absorb(title); 592 } 593 return !!spt; 594 } 595 EXPORT_SYMBOL_GPL(stutter_wait); 596 597 /* 598 * Cause the torture test to "stutter", starting and stopping all 599 * threads periodically. 600 */ 601 static int torture_stutter(void *arg) 602 { 603 VERBOSE_TOROUT_STRING("torture_stutter task started"); 604 do { 605 if (!torture_must_stop() && stutter > 1) { 606 WRITE_ONCE(stutter_pause_test, 1); 607 schedule_timeout_interruptible(stutter - 1); 608 WRITE_ONCE(stutter_pause_test, 2); 609 schedule_timeout_interruptible(1); 610 } 611 WRITE_ONCE(stutter_pause_test, 0); 612 if (!torture_must_stop()) 613 schedule_timeout_interruptible(stutter); 614 torture_shutdown_absorb("torture_stutter"); 615 } while (!torture_must_stop()); 616 torture_kthread_stopping("torture_stutter"); 617 return 0; 618 } 619 620 /* 621 * Initialize and kick off the torture_stutter kthread. 622 */ 623 int torture_stutter_init(const int s) 624 { 625 stutter = s; 626 return torture_create_kthread(torture_stutter, NULL, stutter_task); 627 } 628 EXPORT_SYMBOL_GPL(torture_stutter_init); 629 630 /* 631 * Cleanup after the torture_stutter kthread. 632 */ 633 static void torture_stutter_cleanup(void) 634 { 635 if (!stutter_task) 636 return; 637 VERBOSE_TOROUT_STRING("Stopping torture_stutter task"); 638 kthread_stop(stutter_task); 639 stutter_task = NULL; 640 } 641 642 /* 643 * Initialize torture module. Please note that this is -not- invoked via 644 * the usual module_init() mechanism, but rather by an explicit call from 645 * the client torture module. This call must be paired with a later 646 * torture_init_end(). 647 * 648 * The runnable parameter points to a flag that controls whether or not 649 * the test is currently runnable. If there is no such flag, pass in NULL. 650 */ 651 bool torture_init_begin(char *ttype, int v) 652 { 653 mutex_lock(&fullstop_mutex); 654 if (torture_type != NULL) { 655 pr_alert("torture_init_begin: Refusing %s init: %s running.\n", 656 ttype, torture_type); 657 pr_alert("torture_init_begin: One torture test at a time!\n"); 658 mutex_unlock(&fullstop_mutex); 659 return false; 660 } 661 torture_type = ttype; 662 verbose = v; 663 fullstop = FULLSTOP_DONTSTOP; 664 return true; 665 } 666 EXPORT_SYMBOL_GPL(torture_init_begin); 667 668 /* 669 * Tell the torture module that initialization is complete. 670 */ 671 void torture_init_end(void) 672 { 673 mutex_unlock(&fullstop_mutex); 674 register_reboot_notifier(&torture_shutdown_nb); 675 } 676 EXPORT_SYMBOL_GPL(torture_init_end); 677 678 /* 679 * Clean up torture module. Please note that this is -not- invoked via 680 * the usual module_exit() mechanism, but rather by an explicit call from 681 * the client torture module. Returns true if a race with system shutdown 682 * is detected, otherwise, all kthreads started by functions in this file 683 * will be shut down. 684 * 685 * This must be called before the caller starts shutting down its own 686 * kthreads. 687 * 688 * Both torture_cleanup_begin() and torture_cleanup_end() must be paired, 689 * in order to correctly perform the cleanup. They are separated because 690 * threads can still need to reference the torture_type type, thus nullify 691 * only after completing all other relevant calls. 692 */ 693 bool torture_cleanup_begin(void) 694 { 695 mutex_lock(&fullstop_mutex); 696 if (READ_ONCE(fullstop) == FULLSTOP_SHUTDOWN) { 697 pr_warn("Concurrent rmmod and shutdown illegal!\n"); 698 mutex_unlock(&fullstop_mutex); 699 schedule_timeout_uninterruptible(10); 700 return true; 701 } 702 WRITE_ONCE(fullstop, FULLSTOP_RMMOD); 703 mutex_unlock(&fullstop_mutex); 704 torture_shutdown_cleanup(); 705 torture_shuffle_cleanup(); 706 torture_stutter_cleanup(); 707 torture_onoff_cleanup(); 708 return false; 709 } 710 EXPORT_SYMBOL_GPL(torture_cleanup_begin); 711 712 void torture_cleanup_end(void) 713 { 714 mutex_lock(&fullstop_mutex); 715 torture_type = NULL; 716 mutex_unlock(&fullstop_mutex); 717 } 718 EXPORT_SYMBOL_GPL(torture_cleanup_end); 719 720 /* 721 * Is it time for the current torture test to stop? 722 */ 723 bool torture_must_stop(void) 724 { 725 return torture_must_stop_irq() || kthread_should_stop(); 726 } 727 EXPORT_SYMBOL_GPL(torture_must_stop); 728 729 /* 730 * Is it time for the current torture test to stop? This is the irq-safe 731 * version, hence no check for kthread_should_stop(). 732 */ 733 bool torture_must_stop_irq(void) 734 { 735 return READ_ONCE(fullstop) != FULLSTOP_DONTSTOP; 736 } 737 EXPORT_SYMBOL_GPL(torture_must_stop_irq); 738 739 /* 740 * Each kthread must wait for kthread_should_stop() before returning from 741 * its top-level function, otherwise segfaults ensue. This function 742 * prints a "stopping" message and waits for kthread_should_stop(), and 743 * should be called from all torture kthreads immediately prior to 744 * returning. 745 */ 746 void torture_kthread_stopping(char *title) 747 { 748 char buf[128]; 749 750 snprintf(buf, sizeof(buf), "Stopping %s", title); 751 VERBOSE_TOROUT_STRING(buf); 752 while (!kthread_should_stop()) { 753 torture_shutdown_absorb(title); 754 schedule_timeout_uninterruptible(1); 755 } 756 } 757 EXPORT_SYMBOL_GPL(torture_kthread_stopping); 758 759 /* 760 * Create a generic torture kthread that is immediately runnable. If you 761 * need the kthread to be stopped so that you can do something to it before 762 * it starts, you will need to open-code your own. 763 */ 764 int _torture_create_kthread(int (*fn)(void *arg), void *arg, char *s, char *m, 765 char *f, struct task_struct **tp) 766 { 767 int ret = 0; 768 769 VERBOSE_TOROUT_STRING(m); 770 *tp = kthread_run(fn, arg, "%s", s); 771 if (IS_ERR(*tp)) { 772 ret = PTR_ERR(*tp); 773 VERBOSE_TOROUT_ERRSTRING(f); 774 *tp = NULL; 775 } 776 torture_shuffle_task_register(*tp); 777 return ret; 778 } 779 EXPORT_SYMBOL_GPL(_torture_create_kthread); 780 781 /* 782 * Stop a generic kthread, emitting a message. 783 */ 784 void _torture_stop_kthread(char *m, struct task_struct **tp) 785 { 786 if (*tp == NULL) 787 return; 788 VERBOSE_TOROUT_STRING(m); 789 kthread_stop(*tp); 790 *tp = NULL; 791 } 792 EXPORT_SYMBOL_GPL(_torture_stop_kthread); 793