kernel/torture.c

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