locktorture: Add infrastructure for torturing read locks

Most of it is based on what we already have for writers. This allows
readers to be very independent (and thus configurable), enabling
future module parameters to control things such as rw distribution.
Furthermore, readers have their own delaying function, allowing us
to test different rw critical region latencies, and stress locking
internals. Similarly, statistics, for now will only serve for the
number of lock acquisitions -- as opposed to writers, readers have
no failure detection.

In addition, introduce a new nreaders_stress module parameter. The
default number of readers will be the same number of writers threads.
Writer threads are interleaved with readers. Documentation is updated,
respectively.

Signed-off-by: Davidlohr Bueso <dbueso@suse.de>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>

1 files changed, 156 insertions, 20 deletions

diff --git a/kernel/locking/locktorture.c b/kernel/locking/locktorture.c
index 988267cc92c1..c1073d79e440 100644
--- a/kernel/locking/locktorture.c
+++ b/kernel/locking/locktorture.c
@@ -52,6 +52,8 @@ MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com>");
 
 torture_param(int, nwriters_stress, -1,
              "Number of write-locking stress-test threads");
+torture_param(int, nreaders_stress, -1,
+             "Number of read-locking stress-test threads");
 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");
@@ -74,15 +76,19 @@ static atomic_t n_lock_torture_errors;
 
 static struct task_struct *stats_task;
 static struct task_struct **writer_tasks;
+static struct task_struct **reader_tasks;
 
 static int nrealwriters_stress;
 static bool lock_is_write_held;
+static int nrealreaders_stress;
+static bool lock_is_read_held;
 
 struct lock_stress_stats {
         long n_lock_fail;
         long n_lock_acquired;
 };
 static struct lock_stress_stats *lwsa; /* writer statistics */
+static struct lock_stress_stats *lrsa; /* reader statistics */
 
 #if defined(MODULE)
 #define LOCKTORTURE_RUNNABLE_INIT 1
@@ -104,6 +110,9 @@ struct lock_torture_ops {
         int (*writelock)(void);
         void (*write_delay)(struct torture_random_state *trsp);
         void (*writeunlock)(void);
+        int (*readlock)(void);
+        void (*read_delay)(struct torture_random_state *trsp);
+        void (*readunlock)(void);
         unsigned long flags;
         const char *name;
 };
@@ -142,6 +151,9 @@ static struct lock_torture_ops lock_busted_ops = {
         .writelock      = torture_lock_busted_write_lock,
         .write_delay    = torture_lock_busted_write_delay,
         .writeunlock    = torture_lock_busted_write_unlock,
+        .readlock       = NULL,
+        .read_delay     = NULL,
+        .readunlock     = NULL,
         .name           = "lock_busted"
 };
 
@@ -182,6 +194,9 @@ static struct lock_torture_ops spin_lock_ops = {
         .writelock      = torture_spin_lock_write_lock,
         .write_delay    = torture_spin_lock_write_delay,
         .writeunlock    = torture_spin_lock_write_unlock,
+        .readlock       = NULL,
+        .read_delay     = NULL,
+        .readunlock     = NULL,
         .name           = "spin_lock"
 };
 
@@ -205,6 +220,9 @@ static struct lock_torture_ops spin_lock_irq_ops = {
         .writelock      = torture_spin_lock_write_lock_irq,
         .write_delay    = torture_spin_lock_write_delay,
         .writeunlock    = torture_lock_spin_write_unlock_irq,
+        .readlock       = NULL,
+        .read_delay     = NULL,
+        .readunlock     = NULL,
         .name           = "spin_lock_irq"
 };
 
@@ -241,6 +259,9 @@ static struct lock_torture_ops mutex_lock_ops = {
         .writelock      = torture_mutex_lock,
         .write_delay    = torture_mutex_delay,
         .writeunlock    = torture_mutex_unlock,
+        .readlock       = NULL,
+        .read_delay     = NULL,
+        .readunlock     = NULL,
         .name           = "mutex_lock"
 };
 
@@ -274,28 +295,57 @@ static int lock_torture_writer(void *arg)
 }
 
 /*
+ * Lock torture reader kthread.  Repeatedly acquires and releases
+ * the reader lock.
+ */
+static int lock_torture_reader(void *arg)
+{
+        struct lock_stress_stats *lrsp = arg;
+        static DEFINE_TORTURE_RANDOM(rand);
+
+        VERBOSE_TOROUT_STRING("lock_torture_reader task started");
+        set_user_nice(current, MAX_NICE);
+
+        do {
+                if ((torture_random(&rand) & 0xfffff) == 0)
+                        schedule_timeout_uninterruptible(1);
+                cur_ops->readlock();
+                lock_is_read_held = 1;
+                lrsp->n_lock_acquired++;
+                cur_ops->read_delay(&rand);
+                lock_is_read_held = 0;
+                cur_ops->readunlock();
+                stutter_wait("lock_torture_reader");
+        } while (!torture_must_stop());
+        torture_kthread_stopping("lock_torture_reader");
+        return 0;
+}
+
+/*
  * Create an lock-torture-statistics message in the specified buffer.
  */
-static void lock_torture_printk(char *page)
+static void __torture_print_stats(char *page,
+                                  struct lock_stress_stats *statp, bool write)
 {
         bool fail = 0;
-        int i;
+        int i, n_stress;
         long max = 0;
-        long min = lwsa[0].n_lock_acquired;
+        long min = statp[0].n_lock_acquired;
         long long sum = 0;
 
-        for (i = 0; i < nrealwriters_stress; i++) {
-                if (lwsa[i].n_lock_fail)
+        n_stress = write ? nrealwriters_stress : nrealreaders_stress;
+        for (i = 0; i < n_stress; i++) {
+                if (statp[i].n_lock_fail)
                         fail = true;
-                sum += lwsa[i].n_lock_acquired;
-                if (max < lwsa[i].n_lock_fail)
-                        max = lwsa[i].n_lock_fail;
-                if (min > lwsa[i].n_lock_fail)
-                        min = lwsa[i].n_lock_fail;
+                sum += statp[i].n_lock_acquired;
+                if (max < statp[i].n_lock_fail)
+                        max = statp[i].n_lock_fail;
+                if (min > statp[i].n_lock_fail)
+                        min = statp[i].n_lock_fail;
         }
-        page += sprintf(page, "%s%s ", torture_type, TORTURE_FLAG);
         page += sprintf(page,
-                        "Writes:  Total: %lld  Max/Min: %ld/%ld %s  Fail: %d %s\n",
+                        "%s:  Total: %lld  Max/Min: %ld/%ld %s  Fail: %d %s\n",
+                        write ? "Writes" : "Reads ",
                         sum, max, min, max / 2 > min ? "???" : "",
                         fail, fail ? "!!!" : "");
         if (fail)
@@ -315,15 +365,32 @@ static void lock_torture_stats_print(void)
         int size = nrealwriters_stress * 200 + 8192;
         char *buf;
 
+        if (cur_ops->readlock)
+                size += nrealreaders_stress * 200 + 8192;
+
         buf = kmalloc(size, GFP_KERNEL);
         if (!buf) {
                 pr_err("lock_torture_stats_print: Out of memory, need: %d",
                        size);
                 return;
         }
-        lock_torture_printk(buf);
+
+        __torture_print_stats(buf, lwsa, true);
         pr_alert("%s", buf);
         kfree(buf);
+
+        if (cur_ops->readlock) {
+                buf = kmall