Merge branch 'perf/urgent' into perf/core
[linux-2.6.git] / kernel / rcutorture.c
index 7c4142a..9bb5217 100644 (file)
@@ -18,7 +18,7 @@
  * Copyright (C) IBM Corporation, 2005, 2006
  *
  * Authors: Paul E. McKenney <paulmck@us.ibm.com>
- *          Josh Triplett <josh@freedesktop.org>
+ *       Josh Triplett <josh@freedesktop.org>
  *
  * See also:  Documentation/RCU/torture.txt
  */
@@ -50,7 +50,7 @@
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com> and "
-              "Josh Triplett <josh@freedesktop.org>");
+             "Josh Triplett <josh@freedesktop.org>");
 
 static int nreaders = -1;      /* # reader threads, defaults to 2*ncpus */
 static int nfakewriters = 4;   /* # fake writer threads */
@@ -110,8 +110,8 @@ struct rcu_torture {
 };
 
 static LIST_HEAD(rcu_torture_freelist);
-static struct rcu_torture *rcu_torture_current = NULL;
-static long rcu_torture_current_version = 0;
+static struct rcu_torture *rcu_torture_current;
+static long rcu_torture_current_version;
 static struct rcu_torture rcu_tortures[10 * RCU_TORTURE_PIPE_LEN];
 static DEFINE_SPINLOCK(rcu_torture_lock);
 static DEFINE_PER_CPU(long [RCU_TORTURE_PIPE_LEN + 1], rcu_torture_count) =
@@ -124,10 +124,11 @@ static atomic_t n_rcu_torture_alloc_fail;
 static atomic_t n_rcu_torture_free;
 static atomic_t n_rcu_torture_mberror;
 static atomic_t n_rcu_torture_error;
-static long n_rcu_torture_timers = 0;
+static long n_rcu_torture_timers;
 static struct list_head rcu_torture_removed;
+static cpumask_var_t shuffle_tmp_mask;
 
-static int stutter_pause_test = 0;
+static int stutter_pause_test;
 
 #if defined(MODULE) || defined(CONFIG_RCU_TORTURE_TEST_RUNNABLE)
 #define RCUTORTURE_RUNNABLE_INIT 1
@@ -256,17 +257,18 @@ struct rcu_torture_ops {
        void (*init)(void);
        void (*cleanup)(void);
        int (*readlock)(void);
-       void (*readdelay)(struct rcu_random_state *rrsp);
+       void (*read_delay)(struct rcu_random_state *rrsp);
        void (*readunlock)(int idx);
        int (*completed)(void);
-       void (*deferredfree)(struct rcu_torture *p);
+       void (*deferred_free)(struct rcu_torture *p);
        void (*sync)(void);
        void (*cb_barrier)(void);
        int (*stats)(char *page);
-       int irqcapable;
+       int irq_capable;
        char *name;
 };
-static struct rcu_torture_ops *cur_ops = NULL;
+
+static struct rcu_torture_ops *cur_ops;
 
 /*
  * Definitions for rcu torture testing.
@@ -280,14 +282,17 @@ static int rcu_torture_read_lock(void) __acquires(RCU)
 
 static void rcu_read_delay(struct rcu_random_state *rrsp)
 {
-       long delay;
-       const long longdelay = 200;
+       const unsigned long shortdelay_us = 200;
+       const unsigned long longdelay_ms = 50;
 
-       /* We want there to be long-running readers, but not all the time. */
+       /* We want a short delay sometimes to make a reader delay the grace
+        * period, and we want a long delay occasionally to trigger
+        * force_quiescent_state. */
 
-       delay = rcu_random(rrsp) % (nrealreaders * 2 * longdelay);
-       if (!delay)
-               udelay(longdelay);
+       if (!(rcu_random(rrsp) % (nrealreaders * 2000 * longdelay_ms)))
+               mdelay(longdelay_ms);
+       if (!(rcu_random(rrsp) % (nrealreaders * 2 * shortdelay_us)))
+               udelay(shortdelay_us);
 }
 
 static void rcu_torture_read_unlock(int idx) __releases(RCU)
@@ -319,7 +324,12 @@ rcu_torture_cb(struct rcu_head *p)
                rp->rtort_mbtest = 0;
                rcu_torture_free(rp);
        } else
