Merge commit 'linus/master' into tracing/kprobes

Conflicts:
	kernel/trace/Makefile
	kernel/trace/trace.h
	kernel/trace/trace_event_types.h
	kernel/trace/trace_export.c

Merge reason:
	Sync with latest significant tracing core changes.

1 files changed, 132 insertions, 109 deletions

diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 9b4a975a4b4a..233768f21f97 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -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,11 +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
@@ -257,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.
@@ -281,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)
@@ -320,7 +324,7 @@ 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 void rcu_torture_deferred_free(struct rcu_torture *p)
@@ -329,18 +333,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)
@@ -370,18 +374,18 @@ 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"
 };
 
 /*
@@ -432,33 +436,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"
 };
 
 /*
@@ -530,17 +534,17 @@ 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"
 };
 
 /*
@@ -574,32 +578,49 @@ 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      = sched_torture_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"
+        .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      = sched_torture_completed,
+        .deferred_free  = rcu_sync_torture_deferred_free,
+        .sync           = sched_torture_synchronize,
+        .cb_barrier     = NULL,
+        .stats          = NULL,
+        .name           = "sched_sync"
+};
+
+extern int rcu_expedited_torture_stats(char *page);
+
+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      = sched_torture_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"
 };
 
 /*
@@ -621,7 +642,8 @@ 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);
@@ -635,7 +657,7 @@ rcu_torture_writer(void *arg)
                                 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();
@@ -700,7 +722,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();
@@ -738,11 +760,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);
                 }
@@ -757,7 +779,7 @@ 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) {
@@ -778,7 +800,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);
@@ -1078,6 +1100,7 @@ rcu_torture_init(void)
         int firsterr = 0;
         static struct rcu_torture_ops *torture_ops[] =
                 { &rcu_ops, &rcu_sync_ops, &rcu_bh_ops, &rcu_bh_sync_ops,
+                  &sched_expedited_ops,
                   &srcu_ops, &sched_ops, &sched_ops_sync, };
 
         mutex_lock(&fullstop_mutex);
@@ -1092,7 +1115,7 @@ rcu_torture_init(void)
                 printk(KERN_ALERT "rcutorture: invalid torture type: \"%s\"\n",
                        torture_type);
                 mutex_unlock(&fullstop_mutex);
-                return (-EINVAL);
+                return -EINVAL;
         }
         if (cur_ops->init)
                 cur_ops->init(); /* no "goto unwind" prior to this point!!! */
@@ -1143,7 +1166,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;
@@ -1152,7 +1175,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");