rcutorture: Abstract torture_stop_kthread()

Stopping of kthreads is not RCU-specific, so this commit abstracts
out torture_stop_kthread(), saving a few lines of code in the process.

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

2 files changed, 27 insertions, 58 deletions

diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c
index a6f6c8418d87..37bd4beea198 100644
--- a/kernel/rcu/rcutorture.c
+++ b/kernel/rcu/rcutorture.c
@@ -1033,14 +1033,12 @@ static void rcutorture_booster_cleanup(int cpu)
         if (boost_tasks[cpu] == NULL)
                 return;
         mutex_lock(&boost_mutex);
-        VERBOSE_TOROUT_STRING("Stopping rcu_torture_boost task");
         t = boost_tasks[cpu];
         boost_tasks[cpu] = NULL;
         mutex_unlock(&boost_mutex);
 
         /* This must be outside of the mutex, otherwise deadlock! */
-        kthread_stop(t);
-        boost_tasks[cpu] = NULL;
+        torture_stop_kthread(rcu_torture_boost, t);
 }
 
 static int rcutorture_booster_init(int cpu)
@@ -1110,16 +1108,6 @@ static int __init rcu_torture_stall_init(void)
         return torture_create_kthread(rcu_torture_stall, NULL, stall_task);
 }
 
-/* Clean up after the CPU-stall kthread, if one was spawned. */
-static void rcu_torture_stall_cleanup(void)
-{
-        if (stall_task == NULL)
-                return;
-        VERBOSE_TOROUT_STRING("Stopping rcu_torture_stall_task.");
-        kthread_stop(stall_task);
-        stall_task = NULL;
-}
-
 /* Callback function for RCU barrier testing. */
 void rcu_torture_barrier_cbf(struct rcu_head *rcu)
 {
@@ -1230,19 +1218,11 @@ static void rcu_torture_barrier_cleanup(void)
 {
         int i;
 
-        if (barrier_task != NULL) {
-                VERBOSE_TOROUT_STRING("Stopping rcu_torture_barrier task");
-                kthread_stop(barrier_task);
-                barrier_task = NULL;
-        }
+        torture_stop_kthread(rcu_torture_barrier, barrier_task);
         if (barrier_cbs_tasks != NULL) {
-                for (i = 0; i < n_barrier_cbs; i++) {
-                        if (barrier_cbs_tasks[i] != NULL) {
-                                VERBOSE_TOROUT_STRING("Stopping rcu_torture_barrier_cbs task");
-                                kthread_stop(barrier_cbs_tasks[i]);
-                                barrier_cbs_tasks[i] = NULL;
-                        }
-                }
+                for (i = 0; i < n_barrier_cbs; i++)
+                        torture_stop_kthread(rcu_torture_barrier_cbs,
+                                             barrier_cbs_tasks[i]);
                 kfree(barrier_cbs_tasks);
                 barrier_cbs_tasks = NULL;
         }
@@ -1288,53 +1268,29 @@ rcu_torture_cleanup(void)
         }
 
         rcu_torture_barrier_cleanup();
-        rcu_torture_stall_cleanup();
+        torture_stop_kthread(rcu_torture_stall, stall_task);
         torture_stutter_cleanup();
-
-        if (writer_task) {
-                VERBOSE_TOROUT_STRING("Stopping rcu_torture_writer task");
-                kthread_stop(writer_task);
-        }
-        writer_task = NULL;
+        torture_stop_kthread(rcu_torture_writer, writer_task);
 
         if (reader_tasks) {
-                for (i = 0; i < nrealreaders; i++) {
-                        if (reader_tasks[i]) {
-                                VERBOSE_TOROUT_STRING(
-                                        "Stopping rcu_torture_reader task");
-                                kthread_stop(reader_tasks[i]);
-                        }
-                        reader_tasks[i] = NULL;
-                }
+                for (i = 0; i < nrealreaders; i++)
+                        torture_stop_kthread(rcu_torture_reader,
+                                             reader_tasks[i]);
                 kfree(reader_tasks);
-                reader_tasks = NULL;
         }
         rcu_torture_current = NULL;
 
         if (fakewriter_tasks) {
                 for (i = 0; i < nfakewriters; i++) {
-                        if (fakewriter_tasks[i]) {
-                                VERBOSE_TOROUT_STRING(
-                                        "Stopping rcu_torture_fakewriter task");
-                                kthread_stop(fakewriter_tasks[i]);
-                        }
-                        fakewriter_tasks[i] = NULL;
+                        torture_stop_kthread(rcu_torture_fakewriter,
+                                             fakewriter_tasks[i]);
                 }
                 kfree(fakewriter_tasks);
                 fakewriter_tasks = NULL;
         }
 
-        if (stats_task) {
-                VERBOSE_TOROUT_STRING("Stopping rcu_torture_stats task");
-                kthread_stop(stats_task);
-        }
-        stats_task = NULL;
-
-        if (fqs_task) {
-                VERBOSE_TOROUT_STRING("Stopping rcu_torture_fqs task");
-                kthread_stop(fqs_task);
-        }
-        fqs_task = NULL;
+        torture_stop_kthread(rcu_torture_stats, stats_task);
+        torture_stop_kthread(rcu_torture_fqs, fqs_task);
         if ((test_boost == 1 && cur_ops->can_boost) ||
             test_boost == 2) {
                 unregister_cpu_notifier(&rcutorture_cpu_nb);
diff --git a/kernel/torture.c b/kernel/torture.c
index 439451821a7f..871f63611f7f 100644
--- a/kernel/torture.c
+++ b/kernel/torture.c
@@ -700,3 +700,16 @@ int _torture_create_kthread(int (*fn)(void *arg), void *arg, char *s, char *m,
         return ret;
 }
 EXPORT_SYMBOL_GPL(_torture_create_kthread);
+
+/*
+ * Stop a generic kthread, emitting a message.
+ */
+void _torture_stop_kthread(char *m, struct task_struct **tp)
+{
+        if (*tp == NULL)
+                return;
+        VERBOSE_TOROUT_STRING(m);
+        kthread_stop(*tp);
+        *tp = NULL;
+}
+EXPORT_SYMBOL_GPL(_torture_stop_kthread);