-               cur_ops->deferredfree(rp);
+               cur_ops->deferred_free(rp);
+}
+
+static int rcu_no_completed(void)
+{
+       return 0;
 }
 
 static void rcu_torture_deferred_free(struct rcu_torture *p)
@@ -328,18 +338,18 @@ static void rcu_torture_deferred_free(struct rcu_torture *p)
 }
 
 static struct rcu_torture_ops rcu_ops = {
-       .init = NULL,
-       .cleanup = NULL,
-       .readlock = rcu_torture_read_lock,
-       .readdelay = rcu_read_delay,
-       .readunlock = rcu_torture_read_unlock,
-       .completed = rcu_torture_completed,
-       .deferredfree = rcu_torture_deferred_free,
-       .sync = synchronize_rcu,
-       .cb_barrier = rcu_barrier,
-       .stats = NULL,
-       .irqcapable = 1,
-       .name = "rcu"
+       .init           = NULL,
+       .cleanup        = NULL,
+       .readlock       = rcu_torture_read_lock,
+       .read_delay     = rcu_read_delay,
+       .readunlock     = rcu_torture_read_unlock,
+       .completed      = rcu_torture_completed,
+       .deferred_free  = rcu_torture_deferred_free,
+       .sync           = synchronize_rcu,
+       .cb_barrier     = rcu_barrier,
+       .stats          = NULL,
+       .irq_capable    = 1,
+       .name           = "rcu"
 };
 
 static void rcu_sync_torture_deferred_free(struct rcu_torture *p)
