~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/torture.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp