1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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 <asm/byteorder.h>
47#include <linux/torture.h>
48
49MODULE_LICENSE("GPL");
50MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com>");
51
52static char *torture_type;
53static bool verbose;
54
55
56#define FULLSTOP_DONTSTOP 0
57#define FULLSTOP_SHUTDOWN 1
58#define FULLSTOP_RMMOD 2
59static int fullstop = FULLSTOP_RMMOD;
60static DEFINE_MUTEX(fullstop_mutex);
61static int *torture_runnable;
62
63#ifdef CONFIG_HOTPLUG_CPU
64
65
66
67
68
69
70static struct task_struct *onoff_task;
71static long onoff_holdoff;
72static long onoff_interval;
73static long n_offline_attempts;
74static long n_offline_successes;
75static unsigned long sum_offline;
76static int min_offline = -1;
77static int max_offline;
78static long n_online_attempts;
79static long n_online_successes;
80static unsigned long sum_online;
81static int min_online = -1;
82static int max_online;
83
84
85
86
87
88static int
89torture_onoff(void *arg)
90{
91 int cpu;
92 unsigned long delta;
93 int maxcpu = -1;
94 DEFINE_TORTURE_RANDOM(rand);
95 int ret;
96 unsigned long starttime;
97
98 VERBOSE_TOROUT_STRING("torture_onoff task started");
99 for_each_online_cpu(cpu)
100 maxcpu = cpu;
101 WARN_ON(maxcpu < 0);
102 if (onoff_holdoff > 0) {
103 VERBOSE_TOROUT_STRING("torture_onoff begin holdoff");
104 schedule_timeout_interruptible(onoff_holdoff);
105 VERBOSE_TOROUT_STRING("torture_onoff end holdoff");
106 }
107 while (!torture_must_stop()) {
108 cpu = (torture_random(&rand) >> 4) % (maxcpu + 1);
109 if (cpu_online(cpu) && cpu_is_hotpluggable(cpu)) {
110 if (verbose)
111 pr_alert("%s" TORTURE_FLAG
112 "torture_onoff task: offlining %d\n",
113 torture_type, cpu);
114 starttime = jiffies;
115 n_offline_attempts++;
116 ret = cpu_down(cpu);
117 if (ret) {
118 if (verbose)
119 pr_alert("%s" TORTURE_FLAG
120 "torture_onoff task: offline %d failed: errno %d\n",
121 torture_type, cpu, ret);
122 } else {
123 if (verbose)
124 pr_alert("%s" TORTURE_FLAG
125 "torture_onoff task: offlined %d\n",
126 torture_type, cpu);
127 n_offline_successes++;
128 delta = jiffies - starttime;
129 sum_offline += delta;
130 if (min_offline < 0) {
131 min_offline = delta;
132 max_offline = delta;
133 }
134 if (min_offline > delta)
135 min_offline = delta;
136 if (max_offline < delta)
137 max_offline = delta;
138 }
139 } else if (cpu_is_hotpluggable(cpu)) {
140 if (verbose)
141 pr_alert("%s" TORTURE_FLAG
142 "torture_onoff task: onlining %d\n",
143 torture_type, cpu);
144 starttime = jiffies;
145 n_online_attempts++;
146 ret = cpu_up(cpu);
147 if (ret) {
148 if (verbose)
149 pr_alert("%s" TORTURE_FLAG
150 "torture_onoff task: online %d failed: errno %d\n",
151 torture_type, cpu, ret);
152 } else {
153 if (verbose)
154 pr_alert("%s" TORTURE_FLAG
155 "torture_onoff task: onlined %d\n",
156 torture_type, cpu);
157 n_online_successes++;
158 delta = jiffies - starttime;
159 sum_online += delta;
160 if (min_online < 0) {
161 min_online = delta;
162 max_online = delta;
163 }
164 if (min_online > delta)
165 min_online = delta;
166 if (max_online < delta)
167 max_online = delta;
168 }
169 }
170 schedule_timeout_interruptible(onoff_interval);
171 }
172 torture_kthread_stopping("torture_onoff");
173 return 0;
174}
175
176#endif
177
178
179
180
181int torture_onoff_init(long ooholdoff, long oointerval)
182{
183 int ret = 0;
184
185#ifdef CONFIG_HOTPLUG_CPU
186 onoff_holdoff = ooholdoff;
187 onoff_interval = oointerval;
188 if (onoff_interval <= 0)
189 return 0;
190 ret = torture_create_kthread(torture_onoff, NULL, onoff_task);
191#endif
192 return ret;
193}
194EXPORT_SYMBOL_GPL(torture_onoff_init);
195
196
197
198
199static void torture_onoff_cleanup(void)
200{
201#ifdef CONFIG_HOTPLUG_CPU
202 if (onoff_task == NULL)
203 return;
204 VERBOSE_TOROUT_STRING("Stopping torture_onoff task");
205 kthread_stop(onoff_task);
206 onoff_task = NULL;
207#endif
208}
209EXPORT_SYMBOL_GPL(torture_onoff_cleanup);
210
211
212
213
214void torture_onoff_stats(void)
215{
216#ifdef CONFIG_HOTPLUG_CPU
217 pr_cont("onoff: %ld/%ld:%ld/%ld %d,%d:%d,%d %lu:%lu (HZ=%d) ",
218 n_online_successes, n_online_attempts,
219 n_offline_successes, n_offline_attempts,
220 min_online, max_online,
221 min_offline, max_offline,
222 sum_online, sum_offline, HZ);
223#endif
224}
225EXPORT_SYMBOL_GPL(torture_onoff_stats);
226
227
228
229
230bool torture_onoff_failures(void)
231{
232#ifdef CONFIG_HOTPLUG_CPU
233 return n_online_successes != n_online_attempts ||
234 n_offline_successes != n_offline_attempts;
235#else
236 return false;
237#endif
238}
239EXPORT_SYMBOL_GPL(torture_onoff_failures);
240
241#define TORTURE_RANDOM_MULT 39916801
242#define TORTURE_RANDOM_ADD 479001701
243#define TORTURE_RANDOM_REFRESH 10000
244
245
246
247
248
249unsigned long
250torture_random(struct torture_random_state *trsp)
251{
252 if (--trsp->trs_count < 0) {
253 trsp->trs_state += (unsigned long)local_clock();
254 trsp->trs_count = TORTURE_RANDOM_REFRESH;
255 }
256 trsp->trs_state = trsp->trs_state * TORTURE_RANDOM_MULT +
257 TORTURE_RANDOM_ADD;
258 return swahw32(trsp->trs_state);
259}
260EXPORT_SYMBOL_GPL(torture_random);
261
262
263
264
265
266
267struct shuffle_task {
268 struct list_head st_l;
269 struct task_struct *st_t;
270};
271
272static long shuffle_interval;
273static struct task_struct *shuffler_task;
274static cpumask_var_t shuffle_tmp_mask;
275static int shuffle_idle_cpu;
276static struct list_head shuffle_task_list = LIST_HEAD_INIT(shuffle_task_list);
277static DEFINE_MUTEX(shuffle_task_mutex);
278
279
280
281
282
283void torture_shuffle_task_register(struct task_struct *tp)
284{
285 struct shuffle_task *stp;
286
287 if (WARN_ON_ONCE(tp == NULL))
288 return;
289 stp = kmalloc(sizeof(*stp), GFP_KERNEL);
290 if (WARN_ON_ONCE(stp == NULL))
291 return;
292 stp->st_t = tp;
293 mutex_lock(&shuffle_task_mutex);
294 list_add(&stp->st_l, &shuffle_task_list);
295 mutex_unlock(&shuffle_task_mutex);
296}
297EXPORT_SYMBOL_GPL(torture_shuffle_task_register);
298
299
300
301
302static void torture_shuffle_task_unregister_all(void)
303{
304 struct shuffle_task *stp;
305 struct shuffle_task *p;
306
307 mutex_lock(&shuffle_task_mutex);
308 list_for_each_entry_safe(stp, p, &shuffle_task_list, st_l) {
309 list_del(&stp->st_l);
310 kfree(stp);
311 }
312 mutex_unlock(&shuffle_task_mutex);
313}
314
315
316
317
318
319static void torture_shuffle_tasks(void)
320{
321 struct shuffle_task *stp;
322
323 cpumask_setall(shuffle_tmp_mask);
324 get_online_cpus();
325
326
327 if (num_online_cpus() == 1) {
328 put_online_cpus();
329 return;
330 }
331
332
333 shuffle_idle_cpu = cpumask_next(shuffle_idle_cpu, shuffle_tmp_mask);
334 if (shuffle_idle_cpu >= nr_cpu_ids)
335 shuffle_idle_cpu = -1;
336 else
337 cpumask_clear_cpu(shuffle_idle_cpu, shuffle_tmp_mask);
338
339 mutex_lock(&shuffle_task_mutex);
340 list_for_each_entry(stp, &shuffle_task_list, st_l)
341 set_cpus_allowed_ptr(stp->st_t, shuffle_tmp_mask);
342 mutex_unlock(&shuffle_task_mutex);
343
344 put_online_cpus();
345}
346
347
348
349
350
351static int torture_shuffle(void *arg)
352{
353 VERBOSE_TOROUT_STRING("torture_shuffle task started");
354 do {
355 schedule_timeout_interruptible(shuffle_interval);
356 torture_shuffle_tasks();
357 torture_shutdown_absorb("torture_shuffle");
358 } while (!torture_must_stop());
359 torture_kthread_stopping("torture_shuffle");
360 return 0;
361}
362
363
364
365
366int torture_shuffle_init(long shuffint)
367{
368 shuffle_interval = shuffint;
369
370 shuffle_idle_cpu = -1;
371
372 if (!alloc_cpumask_var(&shuffle_tmp_mask, GFP_KERNEL)) {
373 VERBOSE_TOROUT_ERRSTRING("Failed to alloc mask");
374 return -ENOMEM;
375 }
376
377
378 return torture_create_kthread(torture_shuffle, NULL, shuffler_task);
379}
380EXPORT_SYMBOL_GPL(torture_shuffle_init);
381
382
383
384
385static void torture_shuffle_cleanup(void)
386{
387 torture_shuffle_task_unregister_all();
388 if (shuffler_task) {
389 VERBOSE_TOROUT_STRING("Stopping torture_shuffle task");
390 kthread_stop(shuffler_task);
391 free_cpumask_var(shuffle_tmp_mask);
392 }
393 shuffler_task = NULL;
394}
395EXPORT_SYMBOL_GPL(torture_shuffle_cleanup);
396
397
398
399
400
401static int shutdown_secs;
402static struct task_struct *shutdown_task;
403static unsigned long shutdown_time;
404static void (*torture_shutdown_hook)(void);
405
406
407
408
409
410void torture_shutdown_absorb(const char *title)
411{
412 while (READ_ONCE(fullstop) == FULLSTOP_SHUTDOWN) {
413 pr_notice("torture thread %s parking due to system shutdown\n",
414 title);
415 schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT);
416 }
417}
418EXPORT_SYMBOL_GPL(torture_shutdown_absorb);
419
420
421
422
423
424static int torture_shutdown(void *arg)
425{
426 long delta;
427 unsigned long jiffies_snap;
428
429 VERBOSE_TOROUT_STRING("torture_shutdown task started");
430 jiffies_snap = jiffies;
431 while (ULONG_CMP_LT(jiffies_snap, shutdown_time) &&
432 !torture_must_stop()) {
433 delta = shutdown_time - jiffies_snap;
434 if (verbose)
435 pr_alert("%s" TORTURE_FLAG
436 "torture_shutdown task: %lu jiffies remaining\n",
437 torture_type, delta);
438 schedule_timeout_interruptible(delta);
439 jiffies_snap = jiffies;
440 }
441 if (torture_must_stop()) {
442 torture_kthread_stopping("torture_shutdown");
443 return 0;
444 }
445
446
447
448 VERBOSE_TOROUT_STRING("torture_shutdown task shutting down system");
449 shutdown_task = NULL;
450 if (torture_shutdown_hook)
451 torture_shutdown_hook();
452 else
453 VERBOSE_TOROUT_STRING("No torture_shutdown_hook(), skipping.");
454 kernel_power_off();
455 return 0;
456}
457
458
459
460
461int torture_shutdown_init(int ssecs, void (*cleanup)(void))
462{
463 int ret = 0;
464
465 shutdown_secs = ssecs;
466 torture_shutdown_hook = cleanup;
467 if (shutdown_secs > 0) {
468 shutdown_time = jiffies + shutdown_secs * HZ;
469 ret = torture_create_kthread(torture_shutdown, NULL,
470 shutdown_task);
471 }
472 return ret;
473}
474EXPORT_SYMBOL_GPL(torture_shutdown_init);
475
476
477
478
479static int torture_shutdown_notify(struct notifier_block *unused1,
480 unsigned long unused2, void *unused3)
481{
482 mutex_lock(&fullstop_mutex);
483 if (READ_ONCE(fullstop) == FULLSTOP_DONTSTOP) {
484 VERBOSE_TOROUT_STRING("Unscheduled system shutdown detected");
485 WRITE_ONCE(fullstop, FULLSTOP_SHUTDOWN);
486 } else {
487 pr_warn("Concurrent rmmod and shutdown illegal!\n");
488 }
489 mutex_unlock(&fullstop_mutex);
490 return NOTIFY_DONE;
491}
492
493static struct notifier_block torture_shutdown_nb = {
494 .notifier_call = torture_shutdown_notify,
495};
496
497
498
499
500
501static void torture_shutdown_cleanup(void)
502{
503 unregister_reboot_notifier(&torture_shutdown_nb);
504 if (shutdown_task != NULL) {
505 VERBOSE_TOROUT_STRING("Stopping torture_shutdown task");
506 kthread_stop(shutdown_task);
507 }
508 shutdown_task = NULL;
509}
510
511
512
513
514
515
516static struct task_struct *stutter_task;
517static int stutter_pause_test;
518static int stutter;
519
520
521
522
523
524void stutter_wait(const char *title)
525{
526 cond_resched_rcu_qs();
527 while (READ_ONCE(stutter_pause_test) ||
528 (torture_runnable && !READ_ONCE(*torture_runnable))) {
529 if (stutter_pause_test)
530 if (READ_ONCE(stutter_pause_test) == 1)
531 schedule_timeout_interruptible(1);
532 else
533 while (READ_ONCE(stutter_pause_test))
534 cond_resched();
535 else
536 schedule_timeout_interruptible(round_jiffies_relative(HZ));
537 torture_shutdown_absorb(title);
538 }
539}
540EXPORT_SYMBOL_GPL(stutter_wait);
541
542
543
544
545
546static int torture_stutter(void *arg)
547{
548 VERBOSE_TOROUT_STRING("torture_stutter task started");
549 do {
550 if (!torture_must_stop()) {
551 if (stutter > 1) {
552 schedule_timeout_interruptible(stutter - 1);
553 WRITE_ONCE(stutter_pause_test, 2);
554 }
555 schedule_timeout_interruptible(1);
556 WRITE_ONCE(stutter_pause_test, 1);
557 }
558 if (!torture_must_stop())
559 schedule_timeout_interruptible(stutter);
560 WRITE_ONCE(stutter_pause_test, 0);
561 torture_shutdown_absorb("torture_stutter");
562 } while (!torture_must_stop());
563 torture_kthread_stopping("torture_stutter");
564 return 0;
565}
566
567
568
569
570int torture_stutter_init(int s)
571{
572 int ret;
573
574 stutter = s;
575 ret = torture_create_kthread(torture_stutter, NULL, stutter_task);
576 return ret;
577}
578EXPORT_SYMBOL_GPL(torture_stutter_init);
579
580
581
582
583static void torture_stutter_cleanup(void)
584{
585 if (!stutter_task)
586 return;
587 VERBOSE_TOROUT_STRING("Stopping torture_stutter task");
588 kthread_stop(stutter_task);
589 stutter_task = NULL;
590}
591
592
593
594
595
596
597
598
599
600
601bool torture_init_begin(char *ttype, bool v, int *runnable)
602{
603 mutex_lock(&fullstop_mutex);
604 if (torture_type != NULL) {
605 pr_alert("torture_init_begin: refusing %s init: %s running",
606 ttype, torture_type);
607 mutex_unlock(&fullstop_mutex);
608 return false;
609 }
610 torture_type = ttype;
611 verbose = v;
612 torture_runnable = runnable;
613 fullstop = FULLSTOP_DONTSTOP;
614 return true;
615}
616EXPORT_SYMBOL_GPL(torture_init_begin);
617
618
619
620
621void torture_init_end(void)
622{
623 mutex_unlock(&fullstop_mutex);
624 register_reboot_notifier(&torture_shutdown_nb);
625}
626EXPORT_SYMBOL_GPL(torture_init_end);
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643bool torture_cleanup_begin(void)
644{
645 mutex_lock(&fullstop_mutex);
646 if (READ_ONCE(fullstop) == FULLSTOP_SHUTDOWN) {
647 pr_warn("Concurrent rmmod and shutdown illegal!\n");
648 mutex_unlock(&fullstop_mutex);
649 schedule_timeout_uninterruptible(10);
650 return true;
651 }
652 WRITE_ONCE(fullstop, FULLSTOP_RMMOD);
653 mutex_unlock(&fullstop_mutex);
654 torture_shutdown_cleanup();
655 torture_shuffle_cleanup();
656 torture_stutter_cleanup();
657 torture_onoff_cleanup();
658 return false;
659}
660EXPORT_SYMBOL_GPL(torture_cleanup_begin);
661
662void torture_cleanup_end(void)
663{
664 mutex_lock(&fullstop_mutex);
665 torture_type = NULL;
666 mutex_unlock(&fullstop_mutex);
667}
668EXPORT_SYMBOL_GPL(torture_cleanup_end);
669
670
671
672
673bool torture_must_stop(void)
674{
675 return torture_must_stop_irq() || kthread_should_stop();
676}
677EXPORT_SYMBOL_GPL(torture_must_stop);
678
679
680
681
682
683bool torture_must_stop_irq(void)
684{
685 return READ_ONCE(fullstop) != FULLSTOP_DONTSTOP;
686}
687EXPORT_SYMBOL_GPL(torture_must_stop_irq);
688
689
690
691
692
693
694
695
696void torture_kthread_stopping(char *title)
697{
698 char buf[128];
699
700 snprintf(buf, sizeof(buf), "Stopping %s", title);
701 VERBOSE_TOROUT_STRING(buf);
702 while (!kthread_should_stop()) {
703 torture_shutdown_absorb(title);
704 schedule_timeout_uninterruptible(1);
705 }
706}
707EXPORT_SYMBOL_GPL(torture_kthread_stopping);
708
709
710
711
712
713
714int _torture_create_kthread(int (*fn)(void *arg), void *arg, char *s, char *m,
715 char *f, struct task_struct **tp)
716{
717 int ret = 0;
718
719 VERBOSE_TOROUT_STRING(m);
720 *tp = kthread_run(fn, arg, "%s", s);
721 if (IS_ERR(*tp)) {
722 ret = PTR_ERR(*tp);
723 VERBOSE_TOROUT_ERRSTRING(f);
724 *tp = NULL;
725 }
726 torture_shuffle_task_register(*tp);
727 return ret;
728}
729EXPORT_SYMBOL_GPL(_torture_create_kthread);
730
731
732
733
734void _torture_stop_kthread(char *m, struct task_struct **tp)
735{
736 if (*tp == NULL)
737 return;
738 VERBOSE_TOROUT_STRING(m);
739 kthread_stop(*tp);
740 *tp = NULL;
741}
742EXPORT_SYMBOL_GPL(_torture_stop_kthread);
743