@@ -369,18 +379,33 @@ static void rcu_sync_torture_init(void)
 }
 
 static struct rcu_torture_ops rcu_sync_ops = {
-       .init = rcu_sync_torture_init,
-       .cleanup = NULL,
-       .readlock = rcu_torture_read_lock,
-       .readdelay = rcu_read_delay,
-       .readunlock = rcu_torture_read_unlock,
-       .completed = rcu_torture_completed,
-       .deferredfree = rcu_sync_torture_deferred_free,
-       .sync = synchronize_rcu,
-       .cb_barrier = NULL,
-       .stats = NULL,
-       .irqcapable = 1,
-       .name = "rcu_sync"
+       .init           = rcu_sync_torture_init,
+       .cleanup        = NULL,
+       .readlock       = rcu_torture_read_lock,
+       .read_delay     = rcu_read_delay,
+       .readunlock     = rcu_torture_read_unlock,
+       .completed      = rcu_torture_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = synchronize_rcu,
+       .cb_barrier     = NULL,
+       .stats          = NULL,
+       .irq_capable    = 1,
+       .name           = "rcu_sync"
+};
+
+static struct rcu_torture_ops rcu_expedited_ops = {
+       .init           = rcu_sync_torture_init,
+       .cleanup        = NULL,
+       .readlock       = rcu_torture_read_lock,
+       .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+       .readunlock     = rcu_torture_read_unlock,
+       .completed      = rcu_no_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = synchronize_rcu_expedited,
+       .cb_barrier     = NULL,
+       .stats          = NULL,
+       .irq_capable    = 1,
+       .name           = "rcu_expedited"
 };
 
 /*
@@ -431,33 +456,33 @@ static void rcu_bh_torture_synchronize(void)
 }
 
 static struct rcu_torture_ops rcu_bh_ops = {
-       .init = NULL,
-       .cleanup = NULL,
-       .readlock = rcu_bh_torture_read_lock,
-       .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-       .readunlock = rcu_bh_torture_read_unlock,
-       .completed = rcu_bh_torture_completed,
-       .deferredfree = rcu_bh_torture_deferred_free,
-       .sync = rcu_bh_torture_synchronize,
-       .cb_barrier = rcu_barrier_bh,
-       .stats = NULL,
-       .irqcapable = 1,
-       .name = "rcu_bh"
+       .init           = NULL,
+       .cleanup        = NULL,
+       .readlock       = rcu_bh_torture_read_lock,
+       .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+       .readunlock     = rcu_bh_torture_read_unlock,
+       .completed      = rcu_bh_torture_completed,
+       .deferred_free  = rcu_bh_torture_deferred_free,
+       .sync           = rcu_bh_torture_synchronize,
+       .cb_barrier     = rcu_barrier_bh,
+       .stats          = NULL,
+       .irq_capable    = 1,
+       .name           = "rcu_bh"
 };
 
 static struct rcu_torture_ops rcu_bh_sync_ops = {
-       .init = rcu_sync_torture_init,
-       .cleanup = NULL,
-       .readlock = rcu_bh_torture_read_lock,
-       .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-       .readunlock = rcu_bh_torture_read_unlock,
-       .completed = rcu_bh_torture_completed,
-       .deferredfree = rcu_sync_torture_deferred_free,
-       .sync = rcu_bh_torture_synchronize,
-       .cb_barrier = NULL,
-       .stats = NULL,
-       .irqcapable = 1,
-       .name = "rcu_bh_sync"
+       .init           = rcu_sync_torture_init,
+       .cleanup        = NULL,
+       .readlock       = rcu_bh_torture_read_lock,
+       .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+       .readunlock     = rcu_bh_torture_read_unlock,
+       .completed      = rcu_bh_torture_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = rcu_bh_torture_synchronize,
+       .cb_barrier     = NULL,
+       .stats          = NULL,
+       .irq_capable    = 1,
+       .name           = "rcu_bh_sync"
 };
 
 /*
@@ -529,17 +554,36 @@ static int srcu_torture_stats(char *page)
 }
 
 static struct rcu_torture_ops srcu_ops = {
-       .init = srcu_torture_init,
-       .cleanup = srcu_torture_cleanup,
-       .readlock = srcu_torture_read_lock,
-       .readdelay = srcu_read_delay,
-       .readunlock = srcu_torture_read_unlock,
-       .completed = srcu_torture_completed,
-       .deferredfree = rcu_sync_torture_deferred_free,
-       .sync = srcu_torture_synchronize,
-       .cb_barrier = NULL,
-       .stats = srcu_torture_stats,
-       .name = "srcu"
+       .init           = srcu_torture_init,
+       .cleanup        = srcu_torture_cleanup,
+       .readlock       = srcu_torture_read_lock,
+       .read_delay     = srcu_read_delay,
+       .readunlock     = srcu_torture_read_unlock,
+       .completed      = srcu_torture_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = srcu_torture_synchronize,
+       .cb_barrier     = NULL,
+       .stats          = srcu_torture_stats,
+       .name           = "srcu"
+};
+
+static void srcu_torture_synchronize_expedited(void)
+{
+       synchronize_srcu_expedited(&srcu_ctl);
+}
+
+static struct rcu_torture_ops srcu_expedited_ops = {
+       .init           = srcu_torture_init,
+       .cleanup        = srcu_torture_cleanup,
+       .readlock       = srcu_torture_read_lock,
+       .read_delay     = srcu_read_delay,
+       .readunlock     = srcu_torture_read_unlock,
+       .completed      = srcu_torture_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = srcu_torture_synchronize_expedited,
+       .cb_barrier     = NULL,
+       .stats          = srcu_torture_stats,
+       .name           = "srcu_expedited"
 };
 
 /*
@@ -557,11 +601,6 @@ static void sched_torture_read_unlock(int idx)
        preempt_enable();
 }
 
-static int sched_torture_completed(void)
-{
-       return 0;
-}
-
 static void rcu_sched_torture_deferred_free(struct rcu_torture *p)
 {
        call_rcu_sched(&p->rtort_rcu, rcu_torture_cb);
@@ -573,32 +612,47 @@ static void sched_torture_synchronize(void)
 }
 
 static struct rcu_torture_ops sched_ops = {
-       .init = rcu_sync_torture_init,
-       .cleanup = NULL,
-       .readlock = sched_torture_read_lock,
-       .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-       .readunlock = sched_torture_read_unlock,
-       .completed = sched_torture_completed,
-       .deferredfree = rcu_sched_torture_deferred_free,
-       .sync = sched_torture_synchronize,
-       .cb_barrier = rcu_barrier_sched,
-       .stats = NULL,
-       .irqcapable = 1,
-       .name = "sched"
+       .init           = rcu_sync_torture_init,
+       .cleanup        = NULL,
+       .readlock       = sched_torture_read_lock,
+       .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+       .readunlock     = sched_torture_read_unlock,
+       .completed      = rcu_no_completed,
+       .deferred_free  = rcu_sched_torture_deferred_free,
+       .sync           = sched_torture_synchronize,
+       .cb_barrier     = rcu_barrier_sched,
+       .stats          = NULL,
+       .irq_capable    = 1,
+       .name           = "sched"
 };
 
-static struct rcu_torture_ops sched_ops_sync = {
-       .init = rcu_sync_torture_init,
-       .cleanup = NULL,
-       .readlock = sched_torture_read_lock,
-       .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-       .readunlock = sched_torture_read_unlock,
-       .completed = sched_torture_completed,
-       .deferredfree = rcu_sync_torture_deferred_free,
-       .sync = sched_torture_synchronize,
-       .cb_barrier = NULL,
-       .stats = NULL,
-       .name = "sched_sync"
+static struct rcu_torture_ops sched_sync_ops = {
+       .init           = rcu_sync_torture_init,
+       .cleanup        = NULL,
+       .readlock       = sched_torture_read_lock,
+       .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+       .readunlock     = sched_torture_read_unlock,
+       .completed      = rcu_no_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = sched_torture_synchronize,
+       .cb_barrier     = NULL,
+       .stats          = NULL,
+       .name           = "sched_sync"
+};
+
+static struct rcu_torture_ops sched_expedited_ops = {
+       .init           = rcu_sync_torture_init,
+       .cleanup        = NULL,
+       .readlock       = sched_torture_read_lock,
+       .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+       .readunlock     = sched_torture_read_unlock,
+       .completed      = rcu_no_completed,
+       .deferred_free  = rcu_sync_torture_deferred_free,
+       .sync           = synchronize_sched_expedited,
+       .cb_barrier     = NULL,
+       .stats          = rcu_expedited_torture_stats,
+       .irq_capable    = 1,
+       .name           = "sched_expedited"
 };
 
 /*
@@ -620,21 +674,22 @@ rcu_torture_writer(void *arg)
 
        do {
                schedule_timeout_uninterruptible(1);
-               if ((rp = rcu_torture_alloc()) == NULL)
+               rp = rcu_torture_alloc();
+               if (rp == NULL)
                        continue;
                rp->rtort_pipe_count = 0;
                udelay(rcu_random(&rand) & 0x3ff);
                old_rp = rcu_torture_current;
                rp->rtort_mbtest = 1;
                rcu_assign_pointer(rcu_torture_current, rp);
-               smp_wmb();
+               smp_wmb(); /* Mods to old_rp must follow rcu_assign_pointer() */
                if (old_rp) {
                        i = old_rp->rtort_pipe_count;
                        if (i > RCU_TORTURE_PIPE_LEN)
                                i = RCU_TORTURE_PIPE_LEN;
                        atomic_inc(&rcu_torture_wcount[i]);
                        old_rp->rtort_pipe_count++;
-                       cur_ops->deferredfree(old_rp);
+                       cur_ops->deferred_free(old_rp);
                }
                rcu_torture_current_version++;
                oldbatch = cur_ops->completed();
