// SPDX-License-Identifier: GPL-2.0+ // // Torture test for smp_call_function() and friends. // // Copyright (C) Facebook, 2020. // // Author: Paul E. McKenney <[email protected]> #define pr_fmt(fmt) … #include <linux/atomic.h> #include <linux/bitops.h> #include <linux/completion.h> #include <linux/cpu.h> #include <linux/delay.h> #include <linux/err.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/kthread.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/notifier.h> #include <linux/percpu.h> #include <linux/rcupdate.h> #include <linux/rcupdate_trace.h> #include <linux/reboot.h> #include <linux/sched.h> #include <linux/spinlock.h> #include <linux/smp.h> #include <linux/stat.h> #include <linux/srcu.h> #include <linux/slab.h> #include <linux/torture.h> #include <linux/types.h> #define SCFTORT_STRING … #define SCFTORT_FLAG … #define VERBOSE_SCFTORTOUT(s, x...) … #define SCFTORTOUT_ERRSTRING(s, x...) … MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …; MODULE_AUTHOR(…) …; // Wait until there are multiple CPUs before starting test. torture_param(int, holdoff, IS_BUILTIN(CONFIG_SCF_TORTURE_TEST) ? 10 : 0, "Holdoff time before test start (s)"); torture_param(int, longwait, 0, "Include ridiculously long waits? (seconds)"); torture_param(int, nthreads, -1, "# threads, defaults to -1 for all CPUs."); torture_param(int, onoff_holdoff, 0, "Time after boot before CPU hotplugs (s)"); torture_param(int, onoff_interval, 0, "Time between CPU hotplugs (s), 0=disable"); torture_param(int, shutdown_secs, 0, "Shutdown time (ms), <= zero to disable."); torture_param(int, stat_interval, 60, "Number of seconds between stats printk()s."); torture_param(int, stutter, 5, "Number of jiffies to run/halt test, 0=disable"); torture_param(bool, use_cpus_read_lock, 0, "Use cpus_read_lock() to exclude CPU hotplug."); torture_param(int, verbose, 0, "Enable verbose debugging printk()s"); torture_param(int, weight_resched, -1, "Testing weight for resched_cpu() operations."); torture_param(int, weight_single, -1, "Testing weight for single-CPU no-wait operations."); torture_param(int, weight_single_rpc, -1, "Testing weight for single-CPU RPC operations."); torture_param(int, weight_single_wait, -1, "Testing weight for single-CPU operations."); torture_param(int, weight_many, -1, "Testing weight for multi-CPU no-wait operations."); torture_param(int, weight_many_wait, -1, "Testing weight for multi-CPU operations."); torture_param(int, weight_all, -1, "Testing weight for all-CPU no-wait operations."); torture_param(int, weight_all_wait, -1, "Testing weight for all-CPU operations."); static char *torture_type = …; #ifdef MODULE #define SCFTORT_SHUTDOWN … #else #define SCFTORT_SHUTDOWN … #endif torture_param(bool, shutdown, SCFTORT_SHUTDOWN, "Shutdown at end of torture test."); struct scf_statistics { … }; static struct scf_statistics *scf_stats_p; static struct task_struct *scf_torture_stats_task; static DEFINE_PER_CPU(long long, scf_invoked_count); // Data for random primitive selection #define SCF_PRIM_RESCHED … #define SCF_PRIM_SINGLE … #define SCF_PRIM_SINGLE_RPC … #define SCF_PRIM_MANY … #define SCF_PRIM_ALL … #define SCF_NPRIMS … // except for SCF_PRIM_RESCHED and // SCF_PRIM_SINGLE_RPC. static char *scf_prim_name[] = …; struct scf_selector { … }; static struct scf_selector scf_sel_array[SCF_NPRIMS]; static int scf_sel_array_len; static unsigned long scf_sel_totweight; // Communicate between caller and handler. struct scf_check { … }; // Use to wait for all threads to start. static atomic_t n_started; static atomic_t n_errs; static atomic_t n_mb_in_errs; static atomic_t n_mb_out_errs; static atomic_t n_alloc_errs; static bool scfdone; static char *bangstr = …; static DEFINE_TORTURE_RANDOM_PERCPU(scf_torture_rand); extern void resched_cpu(int cpu); // An alternative IPI vector. // Print torture statistics. Caller must ensure serialization. static void scf_torture_stats_print(void) { … } // Periodically prints torture statistics, if periodic statistics printing // was specified via the stat_interval module parameter. static int scf_torture_stats(void *arg) { … } // Add a primitive to the scf_sel_array[]. static void scf_sel_add(unsigned long weight, int prim, bool wait) { … } // Dump out weighting percentages for scf_prim_name[] array. static void scf_sel_dump(void) { … } // Randomly pick a primitive and wait/nowait, based on weightings. static struct scf_selector *scf_sel_rand(struct torture_random_state *trsp) { … } // Update statistics and occasionally burn up mass quantities of CPU time, // if told to do so via scftorture.longwait. Otherwise, occasionally burn // a little bit. static void scf_handler(void *scfc_in) { … } // As above, but check for correct CPU. static void scf_handler_1(void *scfc_in) { … } // Randomly do an smp_call_function*() invocation. static void scftorture_invoke_one(struct scf_statistics *scfp, struct torture_random_state *trsp) { … } // SCF test kthread. Repeatedly does calls to members of the // smp_call_function() family of functions. static int scftorture_invoker(void *arg) { … } static void scftorture_print_module_parms(const char *tag) { … } static void scf_cleanup_handler(void *unused) { … } static void scf_torture_cleanup(void) { … } static int __init scf_torture_init(void) { … } module_init(…) …; module_exit(scf_torture_cleanup);
Codebase Browser
linux