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