@@ -699,7 +754,7 @@ static void rcu_torture_timer(unsigned long unused)
        if (p->rtort_mbtest == 0)
                atomic_inc(&n_rcu_torture_mberror);
        spin_lock(&rand_lock);
-       cur_ops->readdelay(&rand);
+       cur_ops->read_delay(&rand);
        n_rcu_torture_timers++;
        spin_unlock(&rand_lock);
        preempt_disable();
@@ -708,13 +763,13 @@ static void rcu_torture_timer(unsigned long unused)
                /* Should not happen, but... */
                pipe_count = RCU_TORTURE_PIPE_LEN;
        }
-       ++__get_cpu_var(rcu_torture_count)[pipe_count];
+       __this_cpu_inc(per_cpu_var(rcu_torture_count)[pipe_count]);
        completed = cur_ops->completed() - completed;
        if (completed > RCU_TORTURE_PIPE_LEN) {
                /* Should not happen, but... */
                completed = RCU_TORTURE_PIPE_LEN;
        }
-       ++__get_cpu_var(rcu_torture_batch)[completed];
+       __this_cpu_inc(per_cpu_var(rcu_torture_batch)[completed]);
        preempt_enable();
        cur_ops->readunlock(idx);
 }
@@ -737,11 +792,11 @@ rcu_torture_reader(void *arg)
 
        VERBOSE_PRINTK_STRING("rcu_torture_reader task started");
        set_user_nice(current, 19);
