rcutorture: Abstract torture_shutdown_absorb()

Because handling races between rmmod and normal shutdown is not specific
to rcutorture, this commit renames rcutorture_shutdown_absorb() to
torture_shutdown_absorb() and pulls it out into then kernel/torture.c
module.  This implies pulling the fullstop mechanism into kernel/torture.c
as well.

The exporting of fullstop and fullstop_mutex is ugly and must die.
And it does in fact die in later commits that introduce higher-level
APIs that encapsulate both of these variables.

Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Reviewed-by: Josh Triplett <josh@joshtriplett.org>`

diff --git a/include/linux/torture.h b/include/linux/torture.h
index 09be8887fb0806ef92a4baa9504279a1845f25fd..8474d776c864c322ac7341a7ecebea3a14141f9e 100644 (file)
--- a/include/linux/torture.h
+++ b/include/linux/torture.h
@@ -41,6 +41,18 @@
        module_param(name, type, 0444); \
        MODULE_PARM_DESC(name, msg);
 
+/* Mediate rmmod and system shutdown.  Concurrent rmmod & shutdown illegal! */
+#define FULLSTOP_DONTSTOP 0    /* Normal operation. */
+#define FULLSTOP_SHUTDOWN 1    /* System shutdown with rcutorture running. */
+#define FULLSTOP_RMMOD    2    /* Normal rmmod of rcutorture. */
+extern int fullstop;
+/* Protect fullstop transitions and spawning of kthreads.  */
+extern struct mutex fullstop_mutex;
+
+/* Common module parameters. */
+extern char *torture_type;
+extern bool verbose;
+
 #define TORTURE_FLAG "-torture:"
 #define TOROUT_STRING(s) \
        pr_alert("%s" TORTURE_FLAG s "\n", torture_type)
@@ -57,4 +69,7 @@ struct torture_random_state {
 #define DEFINE_TORTURE_RANDOM(name) struct torture_random_state name = { 0, 0 }
 unsigned long torture_random(struct torture_random_state *trsp);
 
+/* Shutdown task absorption, for when the tasks cannot safely be killed. */
+void torture_shutdown_absorb(const char *title);
+
 #endif /* __LINUX_TORTURE_H */

diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c
index 86fd8c11257bcaf339abbb6d4ed4a2c2dad5c64a..a868758a6f9c27b2421d233551ca2d9a58e1ad3d 100644 (file)
--- a/kernel/rcu/rcutorture.c
+++ b/kernel/rcu/rcutorture.c
@@ -91,11 +91,15 @@ torture_param(int, test_boost_interval, 7,
             "Interval between boost tests, seconds.");
 torture_param(bool, test_no_idle_hz, true,
             "Test support for tickless idle CPUs");
-torture_param(bool, verbose, false, "Enable verbose debugging printk()s");
 
-static char *torture_type = "rcu";
+char *torture_type = "rcu";
+EXPORT_SYMBOL_GPL(torture_type);
 module_param(torture_type, charp, 0444);
 MODULE_PARM_DESC(torture_type, "Type of RCU to torture (rcu, rcu_bh, ...)");
+bool verbose;
+EXPORT_SYMBOL_GPL(verbose);
+module_param(verbose, bool, 0444);
+MODULE_PARM_DESC(verbose, "Enable verbose debugging printk()s");
 
 static int nrealreaders;
 static struct task_struct *writer_task;
@@ -200,17 +204,6 @@ static atomic_t barrier_cbs_invoked;       /* Barrier callbacks invoked. */
 static wait_queue_head_t *barrier_cbs_wq; /* Coordinate barrier testing. */
 static DECLARE_WAIT_QUEUE_HEAD(barrier_wq);
 
-/* Mediate rmmod and system shutdown.  Concurrent rmmod & shutdown illegal! */
-
-#define FULLSTOP_DONTSTOP 0    /* Normal operation. */
-#define FULLSTOP_SHUTDOWN 1    /* System shutdown with rcutorture running. */
-#define FULLSTOP_RMMOD    2    /* Normal rmmod of rcutorture. */
-static int fullstop = FULLSTOP_RMMOD;
-/*
- * Protect fullstop transitions and spawning of kthreads.
- */
-static DEFINE_MUTEX(fullstop_mutex);
-
 /* Forward reference. */
 static void rcu_torture_cleanup(void);
 
@@ -231,20 +224,6 @@ rcutorture_shutdown_notify(struct notifier_block *unused1,
        return NOTIFY_DONE;
 }
 
-/*
- * Absorb kthreads into a kernel function that won't return, so that
- * they won't ever access module text or data again.
- */
-static void rcutorture_shutdown_absorb(const char *title)
-{
-       if (ACCESS_ONCE(fullstop) == FULLSTOP_SHUTDOWN) {
-               pr_notice(
-                      "rcutorture thread %s parking due to system shutdown\n",
-                      title);
-               schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT);
-       }
-}
-
 /*
  * Allocate an element from the rcu_tortures pool.
  */
@@ -286,7 +265,7 @@ rcu_stutter_wait(const char *title)
                        schedule_timeout_interruptible(1);
                else
                        schedule_timeout_interruptible(round_jiffies_relative(HZ));
-               rcutorture_shutdown_absorb(title);
+               torture_shutdown_absorb(title);
        }
 }
 
@@ -681,7 +660,7 @@ checkwait:  rcu_stutter_wait("rcu_torture_boost");
 
        /* Clean up and exit. */
        VERBOSE_TOROUT_STRING("rcu_torture_boost task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_boost");
+       torture_shutdown_absorb("rcu_torture_boost");
        while (!kthread_should_stop() || rbi.inflight)
                schedule_timeout_uninterruptible(1);
        smp_mb(); /* order accesses to ->inflight before stack-frame death. */
@@ -717,7 +696,7 @@ rcu_torture_fqs(void *arg)
                rcu_stutter_wait("rcu_torture_fqs");
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
        VERBOSE_TOROUT_STRING("rcu_torture_fqs task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_fqs");
+       torture_shutdown_absorb("rcu_torture_fqs");
        while (!kthread_should_stop())
                schedule_timeout_uninterruptible(1);
        return 0;
@@ -789,7 +768,7 @@ rcu_torture_writer(void *arg)
                rcu_stutter_wait("rcu_torture_writer");
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
        VERBOSE_TOROUT_STRING("rcu_torture_writer task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_writer");
+       torture_shutdown_absorb("rcu_torture_writer");
        while (!kthread_should_stop())
                schedule_timeout_uninterruptible(1);
        return 0;
@@ -827,7 +806,7 @@ rcu_torture_fakewriter(void *arg)
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
 
        VERBOSE_TOROUT_STRING("rcu_torture_fakewriter task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_fakewriter");
+       torture_shutdown_absorb("rcu_torture_fakewriter");
        while (!kthread_should_stop())
                schedule_timeout_uninterruptible(1);
        return 0;
@@ -971,7 +950,7 @@ rcu_torture_reader(void *arg)
                rcu_stutter_wait("rcu_torture_reader");
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
        VERBOSE_TOROUT_STRING("rcu_torture_reader task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_reader");
+       torture_shutdown_absorb("rcu_torture_reader");
        if (irqreader && cur_ops->irq_capable)
                del_timer_sync(&t);
        while (!kthread_should_stop())
@@ -1095,7 +1074,7 @@ rcu_torture_stats(void *arg)
        do {
                schedule_timeout_interruptible(stat_interval * HZ);
                rcu_torture_stats_print();
-               rcutorture_shutdown_absorb("rcu_torture_stats");
+               torture_shutdown_absorb("rcu_torture_stats");
        } while (!kthread_should_stop());
        VERBOSE_TOROUT_STRING("rcu_torture_stats task stopping");
        return 0;
@@ -1179,7 +1158,7 @@ rcu_torture_shuffle(void *arg)
        do {
                schedule_timeout_interruptible(shuffle_interval * HZ);
                rcu_torture_shuffle_tasks();
-               rcutorture_shutdown_absorb("rcu_torture_shuffle");
+               torture_shutdown_absorb("rcu_torture_shuffle");
        } while (!kthread_should_stop());
        VERBOSE_TOROUT_STRING("rcu_torture_shuffle task stopping");
        return 0;
@@ -1198,7 +1177,7 @@ rcu_torture_stutter(void *arg)
                if (!kthread_should_stop())
                        schedule_timeout_interruptible(stutter * HZ);
                stutter_pause_test = 0;
-               rcutorture_shutdown_absorb("rcu_torture_stutter");
+               torture_shutdown_absorb("rcu_torture_stutter");
        } while (!kthread_should_stop());
        VERBOSE_TOROUT_STRING("rcu_torture_stutter task stopping");
        return 0;
@@ -1470,7 +1449,7 @@ static int rcu_torture_stall(void *args)
                rcu_read_unlock();
                pr_alert("rcu_torture_stall end.\n");
        }
-       rcutorture_shutdown_absorb("rcu_torture_stall");
+       torture_shutdown_absorb("rcu_torture_stall");
        while (!kthread_should_stop())
                schedule_timeout_interruptible(10 * HZ);
        return 0;
@@ -1534,7 +1513,7 @@ static int rcu_torture_barrier_cbs(void *arg)
                        wake_up(&barrier_wq);
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
        VERBOSE_TOROUT_STRING("rcu_torture_barrier_cbs task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_barrier_cbs");
+       torture_shutdown_absorb("rcu_torture_barrier_cbs");
        while (!kthread_should_stop())
                schedule_timeout_interruptible(1);
        cur_ops->cb_barrier();
@@ -1571,7 +1550,7 @@ static int rcu_torture_barrier(void *arg)
                schedule_timeout_interruptible(HZ / 10);
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
        VERBOSE_TOROUT_STRING("rcu_torture_barrier task stopping");
-       rcutorture_shutdown_absorb("rcu_torture_barrier");
+       torture_shutdown_absorb("rcu_torture_barrier");
        while (!kthread_should_stop())
                schedule_timeout_interruptible(1);
        return 0;

diff --git a/kernel/torture.c b/kernel/torture.c
index c82c70f7828e525e286df06d7ca6836a475e3b34..f05042036ae877966fbf2a033d1651b2339db3a6 100644 (file)
--- a/kernel/torture.c
+++ b/kernel/torture.c
@@ -49,6 +49,11 @@
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com>");
 
+int fullstop = FULLSTOP_RMMOD;
+EXPORT_SYMBOL_GPL(fullstop);
+DEFINE_MUTEX(fullstop_mutex);
+EXPORT_SYMBOL_GPL(fullstop_mutex);
+
 #define TORTURE_RANDOM_MULT    39916801  /* prime */
 #define TORTURE_RANDOM_ADD     479001701 /* prime */
 #define TORTURE_RANDOM_REFRESH 10000
@@ -69,3 +74,18 @@ torture_random(struct torture_random_state *trsp)
        return swahw32(trsp->trs_state);
 }
 EXPORT_SYMBOL_GPL(torture_random);
+
+/*
+ * Absorb kthreads into a kernel function that won't return, so that
+ * they won't ever access module text or data again.
+ */
+void torture_shutdown_absorb(const char *title)
+{
+       while (ACCESS_ONCE(fullstop) == FULLSTOP_SHUTDOWN) {
+               pr_notice(
+                      "torture thread %s parking due to system shutdown\n",
+                      title);
+               schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT);
+       }
+}
+EXPORT_SYMBOL_GPL(torture_shutdown_absorb);