1 // SPDX-License-Identifier: GPL-2.0+
3 * Common functions for in-kernel torture tests.
5 * Copyright (C) IBM Corporation, 2014
7 * Author: Paul E. McKenney <paulmck@linux.ibm.com>
8 * Based on kernel/rcu/torture.c.
11 #define pr_fmt(fmt) fmt
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>
43 MODULE_LICENSE("GPL");
44 MODULE_AUTHOR("Paul E. McKenney <paulmck@linux.ibm.com>");
46 static bool disable_onoff_at_boot
;
47 module_param(disable_onoff_at_boot
, bool, 0444);
49 static bool ftrace_dump_at_shutdown
;
50 module_param(ftrace_dump_at_shutdown
, bool, 0444);
52 static int verbose_sleep_frequency
;
53 module_param(verbose_sleep_frequency
, int, 0444);
55 static int verbose_sleep_duration
= 1;
56 module_param(verbose_sleep_duration
, int, 0444);
58 static int random_shuffle
;
59 module_param(random_shuffle
, int, 0444);
61 static char *torture_type
;
64 /* Mediate rmmod and system shutdown. Concurrent rmmod & shutdown illegal! */
65 #define FULLSTOP_DONTSTOP 0 /* Normal operation. */
66 #define FULLSTOP_SHUTDOWN 1 /* System shutdown with torture running. */
67 #define FULLSTOP_RMMOD 2 /* Normal rmmod of torture. */
68 static int fullstop
= FULLSTOP_RMMOD
;
69 static DEFINE_MUTEX(fullstop_mutex
);
71 static atomic_t verbose_sleep_counter
;
74 * Sleep if needed from VERBOSE_TOROUT*().
76 void verbose_torout_sleep(void)
78 if (verbose_sleep_frequency
> 0 &&
79 verbose_sleep_duration
> 0 &&
80 !(atomic_inc_return(&verbose_sleep_counter
) % verbose_sleep_frequency
))
81 schedule_timeout_uninterruptible(verbose_sleep_duration
);
83 EXPORT_SYMBOL_GPL(verbose_torout_sleep
);
86 * Schedule a high-resolution-timer sleep in nanoseconds, with a 32-bit
87 * nanosecond random fuzz. This function and its friends desynchronize
88 * testing from the timer wheel.
90 int torture_hrtimeout_ns(ktime_t baset_ns
, u32 fuzzt_ns
, const enum hrtimer_mode mode
,
91 struct torture_random_state
*trsp
)
93 ktime_t hto
= baset_ns
;
96 hto
+= torture_random(trsp
) % fuzzt_ns
;
97 set_current_state(TASK_IDLE
);
98 return schedule_hrtimeout(&hto
, mode
);
100 EXPORT_SYMBOL_GPL(torture_hrtimeout_ns
);
103 * Schedule a high-resolution-timer sleep in microseconds, with a 32-bit
104 * nanosecond (not microsecond!) random fuzz.
106 int torture_hrtimeout_us(u32 baset_us
, u32 fuzzt_ns
, struct torture_random_state
*trsp
)
108 ktime_t baset_ns
= baset_us
* NSEC_PER_USEC
;
110 return torture_hrtimeout_ns(baset_ns
, fuzzt_ns
, HRTIMER_MODE_REL
, trsp
);
112 EXPORT_SYMBOL_GPL(torture_hrtimeout_us
);
115 * Schedule a high-resolution-timer sleep in milliseconds, with a 32-bit
116 * microsecond (not millisecond!) random fuzz.
118 int torture_hrtimeout_ms(u32 baset_ms
, u32 fuzzt_us
, struct torture_random_state
*trsp
)
120 ktime_t baset_ns
= baset_ms
* NSEC_PER_MSEC
;
123 if ((u32
)~0U / NSEC_PER_USEC
< fuzzt_us
)
126 fuzzt_ns
= fuzzt_us
* NSEC_PER_USEC
;
127 return torture_hrtimeout_ns(baset_ns
, fuzzt_ns
, HRTIMER_MODE_REL
, trsp
);
129 EXPORT_SYMBOL_GPL(torture_hrtimeout_ms
);
132 * Schedule a high-resolution-timer sleep in jiffies, with an
133 * implied one-jiffy random fuzz. This is intended to replace calls to
134 * schedule_timeout_interruptible() and friends.
136 int torture_hrtimeout_jiffies(u32 baset_j
, struct torture_random_state
*trsp
)
138 ktime_t baset_ns
= jiffies_to_nsecs(baset_j
);
140 return torture_hrtimeout_ns(baset_ns
, jiffies_to_nsecs(1), HRTIMER_MODE_REL
, trsp
);
142 EXPORT_SYMBOL_GPL(torture_hrtimeout_jiffies
);
145 * Schedule a high-resolution-timer sleep in milliseconds, with a 32-bit
146 * millisecond (not second!) random fuzz.
148 int torture_hrtimeout_s(u32 baset_s
, u32 fuzzt_ms
, struct torture_random_state
*trsp
)
150 ktime_t baset_ns
= baset_s
* NSEC_PER_SEC
;
153 if ((u32
)~0U / NSEC_PER_MSEC
< fuzzt_ms
)
156 fuzzt_ns
= fuzzt_ms
* NSEC_PER_MSEC
;
157 return torture_hrtimeout_ns(baset_ns
, fuzzt_ns
, HRTIMER_MODE_REL
, trsp
);
159 EXPORT_SYMBOL_GPL(torture_hrtimeout_s
);
161 #ifdef CONFIG_HOTPLUG_CPU
164 * Variables for online-offline handling. Only present if CPU hotplug
165 * is enabled, otherwise does nothing.
168 static struct task_struct
*onoff_task
;
169 static long onoff_holdoff
;
170 static long onoff_interval
;
171 static torture_ofl_func
*onoff_f
;
172 static long n_offline_attempts
;
173 static long n_offline_successes
;
174 static unsigned long sum_offline
;
175 static int min_offline
= -1;
176 static int max_offline
;
177 static long n_online_attempts
;
178 static long n_online_successes
;
179 static unsigned long sum_online
;
180 static int min_online
= -1;
181 static int max_online
;
183 static int torture_online_cpus
= NR_CPUS
;
186 * Some torture testing leverages confusion as to the number of online
187 * CPUs. This function returns the torture-testing view of this number,
188 * which allows torture tests to load-balance appropriately.
190 int torture_num_online_cpus(void)
192 return READ_ONCE(torture_online_cpus
);
194 EXPORT_SYMBOL_GPL(torture_num_online_cpus
);
197 * Attempt to take a CPU offline. Return false if the CPU is already
198 * offline or if it is not subject to CPU-hotplug operations. The
199 * caller can detect other failures by looking at the statistics.
201 bool torture_offline(int cpu
, long *n_offl_attempts
, long *n_offl_successes
,
202 unsigned long *sum_offl
, int *min_offl
, int *max_offl
)
207 unsigned long starttime
;
209 if (!cpu_online(cpu
) || !cpu_is_hotpluggable(cpu
))
211 if (num_online_cpus() <= 1)
212 return false; /* Can't offline the last CPU. */
215 pr_alert("%s" TORTURE_FLAG
216 "torture_onoff task: offlining %d\n",
219 (*n_offl_attempts
)++;
220 ret
= remove_cpu(cpu
);
223 if (!rcu_inkernel_boot_has_ended() && ret
== -EBUSY
) {
224 // PCI probe frequently disables hotplug during boot.
225 (*n_offl_attempts
)--;
226 s
= " (-EBUSY forgiven during boot)";
229 pr_alert("%s" TORTURE_FLAG
230 "torture_onoff task: offline %d failed%s: errno %d\n",
231 torture_type
, cpu
, s
, ret
);
234 pr_alert("%s" TORTURE_FLAG
235 "torture_onoff task: offlined %d\n",
239 (*n_offl_successes
)++;
240 delta
= jiffies
- starttime
;
246 if (*min_offl
> delta
)
248 if (*max_offl
< delta
)
250 WRITE_ONCE(torture_online_cpus
, torture_online_cpus
- 1);
251 WARN_ON_ONCE(torture_online_cpus
<= 0);
256 EXPORT_SYMBOL_GPL(torture_offline
);
259 * Attempt to bring a CPU online. Return false if the CPU is already
260 * online or if it is not subject to CPU-hotplug operations. The
261 * caller can detect other failures by looking at the statistics.
263 bool torture_online(int cpu
, long *n_onl_attempts
, long *n_onl_successes
,
264 unsigned long *sum_onl
, int *min_onl
, int *max_onl
)
269 unsigned long starttime
;
271 if (cpu_online(cpu
) || !cpu_is_hotpluggable(cpu
))
275 pr_alert("%s" TORTURE_FLAG
276 "torture_onoff task: onlining %d\n",
283 if (!rcu_inkernel_boot_has_ended() && ret
== -EBUSY
) {
284 // PCI probe frequently disables hotplug during boot.
286 s
= " (-EBUSY forgiven during boot)";
289 pr_alert("%s" TORTURE_FLAG
290 "torture_onoff task: online %d failed%s: errno %d\n",
291 torture_type
, cpu
, s
, ret
);
294 pr_alert("%s" TORTURE_FLAG
295 "torture_onoff task: onlined %d\n",
297 (*n_onl_successes
)++;
298 delta
= jiffies
- starttime
;
304 if (*min_onl
> delta
)
306 if (*max_onl
< delta
)
308 WRITE_ONCE(torture_online_cpus
, torture_online_cpus
+ 1);
313 EXPORT_SYMBOL_GPL(torture_online
);
316 * Get everything online at the beginning and ends of tests.
318 static void torture_online_all(char *phase
)
323 for_each_possible_cpu(cpu
) {
327 if (ret
&& verbose
) {
328 pr_alert("%s" TORTURE_FLAG
329 "%s: %s online %d: errno %d\n",
330 __func__
, phase
, torture_type
, cpu
, ret
);
336 * Execute random CPU-hotplug operations at the interval specified
337 * by the onoff_interval.
340 torture_onoff(void *arg
)
344 DEFINE_TORTURE_RANDOM(rand
);
346 VERBOSE_TOROUT_STRING("torture_onoff task started");
347 for_each_online_cpu(cpu
)
350 torture_online_all("Initial");
352 VERBOSE_TOROUT_STRING("Only one CPU, so CPU-hotplug testing is disabled");
356 if (onoff_holdoff
> 0) {
357 VERBOSE_TOROUT_STRING("torture_onoff begin holdoff");
358 torture_hrtimeout_jiffies(onoff_holdoff
, &rand
);
359 VERBOSE_TOROUT_STRING("torture_onoff end holdoff");
361 while (!torture_must_stop()) {
362 if (disable_onoff_at_boot
&& !rcu_inkernel_boot_has_ended()) {
363 torture_hrtimeout_jiffies(HZ
/ 10, &rand
);
366 cpu
= torture_random(&rand
) % (maxcpu
+ 1);
367 if (!torture_offline(cpu
,
368 &n_offline_attempts
, &n_offline_successes
,
369 &sum_offline
, &min_offline
, &max_offline
))
371 &n_online_attempts
, &n_online_successes
,
372 &sum_online
, &min_online
, &max_online
);
373 torture_hrtimeout_jiffies(onoff_interval
, &rand
);
377 torture_kthread_stopping("torture_onoff");
378 torture_online_all("Final");
382 #endif /* #ifdef CONFIG_HOTPLUG_CPU */
385 * Initiate online-offline handling.
387 int torture_onoff_init(long ooholdoff
, long oointerval
, torture_ofl_func
*f
)
389 #ifdef CONFIG_HOTPLUG_CPU
390 onoff_holdoff
= ooholdoff
;
391 onoff_interval
= oointerval
;
393 if (onoff_interval
<= 0)
395 return torture_create_kthread(torture_onoff
, NULL
, onoff_task
);
396 #else /* #ifdef CONFIG_HOTPLUG_CPU */
398 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */
400 EXPORT_SYMBOL_GPL(torture_onoff_init
);
403 * Clean up after online/offline testing.
405 static void torture_onoff_cleanup(void)
407 #ifdef CONFIG_HOTPLUG_CPU
408 if (onoff_task
== NULL
)
410 VERBOSE_TOROUT_STRING("Stopping torture_onoff task");
411 kthread_stop(onoff_task
);
413 #endif /* #ifdef CONFIG_HOTPLUG_CPU */
417 * Print online/offline testing statistics.
419 void torture_onoff_stats(void)
421 #ifdef CONFIG_HOTPLUG_CPU
422 pr_cont("onoff: %ld/%ld:%ld/%ld %d,%d:%d,%d %lu:%lu (HZ=%d) ",
423 n_online_successes
, n_online_attempts
,
424 n_offline_successes
, n_offline_attempts
,
425 min_online
, max_online
,
426 min_offline
, max_offline
,
427 sum_online
, sum_offline
, HZ
);
428 #endif /* #ifdef CONFIG_HOTPLUG_CPU */
430 EXPORT_SYMBOL_GPL(torture_onoff_stats
);
433 * Were all the online/offline operations successful?
435 bool torture_onoff_failures(void)
437 #ifdef CONFIG_HOTPLUG_CPU
438 return n_online_successes
!= n_online_attempts
||
439 n_offline_successes
!= n_offline_attempts
;
440 #else /* #ifdef CONFIG_HOTPLUG_CPU */
442 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */
444 EXPORT_SYMBOL_GPL(torture_onoff_failures
);
446 #define TORTURE_RANDOM_MULT 39916801 /* prime */
447 #define TORTURE_RANDOM_ADD 479001701 /* prime */
448 #define TORTURE_RANDOM_REFRESH 10000
451 * Crude but fast random-number generator. Uses a linear congruential
452 * generator, with occasional help from cpu_clock().
455 torture_random(struct torture_random_state
*trsp
)
457 if (--trsp
->trs_count
< 0) {
458 trsp
->trs_state
+= (unsigned long)local_clock() + raw_smp_processor_id();
459 trsp
->trs_count
= TORTURE_RANDOM_REFRESH
;
461 trsp
->trs_state
= trsp
->trs_state
* TORTURE_RANDOM_MULT
+
463 return swahw32(trsp
->trs_state
);
465 EXPORT_SYMBOL_GPL(torture_random
);
468 * Variables for shuffling. The idea is to ensure that each CPU stays
469 * idle for an extended period to test interactions with dyntick idle,
470 * as well as interactions with any per-CPU variables.
472 struct shuffle_task
{
473 struct list_head st_l
;
474 struct task_struct
*st_t
;
477 static long shuffle_interval
; /* In jiffies. */
478 static struct task_struct
*shuffler_task
;
479 static cpumask_var_t shuffle_tmp_mask
;
480 static int shuffle_idle_cpu
; /* Force all torture tasks off this CPU */
481 static struct list_head shuffle_task_list
= LIST_HEAD_INIT(shuffle_task_list
);
482 static DEFINE_MUTEX(shuffle_task_mutex
);
485 * Register a task to be shuffled. If there is no memory, just splat
486 * and don't bother registering.
488 void torture_shuffle_task_register(struct task_struct
*tp
)
490 struct shuffle_task
*stp
;
492 if (WARN_ON_ONCE(tp
== NULL
))
494 stp
= kmalloc(sizeof(*stp
), GFP_KERNEL
);
495 if (WARN_ON_ONCE(stp
== NULL
))
498 mutex_lock(&shuffle_task_mutex
);
499 list_add(&stp
->st_l
, &shuffle_task_list
);
500 mutex_unlock(&shuffle_task_mutex
);
502 EXPORT_SYMBOL_GPL(torture_shuffle_task_register
);
505 * Unregister all tasks, for example, at the end of the torture run.
507 static void torture_shuffle_task_unregister_all(void)
509 struct shuffle_task
*stp
;
510 struct shuffle_task
*p
;
512 mutex_lock(&shuffle_task_mutex
);
513 list_for_each_entry_safe(stp
, p
, &shuffle_task_list
, st_l
) {
514 list_del(&stp
->st_l
);
517 mutex_unlock(&shuffle_task_mutex
);
520 /* Shuffle tasks such that we allow shuffle_idle_cpu to become idle.
521 * A special case is when shuffle_idle_cpu = -1, in which case we allow
522 * the tasks to run on all CPUs.
524 static void torture_shuffle_tasks(struct torture_random_state
*trp
)
526 struct shuffle_task
*stp
;
528 cpumask_setall(shuffle_tmp_mask
);
531 /* No point in shuffling if there is only one online CPU (ex: UP) */
532 if (num_online_cpus() == 1) {
537 /* Advance to the next CPU. Upon overflow, don't idle any CPUs. */
538 shuffle_idle_cpu
= cpumask_next(shuffle_idle_cpu
, shuffle_tmp_mask
);
539 if (shuffle_idle_cpu
>= nr_cpu_ids
)
540 shuffle_idle_cpu
= -1;
542 cpumask_clear_cpu(shuffle_idle_cpu
, shuffle_tmp_mask
);
544 mutex_lock(&shuffle_task_mutex
);
545 list_for_each_entry(stp
, &shuffle_task_list
, st_l
) {
546 if (!random_shuffle
|| torture_random(trp
) & 0x1)
547 set_cpus_allowed_ptr(stp
->st_t
, shuffle_tmp_mask
);
549 mutex_unlock(&shuffle_task_mutex
);
554 /* Shuffle tasks across CPUs, with the intent of allowing each CPU in the
555 * system to become idle at a time and cut off its timer ticks. This is meant
556 * to test the support for such tickless idle CPU in RCU.
558 static int torture_shuffle(void *arg
)
560 DEFINE_TORTURE_RANDOM(rand
);
562 VERBOSE_TOROUT_STRING("torture_shuffle task started");
564 torture_hrtimeout_jiffies(shuffle_interval
, &rand
);
565 torture_shuffle_tasks(&rand
);
566 torture_shutdown_absorb("torture_shuffle");
567 } while (!torture_must_stop());
568 torture_kthread_stopping("torture_shuffle");
573 * Start the shuffler, with shuffint in jiffies.
575 int torture_shuffle_init(long shuffint
)
577 shuffle_interval
= shuffint
;
579 shuffle_idle_cpu
= -1;
581 if (!alloc_cpumask_var(&shuffle_tmp_mask
, GFP_KERNEL
)) {
582 TOROUT_ERRSTRING("Failed to alloc mask");
586 /* Create the shuffler thread */
587 return torture_create_kthread(torture_shuffle
, NULL
, shuffler_task
);
589 EXPORT_SYMBOL_GPL(torture_shuffle_init
);
592 * Stop the shuffling.
594 static void torture_shuffle_cleanup(void)
596 torture_shuffle_task_unregister_all();
598 VERBOSE_TOROUT_STRING("Stopping torture_shuffle task");
599 kthread_stop(shuffler_task
);
600 free_cpumask_var(shuffle_tmp_mask
);
602 shuffler_task
= NULL
;
606 * Variables for auto-shutdown. This allows "lights out" torture runs
607 * to be fully scripted.
609 static struct task_struct
*shutdown_task
;
610 static ktime_t shutdown_time
; /* time to system shutdown. */
611 static void (*torture_shutdown_hook
)(void);
614 * Absorb kthreads into a kernel function that won't return, so that
615 * they won't ever access module text or data again.
617 void torture_shutdown_absorb(const char *title
)
619 while (READ_ONCE(fullstop
) == FULLSTOP_SHUTDOWN
) {
620 pr_notice("torture thread %s parking due to system shutdown\n",
622 schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT
);
625 EXPORT_SYMBOL_GPL(torture_shutdown_absorb
);
628 * Cause the torture test to shutdown the system after the test has
629 * run for the time specified by the shutdown_secs parameter.
631 static int torture_shutdown(void *arg
)
635 VERBOSE_TOROUT_STRING("torture_shutdown task started");
636 ktime_snap
= ktime_get();
637 while (ktime_before(ktime_snap
, shutdown_time
) &&
638 !torture_must_stop()) {
640 pr_alert("%s" TORTURE_FLAG
641 "torture_shutdown task: %llu ms remaining\n",
643 ktime_ms_delta(shutdown_time
, ktime_snap
));
644 set_current_state(TASK_INTERRUPTIBLE
);
645 schedule_hrtimeout(&shutdown_time
, HRTIMER_MODE_ABS
);
646 ktime_snap
= ktime_get();
648 if (torture_must_stop()) {
649 torture_kthread_stopping("torture_shutdown");
653 /* OK, shut down the system. */
655 VERBOSE_TOROUT_STRING("torture_shutdown task shutting down system");
656 shutdown_task
= NULL
; /* Avoid self-kill deadlock. */
657 if (torture_shutdown_hook
)
658 torture_shutdown_hook();
660 VERBOSE_TOROUT_STRING("No torture_shutdown_hook(), skipping.");
661 if (ftrace_dump_at_shutdown
)
662 rcu_ftrace_dump(DUMP_ALL
);
663 kernel_power_off(); /* Shut down the system. */
668 * Start up the shutdown task.
670 int torture_shutdown_init(int ssecs
, void (*cleanup
)(void))
672 torture_shutdown_hook
= cleanup
;
674 shutdown_time
= ktime_add(ktime_get(), ktime_set(ssecs
, 0));
675 return torture_create_kthread(torture_shutdown
, NULL
,
680 EXPORT_SYMBOL_GPL(torture_shutdown_init
);
683 * Detect and respond to a system shutdown.
685 static int torture_shutdown_notify(struct notifier_block
*unused1
,
686 unsigned long unused2
, void *unused3
)
688 mutex_lock(&fullstop_mutex
);
689 if (READ_ONCE(fullstop
) == FULLSTOP_DONTSTOP
) {
690 VERBOSE_TOROUT_STRING("Unscheduled system shutdown detected");
691 WRITE_ONCE(fullstop
, FULLSTOP_SHUTDOWN
);
693 pr_warn("Concurrent rmmod and shutdown illegal!\n");
695 mutex_unlock(&fullstop_mutex
);
699 static struct notifier_block torture_shutdown_nb
= {
700 .notifier_call
= torture_shutdown_notify
,
704 * Shut down the shutdown task. Say what??? Heh! This can happen if
705 * the torture module gets an rmmod before the shutdown time arrives. ;-)
707 static void torture_shutdown_cleanup(void)
709 unregister_reboot_notifier(&torture_shutdown_nb
);
710 if (shutdown_task
!= NULL
) {
711 VERBOSE_TOROUT_STRING("Stopping torture_shutdown task");
712 kthread_stop(shutdown_task
);
714 shutdown_task
= NULL
;
718 * Variables for stuttering, which means to periodically pause and
719 * restart testing in order to catch bugs that appear when load is
720 * suddenly applied to or removed from the system.
722 static struct task_struct
*stutter_task
;
723 static ktime_t stutter_till_abs_time
;
725 static int stutter_gap
;
728 * Block until the stutter interval ends. This must be called periodically
729 * by all running kthreads that need to be subject to stuttering.
731 bool stutter_wait(const char *title
)
736 cond_resched_tasks_rcu_qs();
737 till_ns
= READ_ONCE(stutter_till_abs_time
);
738 if (till_ns
&& ktime_before(ktime_get(), till_ns
)) {
739 torture_hrtimeout_ns(till_ns
, 0, HRTIMER_MODE_ABS
, NULL
);
742 torture_shutdown_absorb(title
);
745 EXPORT_SYMBOL_GPL(stutter_wait
);
748 * Cause the torture test to "stutter", starting and stopping all
749 * threads periodically.
751 static int torture_stutter(void *arg
)
755 VERBOSE_TOROUT_STRING("torture_stutter task started");
757 if (!torture_must_stop() && stutter
> 1) {
758 till_ns
= ktime_add_ns(ktime_get(),
759 jiffies_to_nsecs(stutter
));
760 WRITE_ONCE(stutter_till_abs_time
, till_ns
);
761 torture_hrtimeout_jiffies(stutter
- 1, NULL
);
763 if (!torture_must_stop())
764 torture_hrtimeout_jiffies(stutter_gap
, NULL
);
765 torture_shutdown_absorb("torture_stutter");
766 } while (!torture_must_stop());
767 torture_kthread_stopping("torture_stutter");
772 * Initialize and kick off the torture_stutter kthread.
774 int torture_stutter_init(const int s
, const int sgap
)
778 return torture_create_kthread(torture_stutter
, NULL
, stutter_task
);
780 EXPORT_SYMBOL_GPL(torture_stutter_init
);
783 * Cleanup after the torture_stutter kthread.
785 static void torture_stutter_cleanup(void)
789 VERBOSE_TOROUT_STRING("Stopping torture_stutter task");
790 kthread_stop(stutter_task
);
795 torture_print_module_parms(void)
797 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\n",
798 torture_type
, disable_onoff_at_boot
, ftrace_dump_at_shutdown
, verbose_sleep_frequency
, verbose_sleep_duration
, random_shuffle
);
802 * Initialize torture module. Please note that this is -not- invoked via
803 * the usual module_init() mechanism, but rather by an explicit call from
804 * the client torture module. This call must be paired with a later
805 * torture_init_end().
807 * The runnable parameter points to a flag that controls whether or not
808 * the test is currently runnable. If there is no such flag, pass in NULL.
810 bool torture_init_begin(char *ttype
, int v
)
812 mutex_lock(&fullstop_mutex
);
813 if (torture_type
!= NULL
) {
814 pr_alert("%s: Refusing %s init: %s running.\n",
815 __func__
, ttype
, torture_type
);
816 pr_alert("%s: One torture test at a time!\n", __func__
);
817 mutex_unlock(&fullstop_mutex
);
820 torture_type
= ttype
;
822 fullstop
= FULLSTOP_DONTSTOP
;
823 torture_print_module_parms();
826 EXPORT_SYMBOL_GPL(torture_init_begin
);
829 * Tell the torture module that initialization is complete.
831 void torture_init_end(void)
833 mutex_unlock(&fullstop_mutex
);
834 register_reboot_notifier(&torture_shutdown_nb
);
836 EXPORT_SYMBOL_GPL(torture_init_end
);
839 * Clean up torture module. Please note that this is -not- invoked via
840 * the usual module_exit() mechanism, but rather by an explicit call from
841 * the client torture module. Returns true if a race with system shutdown
842 * is detected, otherwise, all kthreads started by functions in this file
845 * This must be called before the caller starts shutting down its own
848 * Both torture_cleanup_begin() and torture_cleanup_end() must be paired,
849 * in order to correctly perform the cleanup. They are separated because
850 * threads can still need to reference the torture_type type, thus nullify
851 * only after completing all other relevant calls.
853 bool torture_cleanup_begin(void)
855 mutex_lock(&fullstop_mutex
);
856 if (READ_ONCE(fullstop
) == FULLSTOP_SHUTDOWN
) {
857 pr_warn("Concurrent rmmod and shutdown illegal!\n");
858 mutex_unlock(&fullstop_mutex
);
859 schedule_timeout_uninterruptible(10);
862 WRITE_ONCE(fullstop
, FULLSTOP_RMMOD
);
863 mutex_unlock(&fullstop_mutex
);
864 torture_shutdown_cleanup();
865 torture_shuffle_cleanup();
866 torture_stutter_cleanup();
867 torture_onoff_cleanup();
870 EXPORT_SYMBOL_GPL(torture_cleanup_begin
);
872 void torture_cleanup_end(void)
874 mutex_lock(&fullstop_mutex
);
876 mutex_unlock(&fullstop_mutex
);
878 EXPORT_SYMBOL_GPL(torture_cleanup_end
);
881 * Is it time for the current torture test to stop?
883 bool torture_must_stop(void)
885 return torture_must_stop_irq() || kthread_should_stop();
887 EXPORT_SYMBOL_GPL(torture_must_stop
);
890 * Is it time for the current torture test to stop? This is the irq-safe
891 * version, hence no check for kthread_should_stop().
893 bool torture_must_stop_irq(void)
895 return READ_ONCE(fullstop
) != FULLSTOP_DONTSTOP
;
897 EXPORT_SYMBOL_GPL(torture_must_stop_irq
);
900 * Each kthread must wait for kthread_should_stop() before returning from
901 * its top-level function, otherwise segfaults ensue. This function
902 * prints a "stopping" message and waits for kthread_should_stop(), and
903 * should be called from all torture kthreads immediately prior to
906 void torture_kthread_stopping(char *title
)
910 snprintf(buf
, sizeof(buf
), "%s is stopping", title
);
911 VERBOSE_TOROUT_STRING(buf
);
912 while (!kthread_should_stop()) {
913 torture_shutdown_absorb(title
);
914 schedule_timeout_uninterruptible(HZ
/ 20);
917 EXPORT_SYMBOL_GPL(torture_kthread_stopping
);
920 * Create a generic torture kthread that is immediately runnable. If you
921 * need the kthread to be stopped so that you can do something to it before
922 * it starts, you will need to open-code your own.
924 int _torture_create_kthread(int (*fn
)(void *arg
), void *arg
, char *s
, char *m
,
925 char *f
, struct task_struct
**tp
, void (*cbf
)(struct task_struct
*tp
))
929 VERBOSE_TOROUT_STRING(m
);
930 *tp
= kthread_create(fn
, arg
, "%s", s
);
941 wake_up_process(*tp
); // Process is sleeping, so ordering provided.
942 torture_shuffle_task_register(*tp
);
945 EXPORT_SYMBOL_GPL(_torture_create_kthread
);
948 * Stop a generic kthread, emitting a message.
950 void _torture_stop_kthread(char *m
, struct task_struct
**tp
)
954 VERBOSE_TOROUT_STRING(m
);
958 EXPORT_SYMBOL_GPL(_torture_stop_kthread
);