-       if (irqreader && cur_ops->irqcapable)
+       if (irqreader && cur_ops->irq_capable)
                setup_timer_on_stack(&t, rcu_torture_timer, 0);
 
        do {
-               if (irqreader && cur_ops->irqcapable) {
+               if (irqreader && cur_ops->irq_capable) {
                        if (!timer_pending(&t))
                                mod_timer(&t, 1);
                }
@@ -756,20 +811,20 @@ rcu_torture_reader(void *arg)
                }
                if (p->rtort_mbtest == 0)
                        atomic_inc(&n_rcu_torture_mberror);
-               cur_ops->readdelay(&rand);
+               cur_ops->read_delay(&rand);
                preempt_disable();
                pipe_count = p->rtort_pipe_count;
                if (pipe_count > RCU_TORTURE_PIPE_LEN) {
                        /* Should not happen, but... */
                        pipe_count = RCU_TORTURE_PIPE_LEN;
                }
-               ++__get_cpu_var(rcu_torture_count)[pipe_count];
+               __this_cpu_inc(per_cpu_var(rcu_torture_count)[pipe_count]);
                completed = cur_ops->completed() - completed;
                if (completed > RCU_TORTURE_PIPE_LEN) {
                        /* Should not happen, but... */
                        completed = RCU_TORTURE_PIPE_LEN;
                }
-               ++__get_cpu_var(rcu_torture_batch)[completed];
+               __this_cpu_inc(per_cpu_var(rcu_torture_batch)[completed]);
                preempt_enable();
                cur_ops->readunlock(idx);
                schedule();
@@ -777,7 +832,7 @@ rcu_torture_reader(void *arg)
        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
        VERBOSE_PRINTK_STRING("rcu_torture_reader task stopping");
        rcutorture_shutdown_absorb("rcu_torture_reader");
-       if (irqreader && cur_ops->irqcapable)
+       if (irqreader && cur_ops->irq_capable)
                del_timer_sync(&t);
        while (!kthread_should_stop())
                schedule_timeout_uninterruptible(1);
@@ -889,10 +944,9 @@ static int rcu_idle_cpu;   /* Force all torture tasks off this CPU */
  */
 static void rcu_torture_shuffle_tasks(void)
 {
-       cpumask_t tmp_mask;
        int i;
 
-       cpus_setall(tmp_mask);
+       cpumask_setall(shuffle_tmp_mask);
        get_online_cpus();
 
        /* No point in shuffling if there is only one online CPU (ex: UP) */
@@ -902,29 +956,29 @@ static void rcu_torture_shuffle_tasks(void)
        }
 
        if (rcu_idle_cpu != -1)
-               cpu_clear(rcu_idle_cpu, tmp_mask);
+               cpumask_clear_cpu(rcu_idle_cpu, shuffle_tmp_mask);
 
-       set_cpus_allowed_ptr(current, &tmp_mask);
+       set_cpus_allowed_ptr(current, shuffle_tmp_mask);
 
        if (reader_tasks) {
                for (i = 0; i < nrealreaders; i++)
                        if (reader_tasks[i])
                                set_cpus_allowed_ptr(reader_tasks[i],
-                                                    &tmp_mask);
+                                                    shuffle_tmp_mask);
        }
 
        if (fakewriter_tasks) {
                for (i = 0; i < nfakewriters; i++)
                        if (fakewriter_tasks[i])
                                set_cpus_allowed_ptr(fakewriter_tasks[i],
-                                                    &tmp_mask);
+                                                    shuffle_tmp_mask);
        }
 
        if (writer_task)
-               set_cpus_allowed_ptr(writer_task, &tmp_mask);
+               set_cpus_allowed_ptr(writer_task, shuffle_tmp_mask);
 
        if (stats_task)
-               set_cpus_allowed_ptr(stats_task, &tmp_mask);
+               set_cpus_allowed_ptr(stats_task, shuffle_tmp_mask);
 
        if (rcu_idle_cpu == -1)
                rcu_idle_cpu = num_online_cpus() - 1;
@@ -1012,6 +1066,7 @@ rcu_torture_cleanup(void)
        if (shuffler_task) {
                VERBOSE_PRINTK_STRING("Stopping rcu_torture_shuffle task");
                kthread_stop(shuffler_task);
+               free_cpumask_var(shuffle_tmp_mask);
        }
        shuffler_task = NULL;
 
@@ -1076,8 +1131,10 @@ rcu_torture_init(void)
        int cpu;
        int firsterr = 0;
        static struct rcu_torture_ops *torture_ops[] =
-               { &rcu_ops, &rcu_sync_ops, &rcu_bh_ops, &rcu_bh_sync_ops,
-                 &srcu_ops, &sched_ops, &sched_ops_sync, };
+               { &rcu_ops, &rcu_sync_ops, &rcu_expedited_ops,
+                 &rcu_bh_ops, &rcu_bh_sync_ops,
+                 &srcu_ops, &srcu_expedited_ops,
+                 &sched_ops, &sched_sync_ops, &sched_expedited_ops, };
 
        mutex_lock(&fullstop_mutex);
 
@@ -1088,10 +1145,14 @@ rcu_torture_init(void)
                        break;
        }
        if (i == ARRAY_SIZE(torture_ops)) {
-               printk(KERN_ALERT "rcutorture: invalid torture type: \"%s\"\n",
+               printk(KERN_ALERT "rcu-torture: invalid torture type: \"%s\"\n",
                       torture_type);
+               printk(KERN_ALERT "rcu-torture types:");
+               for (i = 0; i < ARRAY_SIZE(torture_ops); i++)
+                       printk(KERN_ALERT " %s", torture_ops[i]->name);
+               printk(KERN_ALERT "\n");
                mutex_unlock(&fullstop_mutex);
-               return (-EINVAL);
+               return -EINVAL;
        }
        if (cur_ops->init)
                cur_ops->init(); /* no "goto unwind" prior to this point!!! */
@@ -1142,7 +1203,7 @@ rcu_torture_init(void)
                goto unwind;
        }
        fakewriter_tasks = kzalloc(nfakewriters * sizeof(fakewriter_tasks[0]),
-                                  GFP_KERNEL);
+                                  GFP_KERNEL);
        if (fakewriter_tasks == NULL) {
                VERBOSE_PRINTK_ERRSTRING("out of memory");
                firsterr = -ENOMEM;
@@ -1151,7 +1212,7 @@ rcu_torture_init(void)
        for (i = 0; i < nfakewriters; i++) {
                VERBOSE_PRINTK_STRING("Creating rcu_torture_fakewriter task");
                fakewriter_tasks[i] = kthread_run(rcu_torture_fakewriter, NULL,
-                                                 "rcu_torture_fakewriter");
+                                                 "rcu_torture_fakewriter");
                if (IS_ERR(fakewriter_tasks[i])) {
                        firsterr = PTR_ERR(fakewriter_tasks[i]);
                        VERBOSE_PRINTK_ERRSTRING("Failed to create fakewriter");
@@ -1190,10 +1251,18 @@ rcu_torture_init(void)
        }
        if (test_no_idle_hz) {
                rcu_idle_cpu = num_online_cpus() - 1;
+
+               if (!alloc_cpumask_var(&shuffle_tmp_mask, GFP_KERNEL)) {
+                       firsterr = -ENOMEM;
+                       VERBOSE_PRINTK_ERRSTRING("Failed to alloc mask");
+                       goto unwind;
+               }
+
                /* Create the shuffler thread */
                shuffler_task = kthread_run(rcu_torture_shuffle, NULL,
                                          "rcu_torture_shuffle");
                if (IS_ERR(shuffler_task)) {
+                       free_cpumask_var(shuffle_tmp_mask);
                        firsterr = PTR_ERR(shuffler_task);
                        VERBOSE_PRINTK_ERRSTRING("Failed to create shuffler");
                        shuffler_task = NULL;