79 files changed, 6375 insertions, 2038 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 9a3ec66a9d84..6a212b842d86 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -11,8 +11,6 @@ obj-y     = sched.o fork.o exec_domain.o panic.o printk.o \
             hrtimer.o rwsem.o nsproxy.o srcu.o semaphore.o \
             notifier.o ksysfs.o pm_qos_params.o sched_clock.o
 
-CFLAGS_REMOVE_sched.o = -mno-spe
-
 ifdef CONFIG_FUNCTION_TRACER
 # Do not trace debug files and internal ftrace files
 CFLAGS_REMOVE_lockdep.o = -pg
@@ -21,7 +19,6 @@ CFLAGS_REMOVE_mutex-debug.o = -pg
 CFLAGS_REMOVE_rtmutex-debug.o = -pg
 CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_sched_clock.o = -pg
-CFLAGS_REMOVE_sched.o = -mno-spe -pg
 endif
 
 obj-$(CONFIG_FREEZER) += freezer.o
@@ -92,7 +89,7 @@ obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
 
-ifneq ($(CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER),y)
+ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
 # needed for x86 only.  Why this used to be enabled for all architectures is beyond
 # me.  I suspect most platforms don't need this, but until we know that for sure
diff --git a/kernel/audit.c b/kernel/audit.c
index 4414e93d8750..ce6d8ea3131e 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -61,8 +61,11 @@
 
 #include "audit.h"
 
-/* No auditing will take place until audit_initialized != 0.
+/* No auditing will take place until audit_initialized == AUDIT_INITIALIZED.
  * (Initialization happens after skb_init is called.) */
+#define AUDIT_DISABLED          -1
+#define AUDIT_UNINITIALIZED     0
+#define AUDIT_INITIALIZED       1
 static int      audit_initialized;
 
 #define AUDIT_OFF       0
@@ -965,6 +968,9 @@ static int __init audit_init(void)
 {
         int i;
 
+        if (audit_initialized == AUDIT_DISABLED)
+                return 0;
+
         printk(KERN_INFO "audit: initializing netlink socket (%s)\n",
                audit_default ? "enabled" : "disabled");
         audit_sock = netlink_kernel_create(&init_net, NETLINK_AUDIT, 0,
@@ -976,7 +982,7 @@ static int __init audit_init(void)
 
         skb_queue_head_init(&audit_skb_queue);
         skb_queue_head_init(&audit_skb_hold_queue);
-        audit_initialized = 1;
+        audit_initialized = AUDIT_INITIALIZED;
         audit_enabled = audit_default;
         audit_ever_enabled |= !!audit_default;
 
@@ -999,13 +1005,21 @@ __initcall(audit_init);
 static int __init audit_enable(char *str)
 {
         audit_default = !!simple_strtol(str, NULL, 0);
-        printk(KERN_INFO "audit: %s%s\n",
-               audit_default ? "enabled" : "disabled",
-               audit_initialized ? "" : " (after initialization)");
-        if (audit_initialized) {
+        if (!audit_default)
+                audit_initialized = AUDIT_DISABLED;
+
+        printk(KERN_INFO "audit: %s", audit_default ? "enabled" : "disabled");
+
+        if (audit_initialized == AUDIT_INITIALIZED) {
                 audit_enabled = audit_default;
                 audit_ever_enabled |= !!audit_default;
+        } else if (audit_initialized == AUDIT_UNINITIALIZED) {
+                printk(" (after initialization)");
+        } else {
+                printk(" (until reboot)");
         }
+        printk("\n");
+
         return 1;
 }
 
@@ -1107,9 +1121,7 @@ unsigned int audit_serial(void)
 static inline void audit_get_stamp(struct audit_context *ctx,
                                    struct timespec *t, unsigned int *serial)
 {
-        if (ctx)
-                auditsc_get_stamp(ctx, t, serial);
-        else {
+        if (!ctx || !auditsc_get_stamp(ctx, t, serial)) {
                 *t = CURRENT_TIME;
                 *serial = audit_serial();
         }
@@ -1146,7 +1158,7 @@ struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask,
         int reserve;
         unsigned long timeout_start = jiffies;
 
-        if (!audit_initialized)
+        if (audit_initialized != AUDIT_INITIALIZED)
                 return NULL;
 
         if (unlikely(audit_filter_type(type)))
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index 8ba0e0d934f2..8b509441f49a 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -24,6 +24,7 @@ struct audit_chunk {
         struct list_head trees;         /* with root here */
         int dead;
         int count;
+        atomic_long_t refs;
         struct rcu_head head;
         struct node {
                 struct list_head list;
@@ -56,7 +57,8 @@ static LIST_HEAD(prune_list);
  * tree is refcounted; one reference for "some rules on rules_list refer to
  * it", one for each chunk with pointer to it.
  *
- * chunk is refcounted by embedded inotify_watch.
+ * chunk is refcounted by embedded inotify_watch + .refs (non-zero refcount
+ * of watch contributes 1 to .refs).
  *
  * node.index allows to get from node.list to containing chunk.
  * MSB of that sucker is stolen to mark taggings that we might have to
@@ -121,6 +123,7 @@ static struct audit_chunk *alloc_chunk(int count)
         INIT_LIST_HEAD(&chunk->hash);
         INIT_LIST_HEAD(&chunk->trees);
         chunk->count = count;
+        atomic_long_set(&chunk->refs, 1);
         for (i = 0; i < count; i++) {
                 INIT_LIST_HEAD(&chunk->owners[i].list);
                 chunk->owners[i].index = i;
@@ -129,9 +132,8 @@ static struct audit_chunk *alloc_chunk(int count)
         return chunk;
 }
 
-static void __free_chunk(struct rcu_head *rcu)
+static void free_chunk(struct audit_chunk *chunk)
 {
-        struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head);
         int i;
 
         for (i = 0; i < chunk->count; i++) {
@@ -141,14 +143,16 @@ static void __free_chunk(struct rcu_head *rcu)
         kfree(chunk);
 }
 
-static inline void free_chunk(struct audit_chunk *chunk)
+void audit_put_chunk(struct audit_chunk *chunk)
 {
-        call_rcu(&chunk->head, __free_chunk);
+        if (atomic_long_dec_and_test(&chunk->refs))
+                free_chunk(chunk);
 }
 
-void audit_put_chunk(struct audit_chunk *chunk)
+static void __put_chunk(struct rcu_head *rcu)
 {
-        put_inotify_watch(&chunk->watch);
+        struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head);
+        audit_put_chunk(chunk);
 }
 
 enum {HASH_SIZE = 128};
@@ -176,7 +180,7 @@ struct audit_chunk *audit_tree_lookup(const struct inode *inode)
 
         list_for_each_entry_rcu(p, list, hash) {
                 if (p->watch.inode == inode) {
-                        get_inotify_watch(&p->watch);
+                        atomic_long_inc(&p->refs);
                         return p;
                 }
         }
@@ -194,17 +198,49 @@ int audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)
 
 /* tagging and untagging inodes with trees */
 
-static void untag_chunk(struct audit_chunk *chunk, struct node *p)
+static struct audit_chunk *find_chunk(struct node *p)
+{
+        int index = p->index & ~(1U<<31);
+        p -= index;
+        return container_of(p, struct audit_chunk, owners[0]);
+}
+
+static void untag_chunk(struct node *p)
 {
+        struct audit_chunk *chunk = find_chunk(p);
         struct audit_chunk *new;
         struct audit_tree *owner;
         int size = chunk->count - 1;
         int i, j;
 
+        if (!pin_inotify_watch(&chunk->watch)) {
+                /*
+                 * Filesystem is shutting down; all watches are getting
+                 * evicted, just take it off the node list for this
+                 * tree and let the eviction logics take care of the
+                 * rest.
+                 */
+                owner = p->owner;
+                if (owner->root == chunk) {
+                        list_del_init(&owner->same_root);
+                        owner->root = NULL;
+                }
+                list_del_init(&p->list);
+                p->owner = NULL;
+                put_tree(owner);
+                return;
+        }
+
+        spin_unlock(&hash_lock);
+
+        /*
+         * pin_inotify_watch() succeeded, so the watch won't go away
+         * from under us.
+         */
         mutex_lock(&chunk->watch.inode->inotify_mutex);
         if (chunk->dead) {
                 mutex_unlock(&chunk->watch.inode->inotify_mutex);
-                return;
+                goto out;
         }
 
         owner = p->owner;
@@ -221,7 +257,7 @@ static void untag_chunk(struct audit_chunk *chunk, struct node *p)
                 inotify_evict_watch(&chunk->watch);
                 mutex_unlock(&chunk->watch.inode->inotify_mutex);
                 put_inotify_watch(&chunk->watch);
-                return;
+                goto out;
         }
 
         new = alloc_chunk(size);
@@ -263,7 +299,7 @@ static void untag_chunk(struct audit_chunk *chunk, struct node *p)
         inotify_evict_watch(&chunk->watch);
         mutex_unlock(&chunk->watch.inode->inotify_mutex);
         put_inotify_watch(&chunk->watch);
-        return;
+        goto out;
 
 Fallback:
         // do the best we can
@@ -277,6 +313,9 @@ Fallback:
         put_tree(owner);
         spin_unlock(&hash_lock);
         mutex_unlock(&chunk->watch.inode->inotify_mutex);
+out:
+        unpin_inotify_watch(&chunk->watch);
+        spin_lock(&hash_lock);
 }
 
 static int create_chunk(struct inode *inode, struct audit_tree *tree)
@@ -387,13 +426,6 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
         return 0;
 }
 
-static struct audit_chunk *find_chunk(struct node *p)
-{
-        int index = p->index & ~(1U<<31);
-        p -= index;
-        return container_of(p, struct audit_chunk, owners[0]);
-}
-
 static void kill_rules(struct audit_tree *tree)
 {
         struct audit_krule *rule, *next;
@@ -431,17 +463,10 @@ static void prune_one(struct audit_tree *victim)
         spin_lock(&hash_lock);
         while (!list_empty(&victim->chunks)) {
                 struct node *p;
-                struct audit_chunk *chunk;
 
                 p = list_entry(victim->chunks.next, struct node, list);
-                chunk = find_chunk(p);
-                get_inotify_watch(&chunk->watch);
-                spin_unlock(&hash_lock);
-
-                untag_chunk(chunk, p);
 
-                put_inotify_watch(&chunk->watch);
-                spin_lock(&hash_lock);
+                untag_chunk(p);
         }
         spin_unlock(&hash_lock);
         put_tree(victim);
@@ -469,7 +494,6 @@ static void trim_marked(struct audit_tree *tree)
 
         while (!list_empty(&tree->chunks)) {
                 struct node *node;
-                struct audit_chunk *chunk;
 
                 node = list_entry(tree->chunks.next, struct node, list);
 
@@ -477,14 +501,7 @@ static void trim_marked(struct audit_tree *tree)
                 if (!(node->index & (1U<<31)))
                         break;
 
-                chunk = find_chunk(node);
-                get_inotify_watch(&chunk->watch);
-                spin_unlock(&hash_lock);
-
-                untag_chunk(chunk, node);
-
-                put_inotify_watch(&chunk->watch);
-                spin_lock(&hash_lock);
+                untag_chunk(node);
         }
         if (!tree->root && !tree->goner) {
                 tree->goner = 1;
@@ -878,7 +895,7 @@ static void handle_event(struct inotify_watch *watch, u32 wd, u32 mask,
 static void destroy_watch(struct inotify_watch *watch)
 {
         struct audit_chunk *chunk = container_of(watch, struct audit_chunk, watch);
-        free_chunk(chunk);
+        call_rcu(&chunk->head, __put_chunk);
 }
 
 static const struct inotify_operations rtree_inotify_ops = {
diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index b7d354e2b0ef..9fd85a4640a0 100644
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -1094,8 +1094,8 @@ static void audit_inotify_unregister(struct list_head *in_list)
         list_for_each_entry_safe(p, n, in_list, ilist) {
                 list_del(&p->ilist);
                 inotify_rm_watch(audit_ih, &p->wdata);
-                /* the put matching the get in audit_do_del_rule() */
-                put_inotify_watch(&p->wdata);
+                /* the unpin matching the pin in audit_do_del_rule() */
+                unpin_inotify_watch(&p->wdata);
         }
 }
 
@@ -1389,9 +1389,13 @@ static inline int audit_del_rule(struct audit_entry *entry,
                                 /* Put parent on the inotify un-registration
                                  * list.  Grab a reference before releasing
                                  * audit_filter_mutex, to be released in
-                                 * audit_inotify_unregister(). */
-                                list_add(&parent->ilist, &inotify_list);
-                                get_inotify_watch(&parent->wdata);
+                                 * audit_inotify_unregister().
+                                 * If filesystem is going away, just leave
+                                 * the sucker alone, eviction will take
+                                 * care of it.
+                                 */
+                                if (pin_inotify_watch(&parent->wdata))
+                                        list_add(&parent->ilist, &inotify_list);
                         }
                 }
         }
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index cf5bc2f5f9c3..2a3f0afc4d2a 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -1459,7 +1459,6 @@ void audit_free(struct task_struct *tsk)
 
 /**
  * audit_syscall_entry - fill in an audit record at syscall entry
- * @tsk: task being audited
  * @arch: architecture type
  * @major: major syscall type (function)
  * @a1: additional syscall register 1
@@ -1548,9 +1547,25 @@ void audit_syscall_entry(int arch, int major,
         context->ppid       = 0;
 }
 
+void audit_finish_fork(struct task_struct *child)
+{
+        struct audit_context *ctx = current->audit_context;
+        struct audit_context *p = child->audit_context;
+        if (!p || !ctx || !ctx->auditable)
+                return;
+        p->arch = ctx->arch;
+        p->major = ctx->major;
+        memcpy(p->argv, ctx->argv, sizeof(ctx->argv));
+        p->ctime = ctx->ctime;
+        p->dummy = ctx->dummy;
+        p->auditable = ctx->auditable;
+        p->in_syscall = ctx->in_syscall;
+        p->filterkey = kstrdup(ctx->filterkey, GFP_KERNEL);
+        p->ppid = current->pid;
+}
+
 /**
  * audit_syscall_exit - deallocate audit context after a system call
- * @tsk: task being audited
  * @valid: success/failure flag
  * @return_code: syscall return value
  *
@@ -1942,15 +1957,18 @@ EXPORT_SYMBOL_GPL(__audit_inode_child);
  *
  * Also sets the context as auditable.
  */
-void auditsc_get_stamp(struct audit_context *ctx,
+int auditsc_get_stamp(struct audit_context *ctx,
                        struct timespec *t, unsigned int *serial)
 {
+        if (!ctx->in_syscall)
+                return 0;
         if (!ctx->serial)
                 ctx->serial = audit_serial();
         t->tv_sec  = ctx->ctime.tv_sec;
         t->tv_nsec = ctx->ctime.tv_nsec;
         *serial    = ctx->serial;
         ctx->auditable = 1;
+        return 1;
 }
 
 /* global counter which is incremented every time something logs in */
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 358e77564e6f..fe00b3b983a8 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2039,10 +2039,13 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
         struct cgroup *cgrp;
         struct cgroup_iter it;
         struct task_struct *tsk;
+
         /*
-         * Validate dentry by checking the superblock operations
+         * Validate dentry by checking the superblock operations,
+         * and make sure it's a directory.
          */
-        if (dentry->d_sb->s_op != &cgroup_ops)
+        if (dentry->d_sb->s_op != &cgroup_ops ||
+            !S_ISDIR(dentry->d_inode->i_mode))
                  goto err;
 
         ret = 0;
@@ -2472,10 +2475,7 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
                 mutex_unlock(&cgroup_mutex);
                 return -EBUSY;
         }
-
-        parent = cgrp->parent;
-        root = cgrp->root;
-        sb = root->sb;
+        mutex_unlock(&cgroup_mutex);
 
         /*
          * Call pre_destroy handlers of subsys. Notify subsystems
@@ -2483,7 +2483,14 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
          */
         cgroup_call_pre_destroy(cgrp);
 
-        if (cgroup_has_css_refs(cgrp)) {
+        mutex_lock(&cgroup_mutex);
+        parent = cgrp->parent;
+        root = cgrp->root;
+        sb = root->sb;
+
+        if (atomic_read(&cgrp->count)
+            || !list_empty(&cgrp->children)
+            || cgroup_has_css_refs(cgrp)) {
                 mutex_unlock(&cgroup_mutex);
                 return -EBUSY;
         }
diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c
index 7fa476f01d05..fb249e2bcada 100644
--- a/kernel/cgroup_freezer.c
+++ b/kernel/cgroup_freezer.c
@@ -184,9 +184,20 @@ static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
 {
         struct freezer *freezer;
 
-        task_lock(task);
+        /*
+         * No lock is needed, since the task isn't on tasklist yet,
+         * so it can't be moved to another cgroup, which means the
+         * freezer won't be removed and will be valid during this
+         * function call.
+         */
         freezer = task_freezer(task);
-        task_unlock(task);
+
+        /*
+         * The root cgroup is non-freezable, so we can skip the
+         * following check.
+         */
+        if (!freezer->css.cgroup->parent)
+                return;
 
         spin_lock_irq(&freezer->lock);
         BUG_ON(freezer->state == CGROUP_FROZEN);
@@ -331,7 +342,7 @@ static int freezer_write(struct cgroup *cgroup,
         else if (strcmp(buffer, freezer_state_strs[CGROUP_FROZEN]) == 0)
                 goal_state = CGROUP_FROZEN;
         else
-                return -EIO;
+                return -EINVAL;
 
         if (!cgroup_lock_live_group(cgroup))
                 return -ENODEV;
@@ -350,6 +361,8 @@ static struct cftype files[] = {
 
 static int freezer_populate(struct cgroup_subsys *ss, struct cgroup *cgroup)
 {
+        if (!cgroup->parent)
+                return 0;
         return cgroup_add_files(cgroup, ss, files, ARRAY_SIZE(files));
 }
 
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 5a732c5ef08b..8ea32e8d68b0 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -462,7 +462,7 @@ out:
  * It must be called by the arch code on the new cpu, before the new cpu
  * enables interrupts and before the "boot" cpu returns from __cpu_up().
  */
-void notify_cpu_starting(unsigned int cpu)
+void __cpuinit notify_cpu_starting(unsigned int cpu)
 {
         unsigned long val = CPU_STARTING;
 
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 3e00526f52ec..96c0ba13b8cd 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -36,6 +36,7 @@
 #include <linux/list.h>
 #include <linux/mempolicy.h>
 #include <linux/mm.h>
+#include <linux/memory.h>
 #include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
@@ -584,10 +585,9 @@ static int generate_sched_domains(cpumask_t **domains,
         int i, j, k;            /* indices for partition finding loops */
         cpumask_t *doms;        /* resulting partition; i.e. sched domains */
         struct sched_domain_attr *dattr;  /* attributes for custom domains */
-        int ndoms;              /* number of sched domains in result */
+        int ndoms = 0;          /* number of sched domains in result */
         int nslot;              /* next empty doms[] cpumask_t slot */
 
-        ndoms = 0;
         doms = NULL;
         dattr = NULL;
         csa = NULL;
@@ -674,10 +674,8 @@ restart:
          * Convert <csn, csa> to <ndoms, doms> and populate cpu masks.
          */
         doms = kmalloc(ndoms * sizeof(cpumask_t), GFP_KERNEL);
-        if (!doms) {
-                ndoms = 0;
+        if (!doms)
                 goto done;
-        }
 
         /*
          * The rest of the code, including the scheduler, can deal with
@@ -732,6 +730,13 @@ restart:
 done:
         kfree(csa);
 
+        /*
+         * Fallback to the default domain if kmalloc() failed.
+         * See comments in partition_sched_domains().
+         */
+        if (doms == NULL)
+                ndoms = 1;
+
         *domains    = doms;
         *attributes = dattr;
         return ndoms;
@@ -2011,12 +2016,23 @@ static int cpuset_track_online_cpus(struct notifier_block *unused_nb,
  * Call this routine anytime after node_states[N_HIGH_MEMORY] changes.
  * See also the previous routine cpuset_track_online_cpus().
  */
-void cpuset_track_online_nodes(void)
+static int cpuset_track_online_nodes(struct notifier_block *self,
+                                unsigned long action, void *arg)
 {
         cgroup_lock();
-        top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
-        scan_for_empty_cpusets(&top_cpuset);
+        switch (action) {
+        case MEM_ONLINE:
+                top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+                break;
+        case MEM_OFFLINE:
+                top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+                scan_for_empty_cpusets(&top_cpuset);
+                break;
+        default:
+                break;
+        }
         cgroup_unlock();
+        return NOTIFY_OK;
 }
 #endif
 
@@ -2032,6 +2048,7 @@ void __init cpuset_init_smp(void)
         top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
 
         hotcpu_notifier(cpuset_track_online_cpus, 0);
+        hotplug_memory_notifier(cpuset_track_online_nodes, 10);
 }
 
 /**
diff --git a/kernel/exit.c b/kernel/exit.c
index 80137a5d9467..61ba5b4b10cf 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -40,7 +40,6 @@
 #include <linux/cn_proc.h>
 #include <linux/mutex.h>
 #include <linux/futex.h>
-#include <linux/compat.h>
 #include <linux/pipe_fs_i.h>
 #include <linux/audit.h> /* for audit_free() */
 #include <linux/resource.h>
@@ -54,6 +53,10 @@
 #include <asm/pgtable.h>
 #include <asm/mmu_context.h>
 
+DEFINE_TRACE(sched_process_free);
+DEFINE_TRACE(sched_process_exit);
+DEFINE_TRACE(sched_process_wait);
+
 static void exit_mm(struct task_struct * tsk);
 
 static inline int task_detached(struct task_struct *p)
@@ -141,6 +144,11 @@ static void __exit_signal(struct task_struct *tsk)
         if (sig) {
                 flush_sigqueue(&sig->shared_pending);
                 taskstats_tgid_free(sig);
+                /*
+                 * Make sure ->signal can't go away under rq->lock,
+                 * see account_group_exec_runtime().
+                 */
+                task_rq_unlock_wait(tsk);
                 __cleanup_signal(sig);
         }
 }
@@ -1054,14 +1062,6 @@ NORET_TYPE void do_exit(long code)
                 exit_itimers(tsk->signal);
         }
         acct_collect(code, group_dead);
-#ifdef CONFIG_FUTEX
-        if (unlikely(tsk->robust_list))
-                exit_robust_list(tsk);
-#ifdef CONFIG_COMPAT
-        if (unlikely(tsk->compat_robust_list))
-                compat_exit_robust_list(tsk);
-#endif
-#endif
         if (group_dead)
                 tty_audit_exit();
         if (unlikely(tsk->audit_context))
@@ -1127,7 +1127,6 @@ NORET_TYPE void do_exit(long code)
         preempt_disable();
         /* causes final put_task_struct in finish_task_switch(). */
         tsk->state = TASK_DEAD;
-
         schedule();
         BUG();
         /* Avoid "noreturn function does return".  */
@@ -1325,10 +1324,10 @@ static int wait_task_zombie(struct task_struct *p, int options,
                  * group, which consolidates times for all threads in the
                  * group including the group leader.
                  */
+                thread_group_cputime(p, &cputime);
                 spin_lock_irq(&p->parent->sighand->siglock);
                 psig = p->parent->signal;
                 sig = p->signal;
-                thread_group_cputime(p, &cputime);
                 psig->cutime =
                         cputime_add(psig->cutime,
                         cputime_add(cputime.utime,
diff --git a/kernel/extable.c b/kernel/extable.c
index a26cb2e17023..e136ed8d82ba 100644
--- a/kernel/extable.c
+++ b/kernel/extable.c
@@ -17,6 +17,7 @@
 */
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/ftrace.h>
 #include <asm/uaccess.h>
 #include <asm/sections.h>
 
@@ -40,7 +41,7 @@ const struct exception_table_entry *search_exception_tables(unsigned long addr)
         return e;
 }
 
-int core_kernel_text(unsigned long addr)
+__notrace_funcgraph int core_kernel_text(unsigned long addr)
 {
         if (addr >= (unsigned long)_stext &&
             addr <= (unsigned long)_etext)
@@ -53,7 +54,7 @@ int core_kernel_text(unsigned long addr)
         return 0;
 }
 
-int __kernel_text_address(unsigned long addr)
+__notrace_funcgraph int __kernel_text_address(unsigned long addr)
 {
         if (core_kernel_text(addr))
                 return 1;
@@ -66,3 +67,19 @@ int kernel_text_address(unsigned long addr)
                 return 1;
         return module_text_address(addr) != NULL;
 }
+
+/*
+ * On some architectures (PPC64, IA64) function pointers
+ * are actually only tokens to some data that then holds the
+ * real function address. As a result, to find if a function
+ * pointer is part of the kernel text, we need to do some
+ * special dereferencing first.
+ */
+int func_ptr_is_kernel_text(void *ptr)
+{
+        unsigned long addr;
+        addr = (unsigned long) dereference_function_descriptor(ptr);
+        if (core_kernel_text(addr))
+                return 1;
+        return module_text_address(addr) != NULL;
+}
diff --git a/kernel/fork.c b/kernel/fork.c
index f6083561dfe0..7b93da72d4a2 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -40,12 +40,14 @@
 #include <linux/jiffies.h>
 #include <linux/tracehook.h>
 #include <linux/futex.h>
+#include <linux/compat.h>
 #include <linux/task_io_accounting_ops.h>
 #include <linux/rcupdate.h>
 #include <linux/ptrace.h>
 #include <linux/mount.h>
 #include <linux/audit.h>
 #include <linux/memcontrol.h>
+#include <linux/ftrace.h>
 #include <linux/profile.h>
 #include <linux/rmap.h>
 #include <linux/acct.h>
@@ -79,6 +81,8 @@ DEFINE_PER_CPU(unsigned long, process_counts) = 0;
 
 __cacheline_aligned DEFINE_RWLOCK(tasklist_lock);  /* outer */
 
+DEFINE_TRACE(sched_process_fork);
+
 int nr_processes(void)
 {
         int cpu;
@@ -136,6 +140,7 @@ void free_task(struct task_struct *tsk)
         prop_local_destroy_single(&tsk->dirties);
         free_thread_info(tsk->stack);
         rt_mutex_debug_task_free(tsk);
+        ftrace_graph_exit_task(tsk);
         free_task_struct(tsk);
 }
 EXPORT_SYMBOL(free_task);
@@ -314,17 +319,20 @@ static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
                 file = tmp->vm_file;
                 if (file) {
                         struct inode *inode = file->f_path.dentry->d_inode;
+                        struct address_space *mapping = file->f_mapping;
+
                         get_file(file);
                         if (tmp->vm_flags & VM_DENYWRITE)
                                 atomic_dec(&inode->i_writecount);
-
-                        /* insert tmp into the share list, just after mpnt */
-                        spin_lock(&file->f_mapping->i_mmap_lock);
+                        spin_lock(&mapping->i_mmap_lock);
+                        if (tmp->vm_flags & VM_SHARED)
+                                mapping->i_mmap_writable++;
                         tmp->vm_truncate_count = mpnt->vm_truncate_count;
-                        flush_dcache_mmap_lock(file->f_mapping);
+                        flush_dcache_mmap_lock(mapping);
+                        /* insert tmp into the share list, just after mpnt */
                         vma_prio_tree_add(tmp, mpnt);
-                        flush_dcache_mmap_unlock(file->f_mapping);
-                        spin_unlock(&file->f_mapping->i_mmap_lock);
+                        flush_dcache_mmap_unlock(mapping);
+                        spin_unlock(&mapping->i_mmap_lock);
                 }
 
                 /*
@@ -519,6 +527,16 @@ void mm_release(struct task_struct *tsk, struct mm_struct *mm)
 {
         struct completion *vfork_done = tsk->vfork_done;
 
+        /* Get rid of any futexes when releasing the mm */
+#ifdef CONFIG_FUTEX
+        if (unlikely(tsk->robust_list))
+                exit_robust_list(tsk);
+#ifdef CONFIG_COMPAT
+        if (unlikely(tsk->compat_robust_list))
+                compat_exit_robust_list(tsk);
+#endif
+#endif
+
         /* Get rid of any cached register state */
         deactivate_mm(tsk, mm);
 
@@ -1122,6 +1140,8 @@ static struct task_struct *copy_process(unsigned long clone_flags,
                 }
         }
 
+        ftrace_graph_init_task(p);
+
         p->pid = pid_nr(pid);
         p->tgid = p->pid;
         if (clone_flags & CLONE_THREAD)
@@ -1130,7 +1150,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         if (current->nsproxy != p->nsproxy) {
                 retval = ns_cgroup_clone(p, pid);
                 if (retval)
-                        goto bad_fork_free_pid;
+                        goto bad_fork_free_graph;
         }
 
         p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
@@ -1223,7 +1243,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
                 spin_unlock(&current->sighand->siglock);
                 write_unlock_irq(&tasklist_lock);
                 retval = -ERESTARTNOINTR;
-                goto bad_fork_free_pid;
+                goto bad_fork_free_graph;
         }
 
         if (clone_flags & CLONE_THREAD) {
@@ -1260,6 +1280,8 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         cgroup_post_fork(p);
         return p;
 
+bad_fork_free_graph:
+        ftrace_graph_exit_task(p);
 bad_fork_free_pid:
         if (pid != &init_struct_pid)
                 free_pid(pid);
@@ -1387,6 +1409,7 @@ long do_fork(unsigned long clone_flags,
                         init_completion(&vfork);
                 }
 
+                audit_finish_fork(p);
                 tracehook_report_clone(trace, regs, clone_flags, nr, p);
 
                 /*
diff --git a/kernel/futex.c b/kernel/futex.c
index 8af10027514b..e10c5c8786a6 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -123,24 +123,6 @@ struct futex_hash_bucket {
 static struct futex_hash_bucket futex_queues[1<<FUTEX_HASHBITS];
 
 /*
- * Take mm->mmap_sem, when futex is shared
- */
-static inline void futex_lock_mm(struct rw_semaphore *fshared)
-{
-        if (fshared)
-                down_read(fshared);
-}
-
-/*
- * Release mm->mmap_sem, when the futex is shared
- */
-static inline void futex_unlock_mm(struct rw_semaphore *fshared)
-{
-        if (fshared)
-                up_read(fshared);
-}
-
-/*
  * We hash on the keys returned from get_futex_key (see below).
  */
 static struct futex_hash_bucket *hash_futex(union futex_key *key)
@@ -161,6 +143,45 @@ static inline int match_futex(union futex_key *key1, union futex_key *key2)
                 && key1->both.offset == key2->both.offset);
 }
 
+/*
+ * Take a reference to the resource addressed by a key.
+ * Can be called while holding spinlocks.
+ *
+ */
+static void get_futex_key_refs(union futex_key *key)
+{
+        if (!key->both.ptr)
+                return;
+
+        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
+        case FUT_OFF_INODE:
+                atomic_inc(&key->shared.inode->i_count);
+                break;
+        case FUT_OFF_MMSHARED:
+                atomic_inc(&key->private.mm->mm_count);
+                break;
+        }
+}
+
+/*
+ * Drop a reference to the resource addressed by a key.
+ * The hash bucket spinlock must not be held.
+ */
+static void drop_futex_key_refs(union futex_key *key)
+{
+        if (!key->both.ptr)
+                return;
+
+        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
+        case FUT_OFF_INODE:
+                iput(key->shared.inode);
+                break;
+        case FUT_OFF_MMSHARED:
+                mmdrop(key->private.mm);
+                break;
+        }
+}
+
 /**
  * get_futex_key - Get parameters which are the keys for a futex.
  * @uaddr: virtual address of the futex
@@ -179,12 +200,10 @@ static inline int match_futex(union futex_key *key1, union futex_key *key2)
  * For other futexes, it points to &current->mm->mmap_sem and
  * caller must have taken the reader lock. but NOT any spinlocks.
  */
-static int get_futex_key(u32 __user *uaddr, struct rw_semaphore *fshared,
-                         union futex_key *key)
+static int get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key)
 {
         unsigned long address = (unsigned long)uaddr;
         struct mm_struct *mm = current->mm;
-        struct vm_area_struct *vma;
         struct page *page;
         int err;
 
@@ -208,100 +227,50 @@ static int get_futex_key(u32 __user *uaddr, struct rw_semaphore *fshared,
                         return -EFAULT;
                 key->private.mm = mm;
                 key->private.address = address;
+                get_futex_key_refs(key);
                 return 0;
         }
-        /*
-         * The futex is hashed differently depending on whether
-         * it's in a shared or private mapping.  So check vma first.
-         */
-        vma = find_extend_vma(mm, address);
-        if (unlikely(!vma))
-                return -EFAULT;
 
-        /*
-         * Permissions.
-         */
-        if (unlikely((vma->vm_flags & (VM_IO|VM_READ)) != VM_READ))
-                return (vma->vm_flags & VM_IO) ? -EPERM : -EACCES;
+again:
+        err = get_user_pages_fast(address, 1, 0, &page);
+        if (err < 0)
+                return err;
+
+        lock_page(page);
+        if (!page->mapping) {
+                unlock_page(page);
+                put_page(page);
+                goto again;
+        }
 
         /*
          * Private mappings are handled in a simple way.
          *
          * NOTE: When userspace waits on a MAP_SHARED mapping, even if
          * it's a read-only handle, it's expected that futexes attach to
-         * the object not the particular process.  Therefore we use
-         * VM_MAYSHARE here, not VM_SHARED which is restricted to shared
-         * mappings of _writable_ handles.
+         * the object not the particular process.
          */
-        if (likely(!(vma->vm_flags & VM_MAYSHARE))) {
-                key->both.offset |= FUT_OFF_MMSHARED; /* reference taken on mm */
+        if (PageAnon(page)) {
+                key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
                 key->private.mm = mm;
                 key->private.address = address;
-                return 0;
+        } else {
+                key->both.offset |= FUT_OFF_INODE; /* inode-based key */
+                key->shared.inode = page->mapping->host;
+                key->shared.pgoff = page->index;
         }
 
-        /*
-         * Linear file mappings are also simple.
-         */
-        key->shared.inode = vma->vm_file->f_path.dentry->d_inode;
-        key->both.offset |= FUT_OFF_INODE; /* inode-based key. */
-        if (likely(!(vma->vm_flags & VM_NONLINEAR))) {
-                key->shared.pgoff = (((address - vma->vm_start) >> PAGE_SHIFT)
-                                     + vma->vm_pgoff);
-                return 0;
-        }
+        get_futex_key_refs(key);
 
-        /*
-         * We could walk the page table to read the non-linear
-         * pte, and get the page index without fetching the page
-         * from swap.  But that's a lot of code to duplicate here
-         * for a rare case, so we simply fetch the page.
-         */
-        err = get_user_pages(current, mm, address, 1, 0, 0, &page, NULL);
-        if (err >= 0) {
-                key->shared.pgoff =
-                        page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
-                put_page(page);
-                return 0;
-        }
-        return err;
-}
-
-/*
- * Take a reference to the resource addressed by a key.
- * Can be called while holding spinlocks.
- *
- */
-static void get_futex_key_refs(union futex_key *key)
-{
-        if (key->both.ptr == NULL)
-                return;
-        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
-                case FUT_OFF_INODE:
-                        atomic_inc(&key->shared.inode->i_count);
-                        break;
-                case FUT_OFF_MMSHARED:
-                        atomic_inc(&key->private.mm->mm_count);
-                        break;
-        }
+        unlock_page(page);
+        put_page(page);
+        return 0;
 }
 
-/*
- * Drop a reference to the resource addressed by a key.
- * The hash bucket spinlock must not be held.
- */
-static void drop_futex_key_refs(union futex_key *key)
+static inline
+void put_futex_key(int fshared, union futex_key *key)
 {
-        if (!key->both.ptr)
-                return;
-        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
-                case FUT_OFF_INODE:
-                        iput(key->shared.inode);
-                        break;
-                case FUT_OFF_MMSHARED:
-                        mmdrop(key->private.mm);
-                        break;
-        }
+        drop_futex_key_refs(key);
 }
 
 static u32 cmpxchg_futex_value_locked(u32 __user *uaddr, u32 uval, u32 newval)
@@ -328,10 +297,8 @@ static int get_futex_value_locked(u32 *dest, u32 __user *from)
 
 /*
  * Fault handling.
- * if fshared is non NULL, current->mm->mmap_sem is already held
  */
-static int futex_handle_fault(unsigned long address,
-                              struct rw_semaphore *fshared, int attempt)
+static int futex_handle_fault(unsigned long address, int attempt)
 {
         struct vm_area_struct * vma;
         struct mm_struct *mm = current->mm;
@@ -340,8 +307,7 @@ static int futex_handle_fault(unsigned long address,
         if (attempt > 2)
                 return ret;
 
-        if (!fshared)
-                down_read(&mm->mmap_sem);
+        down_read(&mm->mmap_sem);
         vma = find_vma(mm, address);
         if (vma && address >= vma->vm_start &&
             (vma->vm_flags & VM_WRITE)) {
@@ -361,8 +327,7 @@ static int futex_handle_fault(unsigned long address,
                                 current->min_flt++;
                 }
         }
-        if (!fshared)
-                up_read(&mm->mmap_sem);
+        up_read(&mm->mmap_sem);
         return ret;
 }
 
@@ -385,6 +350,7 @@ static int refill_pi_state_cache(void)
         /* pi_mutex gets initialized later */
         pi_state->owner = NULL;
         atomic_set(&pi_state->refcount, 1);
+        pi_state->key = FUTEX_KEY_INIT;
 
         current->pi_state_cache = pi_state;
 
@@ -462,7 +428,7 @@ void exit_pi_state_list(struct task_struct *curr)
         struct list_head *next, *head = &curr->pi_state_list;
         struct futex_pi_state *pi_state;
         struct futex_hash_bucket *hb;
-        union futex_key key;
+        union futex_key key = FUTEX_KEY_INIT;
 
         if (!futex_cmpxchg_enabled)
                 return;
@@ -719,20 +685,17 @@ double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
  * Wake up all waiters hashed on the physical page that is mapped
  * to this virtual address:
  */
-static int futex_wake(u32 __user *uaddr, struct rw_semaphore *fshared,
-                      int nr_wake, u32 bitset)
+static int futex_wake(u32 __user *uaddr, int fshared, int nr_wake, u32 bitset)
 {
         struct futex_hash_bucket *hb;
         struct futex_q *this, *next;
         struct plist_head *head;
-        union futex_key key;
+        union futex_key key = FUTEX_KEY_INIT;
         int ret;
 
         if (!bitset)
                 return -EINVAL;
 
-        futex_lock_mm(fshared);
-
         ret = get_futex_key(uaddr, fshared, &key);
         if (unlikely(ret != 0))
                 goto out;
@@ -760,7 +723,7 @@ static int futex_wake(u32 __user *uaddr, struct rw_semaphore *fshared,
 
         spin_unlock(&hb->lock);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key);
         return ret;
 }
 
@@ -769,19 +732,16 @@ out:
  * to this virtual address:
  */
 static int
-futex_wake_op(u32 __user *uaddr1, struct rw_semaphore *fshared,
-              u32 __user *uaddr2,
+futex_wake_op(u32 __user *uaddr1, int fshared, u32 __user *uaddr2,
               int nr_wake, int nr_wake2, int op)
 {
-        union futex_key key1, key2;
+        union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
         struct futex_hash_bucket *hb1, *hb2;
         struct plist_head *head;
         struct futex_q *this, *next;
         int ret, op_ret, attempt = 0;
 
 retryfull:
-        futex_lock_mm(fshared);
-
         ret = get_futex_key(uaddr1, fshared, &key1);
         if (unlikely(ret != 0))
                 goto out;
@@ -826,18 +786,12 @@ retry:
                  */
                 if (attempt++) {
                         ret = futex_handle_fault((unsigned long)uaddr2,
-                                                 fshared, attempt);
+                                                 attempt);
                         if (ret)
                                 goto out;
                         goto retry;
                 }
 
-                /*
-                 * If we would have faulted, release mmap_sem,
-                 * fault it in and start all over again.
-                 */
-                futex_unlock_mm(fshared);
-
                 ret = get_user(dummy, uaddr2);
                 if (ret)
                         return ret;
@@ -873,7 +827,8 @@ retry:
         if (hb1 != hb2)
                 spin_unlock(&hb2->lock);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key2);
+        put_futex_key(fshared, &key1);
 
         return ret;
 }
@@ -882,19 +837,16 @@ out:
  * Requeue all waiters hashed on one physical page to another
  * physical page.
  */
-static int futex_requeue(u32 __user *uaddr1, struct rw_semaphore *fshared,
-                         u32 __user *uaddr2,
+static int futex_requeue(u32 __user *uaddr1, int fshared, u32 __user *uaddr2,
                          int nr_wake, int nr_requeue, u32 *cmpval)
 {
-        union futex_key key1, key2;
+        union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
         struct futex_hash_bucket *hb1, *hb2;
         struct plist_head *head1;
         struct futex_q *this, *next;
         int ret, drop_count = 0;
 
  retry:
-        futex_lock_mm(fshared);
-
         ret = get_futex_key(uaddr1, fshared, &key1);
         if (unlikely(ret != 0))
                 goto out;
@@ -917,12 +869,6 @@ static int futex_requeue(u32 __user *uaddr1, struct rw_semaphore *fshared,
                         if (hb1 != hb2)
                                 spin_unlock(&hb2->lock);
 
-                        /*
-                         * If we would have faulted, release mmap_sem, fault
-                         * it in and start all over again.
-                         */
-                        futex_unlock_mm(fshared);
-
                         ret = get_user(curval, uaddr1);
 
                         if (!ret)
@@ -974,7 +920,8 @@ out_unlock:
                 drop_futex_key_refs(&key1);
 
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key2);
+        put_futex_key(fshared, &key1);
         return ret;
 }
 
@@ -1096,8 +1043,7 @@ static void unqueue_me_pi(struct futex_q *q)
  * private futexes.
  */
 static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
-                                struct task_struct *newowner,
-                                struct rw_semaphore *fshared)
+                                struct task_struct *newowner, int fshared)
 {
         u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
         struct futex_pi_state *pi_state = q->pi_state;
@@ -1176,7 +1122,7 @@ retry:
 handle_fault:
         spin_unlock(q->lock_ptr);
 
-        ret = futex_handle_fault((unsigned long)uaddr, fshared, attempt++);
+        ret = futex_handle_fault((unsigned long)uaddr, attempt++);
 
         spin_lock(q->lock_ptr);
 
@@ -1200,7 +1146,7 @@ handle_fault:
 
 static long futex_wait_restart(struct restart_block *restart);
 
-static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
+static int futex_wait(u32 __user *uaddr, int fshared,
                       u32 val, ktime_t *abs_time, u32 bitset)
 {
         struct task_struct *curr = current;
@@ -1218,8 +1164,7 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
         q.pi_state = NULL;
         q.bitset = bitset;
  retry:
-        futex_lock_mm(fshared);
-
+        q.key = FUTEX_KEY_INIT;
         ret = get_futex_key(uaddr, fshared, &q.key);
         if (unlikely(ret != 0))
                 goto out_release_sem;
@@ -1251,12 +1196,6 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
         if (unlikely(ret)) {
                 queue_unlock(&q, hb);
 
-                /*
-                 * If we would have faulted, release mmap_sem, fault it in and
-                 * start all over again.
-                 */
-                futex_unlock_mm(fshared);
-
                 ret = get_user(uval, uaddr);
 
                 if (!ret)
@@ -1271,12 +1210,6 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
         queue_me(&q, hb);
 
         /*
-         * Now the futex is queued and we have checked the data, we
-         * don't want to hold mmap_sem while we sleep.
-         */
-        futex_unlock_mm(fshared);
-
-        /*
          * There might have been scheduling since the queue_me(), as we
          * cannot hold a spinlock across the get_user() in case it
          * faults, and we cannot just set TASK_INTERRUPTIBLE state when
@@ -1363,7 +1296,7 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
         queue_unlock(&q, hb);
 
  out_release_sem:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &q.key);
         return ret;
 }
 
@@ -1371,13 +1304,13 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
 static long futex_wait_restart(struct restart_block *restart)
 {
         u32 __user *uaddr = (u32 __user *)restart->futex.uaddr;
-        struct rw_semaphore *fshared = NULL;
+        int fshared = 0;
         ktime_t t;
 
         t.tv64 = restart->futex.time;
         restart->fn = do_no_restart_syscall;
         if (restart->futex.flags & FLAGS_SHARED)
-                fshared = &current->mm->mmap_sem;
+                fshared = 1;
         return (long)futex_wait(uaddr, fshared, restart->futex.val, &t,
                                 restart->futex.bitset);
 }
@@ -1389,7 +1322,7 @@ static long futex_wait_restart(struct restart_block *restart)
  * if there are waiters then it will block, it does PI, etc. (Due to
  * races the kernel might see a 0 value of the futex too.)
  */
-static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
+static int futex_lock_pi(u32 __user *uaddr, int fshared,
                          int detect, ktime_t *time, int trylock)
 {
         struct hrtimer_sleeper timeout, *to = NULL;
@@ -1412,8 +1345,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
 
         q.pi_state = NULL;
  retry:
-        futex_lock_mm(fshared);
-
+        q.key = FUTEX_KEY_INIT;
         ret = get_futex_key(uaddr, fshared, &q.key);
         if (unlikely(ret != 0))
                 goto out_release_sem;
@@ -1502,7 +1434,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
                          * exit to complete.
                          */
                         queue_unlock(&q, hb);
-                        futex_unlock_mm(fshared);
                         cond_resched();
                         goto retry;
 
@@ -1534,12 +1465,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
          */
         queue_me(&q, hb);
 
-        /*
-         * Now the futex is queued and we have checked the data, we
-         * don't want to hold mmap_sem while we sleep.
-         */
-        futex_unlock_mm(fshared);
-
         WARN_ON(!q.pi_state);
         /*
          * Block on the PI mutex:
@@ -1552,7 +1477,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
                 ret = ret ? 0 : -EWOULDBLOCK;
         }
 
-        futex_lock_mm(fshared);
         spin_lock(q.lock_ptr);
 
         if (!ret) {
@@ -1618,7 +1542,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
 
         /* Unqueue and drop the lock */
         unqueue_me_pi(&q);
-        futex_unlock_mm(fshared);
 
         if (to)
                 destroy_hrtimer_on_stack(&to->timer);
@@ -1628,7 +1551,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
         queue_unlock(&q, hb);
 
  out_release_sem:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &q.key);
         if (to)
                 destroy_hrtimer_on_stack(&to->timer);
         return ret;
@@ -1645,15 +1568,12 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
         queue_unlock(&q, hb);
 
         if (attempt++) {
-                ret = futex_handle_fault((unsigned long)uaddr, fshared,
-                                         attempt);
+                ret = futex_handle_fault((unsigned long)uaddr, attempt);
                 if (ret)
                         goto out_release_sem;
                 goto retry_unlocked;
         }
 
-        futex_unlock_mm(fshared);
-
         ret = get_user(uval, uaddr);
         if (!ret && (uval != -EFAULT))
                 goto retry;
@@ -1668,13 +1588,13 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
  * This is the in-kernel slowpath: we look up the PI state (if any),
  * and do the rt-mutex unlock.
  */
-static int futex_unlock_pi(u32 __user *uaddr, struct rw_semaphore *fshared)
+static int futex_unlock_pi(u32 __user *uaddr, int fshared)
 {
         struct futex_hash_bucket *hb;
         struct futex_q *this, *next;
         u32 uval;
         struct plist_head *head;
-        union futex_key key;
+        union futex_key key = FUTEX_KEY_INIT;
         int ret, attempt = 0;
 
 retry:
@@ -1685,10 +1605,6 @@ retry:
          */
         if ((uval & FUTEX_TID_MASK) != task_pid_vnr(current))
                 return -EPERM;
-        /*
-         * First take all the futex related locks:
-         */
-        futex_lock_mm(fshared);
 
         ret = get_futex_key(uaddr, fshared, &key);
         if (unlikely(ret != 0))
@@ -1747,7 +1663,7 @@ retry_unlocked:
 out_unlock:
         spin_unlock(&hb->lock);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key);
 
         return ret;
 
@@ -1763,16 +1679,13 @@ pi_faulted:
         spin_unlock(&hb->lock);
 
         if (attempt++) {
-                ret = futex_handle_fault((unsigned long)uaddr, fshared,
-                                         attempt);
+                ret = futex_handle_fault((unsigned long)uaddr, attempt);
                 if (ret)
                         goto out;
                 uval = 0;
                 goto retry_unlocked;
         }
 
-        futex_unlock_mm(fshared);
-
         ret = get_user(uval, uaddr);
         if (!ret && (uval != -EFAULT))
                 goto retry;
@@ -1898,8 +1811,7 @@ retry:
                  * PI futexes happens in exit_pi_state():
                  */
                 if (!pi && (uval & FUTEX_WAITERS))
-                        futex_wake(uaddr, &curr->mm->mmap_sem, 1,
-                                   FUTEX_BITSET_MATCH_ANY);
+                        futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
         }
         return 0;
 }
@@ -1995,10 +1907,10 @@ long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
 {
         int ret = -ENOSYS;
         int cmd = op & FUTEX_CMD_MASK;
-        struct rw_semaphore *fshared = NULL;
+        int fshared = 0;
 
         if (!(op & FUTEX_PRIVATE_FLAG))
-                fshared = &current->mm->mmap_sem;
+                fshared = 1;
 
         switch (cmd) {
         case FUTEX_WAIT:
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 2b465dfde426..47e63349d1b2 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -664,14 +664,6 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
 
                 /* Timer is expired, act upon the callback mode */
                 switch(timer->cb_mode) {
-                case HRTIMER_CB_IRQSAFE_NO_RESTART:
-                        debug_hrtimer_deactivate(timer);
-                        /*
-                         * We can call the callback from here. No restart
-                         * happens, so no danger of recursion
-                         */
-                        BUG_ON(timer->function(timer) != HRTIMER_NORESTART);
-                        return 1;
                 case HRTIMER_CB_IRQSAFE_PERCPU:
                 case HRTIMER_CB_IRQSAFE_UNLOCKED:
                         /*
@@ -683,7 +675,6 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
                          */
                         debug_hrtimer_deactivate(timer);
                         return 1;
-                case HRTIMER_CB_IRQSAFE:
                 case HRTIMER_CB_SOFTIRQ:
                         /*
                          * Move everything else into the softirq pending list !
@@ -1209,6 +1200,7 @@ static void run_hrtimer_pending(struct hrtimer_cpu_base *cpu_base)
                 enum hrtimer_restart (*fn)(struct hrtimer *);
                 struct hrtimer *timer;
                 int restart;
+                int emulate_hardirq_ctx = 0;
 
                 timer = list_entry(cpu_base->cb_pending.next,
                                    struct hrtimer, cb_entry);
@@ -1217,10 +1209,24 @@ static void run_hrtimer_pending(struct hrtimer_cpu_base *cpu_base)
                 timer_stats_account_hrtimer(timer);
 
                 fn = timer->function;
+                /*
+                 * A timer might have been added to the cb_pending list
+                 * when it was migrated during a cpu-offline operation.
+                 * Emulate hardirq context for such timers.
+                 */
+                if (timer->cb_mode == HRTIMER_CB_IRQSAFE_PERCPU ||
+                    timer->cb_mode == HRTIMER_CB_IRQSAFE_UNLOCKED)
+                        emulate_hardirq_ctx = 1;
+
                 __remove_hrtimer(timer, timer->base, HRTIMER_STATE_CALLBACK, 0);
                 spin_unlock_irq(&cpu_base->lock);
 
-                restart = fn(timer);
+                if (unlikely(emulate_hardirq_ctx)) {
+                        local_irq_disable();
+                        restart = fn(timer);
+                        local_irq_enable();
+                } else
+                        restart = fn(timer);
 
                 spin_lock_irq(&cpu_base->lock);
 
diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index cc0f7321b8ce..650ce4102a63 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -40,6 +40,9 @@ unsigned long probe_irq_on(void)
          * flush such a longstanding irq before considering it as spurious.
          */
         for_each_irq_desc_reverse(i, desc) {
+                if (!desc)
+                        continue;
+
                 spin_lock_irq(&desc->lock);
                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
                         /*
@@ -68,6 +71,9 @@ unsigned long probe_irq_on(void)
          * happened in the previous stage, it may have masked itself)
          */
         for_each_irq_desc_reverse(i, desc) {
+                if (!desc)
+                        continue;
+
                 spin_lock_irq(&desc->lock);
                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
                         desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
@@ -86,6 +92,9 @@ unsigned long probe_irq_on(void)
          * Now filter out any obviously spurious interrupts
          */
         for_each_irq_desc(i, desc) {
+                if (!desc)
+                        continue;
+
                 spin_lock_irq(&desc->lock);
                 status = desc->status;
 
@@ -124,6 +133,9 @@ unsigned int probe_irq_mask(unsigned long val)
         int i;
 
         for_each_irq_desc(i, desc) {
+                if (!desc)
+                        continue;
+
                 spin_lock_irq(&desc->lock);
                 status = desc->status;
 
@@ -166,6 +178,9 @@ int probe_irq_off(unsigned long val)
         unsigned int status;
 
         for_each_irq_desc(i, desc) {
+                if (!desc)
+                        continue;
+
                 spin_lock_irq(&desc->lock);
                 status = desc->status;
 
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 10b5092e9bfe..8e4fce4a1b1f 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -24,9 +24,10 @@
  */
 void dynamic_irq_init(unsigned int irq)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct irq_desc *desc;
         unsigned long flags;
 
+        desc = irq_to_desc(irq);
         if (!desc) {
                 WARN(1, KERN_ERR "Trying to initialize invalid IRQ%d\n", irq);
                 return;
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index c815b42d0f5b..8aa09547f5ef 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -15,9 +15,16 @@
 #include <linux/random.h>
 #include <linux/interrupt.h>
 #include <linux/kernel_stat.h>
+#include <linux/rculist.h>
+#include <linux/hash.h>
 
 #include "internals.h"
 
+/*
+ * lockdep: we want to handle all irq_desc locks as a single lock-class:
+ */
+static struct lock_class_key irq_desc_lock_class;
+
 /**
  * handle_bad_irq - handle spurious and unhandled irqs
  * @irq:       the interrupt number
@@ -49,6 +56,155 @@ void handle_bad_irq(unsigned int irq, struct irq_desc *desc)
 int nr_irqs = NR_IRQS;
 EXPORT_SYMBOL_GPL(nr_irqs);
 
+void __init __attribute__((weak)) arch_early_irq_init(void)
+{
+}
+
+#ifdef CONFIG_SPARSE_IRQ
+static struct irq_desc irq_desc_init = {
+        .irq        = -1,
+        .status     = IRQ_DISABLED,
+        .chip       = &no_irq_chip,
+        .handle_irq = handle_bad_irq,
+        .depth      = 1,
+        .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
+#ifdef CONFIG_SMP
+        .affinity   = CPU_MASK_ALL
+#endif
+};
+
+static void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr)
+{
+        unsigned long bytes;
+        char *ptr;
+        int node;
+
+        /* Compute how many bytes we need per irq and allocate them */
+        bytes = nr * sizeof(unsigned int);
+
+        node = cpu_to_node(cpu);
+        ptr = kzalloc_node(bytes, GFP_ATOMIC, node);
+        printk(KERN_DEBUG "  alloc kstat_irqs on cpu %d node %d\n", cpu, node);
+
+        if (ptr)
+                desc->kstat_irqs = (unsigned int *)ptr;
+}
+
+void __attribute__((weak)) arch_init_chip_data(struct irq_desc *desc, int cpu)
+{
+}
+
+static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
+{
+        memcpy(desc, &irq_desc_init, sizeof(struct irq_desc));
+        desc->irq = irq;
+#ifdef CONFIG_SMP
+        desc->cpu = cpu;
+#endif
+        lockdep_set_class(&desc->lock, &irq_desc_lock_class);
+        init_kstat_irqs(desc, cpu, nr_cpu_ids);
+        if (!desc->kstat_irqs) {
+                printk(KERN_ERR "can not alloc kstat_irqs\n");
+                BUG_ON(1);
+        }
+        arch_init_chip_data(desc, cpu);
+}
+
+/*
+ * Protect the sparse_irqs:
+ */
+static DEFINE_SPINLOCK(sparse_irq_lock);
+
+struct irq_desc *irq_desc_ptrs[NR_IRQS] __read_mostly;
+
+static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_smp = {
+        [0 ... NR_IRQS_LEGACY-1] = {
+                .irq        = -1,
+                .status     = IRQ_DISABLED,
+                .chip       = &no_irq_chip,
+                .handle_irq = handle_bad_irq,
+                .depth      = 1,
+                .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
+#ifdef CONFIG_SMP
+                .affinity   = CPU_MASK_ALL
+#endif
+        }
+};
+
+/* FIXME: use bootmem alloc ...*/
+static unsigned int kstat_irqs_legacy[NR_IRQS_LEGACY][NR_CPUS];
+
+void __init early_irq_init(void)
+{
+        struct irq_desc *desc;
+        int legacy_count;
+        int i;
+
+        desc = irq_desc_legacy;
+        legacy_count = ARRAY_SIZE(irq_desc_legacy);
+
+        for (i = 0; i < legacy_count; i++) {
+                desc[i].irq = i;
+                desc[i].kstat_irqs = kstat_irqs_legacy[i];
+
+                irq_desc_ptrs[i] = desc + i;
+        }
+
+        for (i = legacy_count; i < NR_IRQS; i++)
+                irq_desc_ptrs[i] = NULL;
+
+        arch_early_irq_init();
+}
+
+struct irq_desc *irq_to_desc(unsigned int irq)
+{
+        return (irq < NR_IRQS) ? irq_desc_ptrs[irq] : NULL;
+}
+
+struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
+{
+        struct irq_desc *desc;
+        unsigned long flags;
+        int node;
+
+        if (irq >= NR_IRQS) {
+                printk(KERN_WARNING "irq >= NR_IRQS in irq_to_desc_alloc: %d %d\n",
+                                irq, NR_IRQS);
+                WARN_ON(1);
+                return NULL;
+        }
+
+        desc = irq_desc_ptrs[irq];
+        if (desc)
+                return desc;
+
+        spin_lock_irqsave(&sparse_irq_lock, flags);
+
+        /* We have to check it to avoid races with another CPU */
+        desc = irq_desc_ptrs[irq];
+        if (desc)
+                goto out_unlock;
+
+        node = cpu_to_node(cpu);
+        desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
+        printk(KERN_DEBUG "  alloc irq_desc for %d on cpu %d node %d\n",
+                 irq, cpu, node);
+        if (!desc) {
+                printk(KERN_ERR "can not alloc irq_desc\n");
+                BUG_ON(1);
+        }
+        init_one_irq_desc(irq, desc, cpu);
+
+        irq_desc_ptrs[irq] = desc;
+
+out_unlock:
+        spin_unlock_irqrestore(&sparse_irq_lock, flags);
+
+        return desc;
+}
+
+#else
+
 struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
         [0 ... NR_IRQS-1] = {
                 .status = IRQ_DISABLED,
@@ -62,6 +218,8 @@ struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
         }
 };
 
+#endif
+
 /*
  * What should we do if we get a hw irq event on an illegal vector?
  * Each architecture has to answer this themself.
@@ -261,17 +419,28 @@ out:
 
 
 #ifdef CONFIG_TRACE_IRQFLAGS
-/*
- * lockdep: we want to handle all irq_desc locks as a single lock-class:
- */
-static struct lock_class_key irq_desc_lock_class;
-
 void early_init_irq_lock_class(void)
 {
+#ifndef CONFIG_SPARSE_IRQ
         struct irq_desc *desc;
         int i;
 
-        for_each_irq_desc(i, desc)
+        for_each_irq_desc(i, desc) {
+                if (!desc)
+                        continue;
+
                 lockdep_set_class(&desc->lock, &irq_desc_lock_class);
+        }
+#endif
+}
+#endif
+
+#ifdef CONFIG_SPARSE_IRQ
+unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        return desc->kstat_irqs[cpu];
 }
 #endif
+EXPORT_SYMBOL(kstat_irqs_cpu);
+
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index c9767e641980..64c1c7253dae 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -25,6 +25,8 @@ static inline void unregister_handler_proc(unsigned int irq,
                                            struct irqaction *action) { }
 #endif
 
+extern int irq_select_affinity_usr(unsigned int irq);
+
 /*
  * Debugging printout:
  */
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index c498a1b8c621..801addda3c43 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -82,24 +82,27 @@ int irq_can_set_affinity(unsigned int irq)
 int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
 {
         struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
 
         if (!desc->chip->set_affinity)
                 return -EINVAL;
 
+        spin_lock_irqsave(&desc->lock, flags);
+
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
-                unsigned long flags;
-
-                spin_lock_irqsave(&desc->lock, flags);
                 desc->affinity = cpumask;
                 desc->chip->set_affinity(irq, cpumask);
-                spin_unlock_irqrestore(&desc->lock, flags);
-        } else
-                set_pending_irq(irq, cpumask);
+        } else {
+                desc->status |= IRQ_MOVE_PENDING;
+                desc->pending_mask = cpumask;
+        }
 #else
         desc->affinity = cpumask;
         desc->chip->set_affinity(irq, cpumask);
 #endif
+        desc->status |= IRQ_AFFINITY_SET;
+        spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 
@@ -107,24 +110,59 @@ int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
 /*
  * Generic version of the affinity autoselector.
  */
-int irq_select_affinity(unsigned int irq)
+int do_irq_select_affinity(unsigned int irq, struct irq_desc *desc)
 {
         cpumask_t mask;
-        struct irq_desc *desc;
 
         if (!irq_can_set_affinity(irq))
                 return 0;
 
         cpus_and(mask, cpu_online_map, irq_default_affinity);
 
-        desc = irq_to_desc(irq);
+        /*
+         * Preserve an userspace affinity setup, but make sure that
+         * one of the targets is online.
+         */
+        if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
+                if (cpus_intersects(desc->affinity, cpu_online_map))
+                        mask = desc->affinity;
+                else
+                        desc->status &= ~IRQ_AFFINITY_SET;
+        }
+
         desc->affinity = mask;
         desc->chip->set_affinity(irq, mask);
 
         return 0;
 }
+#else
+static inline int do_irq_select_affinity(unsigned int irq, struct irq_desc *d)
+{
+        return irq_select_affinity(irq);
+}
 #endif
 
+/*
+ * Called when affinity is set via /proc/irq
+ */
+int irq_select_affinity_usr(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&desc->lock, flags);
+        ret = do_irq_select_affinity(irq, desc);
+        spin_unlock_irqrestore(&desc->lock, flags);
+
+        return ret;
+}
+
+#else
+static inline int do_irq_select_affinity(int irq, struct irq_desc *desc)
+{
+        return 0;
+}
 #endif
 
 /**
@@ -327,7 +365,7 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
                  * IRQF_TRIGGER_* but the PIC does not support multiple
                  * flow-types?
                  */
-                pr_warning("No set_type function for IRQ %d (%s)\n", irq,
+                pr_debug("No set_type function for IRQ %d (%s)\n", irq,
                                 chip ? (chip->name ? : "unknown") : "unknown");
                 return 0;
         }
@@ -445,8 +483,12 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
                         /* Undo nested disables: */
                         desc->depth = 1;
 
+                /* Exclude IRQ from balancing if requested */
+                if (new->flags & IRQF_NOBALANCING)
+                        desc->status |= IRQ_NO_BALANCING;
+
                 /* Set default affinity mask once everything is setup */
-                irq_select_affinity(irq);
+                do_irq_select_affinity(irq, desc);
 
         } else if ((new->flags & IRQF_TRIGGER_MASK)
                         && (new->flags & IRQF_TRIGGER_MASK)
@@ -459,10 +501,6 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
 
         *p = new;
 
-        /* Exclude IRQ from balancing */
-        if (new->flags & IRQF_NOBALANCING)
-                desc->status |= IRQ_NO_BALANCING;
-
         /* Reset broken irq detection when installing new handler */
         desc->irq_count = 0;
         desc->irqs_unhandled = 0;
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index 90b920d3f52b..9db681d95814 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -1,17 +1,6 @@
 
 #include <linux/irq.h>
 
-void set_pending_irq(unsigned int irq, cpumask_t mask)
-{
-        struct irq_desc *desc = irq_to_desc(irq);
-        unsigned long flags;
-
-        spin_lock_irqsave(&desc->lock, flags);
-        desc->status |= IRQ_MOVE_PENDING;
-        desc->pending_mask = mask;
-        spin_unlock_irqrestore(&desc->lock, flags);
-}
-
 void move_masked_irq(int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 4d161c70ba55..f6b3440f05bc 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -62,7 +62,7 @@ static ssize_t irq_affinity_proc_write(struct file *file,
         if (!cpus_intersects(new_value, cpu_online_map))
                 /* Special case for empty set - allow the architecture
                    code to set default SMP affinity. */
-                return irq_select_affinity(irq) ? -EINVAL : count;
+                return irq_select_affinity_usr(irq) ? -EINVAL : count;
 
         irq_set_affinity(irq, new_value);
 
@@ -243,7 +243,11 @@ void init_irq_proc(void)
         /*
          * Create entries for all existing IRQs.
          */
-        for_each_irq_desc(irq, desc)
+        for_each_irq_desc(irq, desc) {
+                if (!desc)
+                        continue;
+
                 register_irq_proc(irq, desc);
+        }
 }
 
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index dd364c11e56e..3738107531fd 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -91,6 +91,9 @@ static int misrouted_irq(int irq)
         int i, ok = 0;
 
         for_each_irq_desc(i, desc) {
+                if (!desc)
+                        continue;
+
                 if (!i)
                          continue;
 
@@ -112,6 +115,8 @@ static void poll_spurious_irqs(unsigned long dummy)
         for_each_irq_desc(i, desc) {
                 unsigned int status;
 
+                if (!desc)
+                        continue;
                 if (!i)
                          continue;
 
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 5072cf1685a2..7b8b0f21a5b1 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -304,17 +304,24 @@ int sprint_symbol(char *buffer, unsigned long address)
         char *modname;
         const char *name;
         unsigned long offset, size;
-        char namebuf[KSYM_NAME_LEN];
+        int len;
 
-        name = kallsyms_lookup(address, &size, &offset, &modname, namebuf);
+        name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
         if (!name)
                 return sprintf(buffer, "0x%lx", address);
 
+        if (name != buffer)
+                strcpy(buffer, name);
+        len = strlen(buffer);
+        buffer += len;
+
         if (modname)
-                return sprintf(buffer, "%s+%#lx/%#lx [%s]", name, offset,
-                                size, modname);
+                len += sprintf(buffer, "+%#lx/%#lx [%s]",
+                                                offset, size, modname);
         else
-                return sprintf(buffer, "%s+%#lx/%#lx", name, offset, size);
+                len += sprintf(buffer, "+%#lx/%#lx", offset, size);
+
+        return len;
 }
 
 /* Look up a kernel symbol and print it to the kernel messages. */
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 8b57a2597f21..9f8a3f25259a 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -72,7 +72,7 @@ static bool kprobe_enabled;
 DEFINE_MUTEX(kprobe_mutex);             /* Protects kprobe_table */
 static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
 static struct {
-        spinlock_t lock ____cacheline_aligned;
+        spinlock_t lock ____cacheline_aligned_in_smp;
 } kretprobe_table_locks[KPROBE_TABLE_SIZE];
 
 static spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
@@ -613,30 +613,37 @@ static int __kprobes __register_kprobe(struct kprobe *p,
                 return -EINVAL;
         p->addr = addr;
 
-        if (!kernel_text_address((unsigned long) p->addr) ||
-            in_kprobes_functions((unsigned long) p->addr))
+        preempt_disable();
+        if (!__kernel_text_address((unsigned long) p->addr) ||
+            in_kprobes_functions((unsigned long) p->addr)) {
+                preempt_enable();
                 return -EINVAL;
+        }
 
         p->mod_refcounted = 0;
 
         /*
          * Check if are we probing a module.
          */
-        probed_mod = module_text_address((unsigned long) p->addr);
+        probed_mod = __module_text_address((unsigned long) p->addr);
         if (probed_mod) {
-                struct module *calling_mod = module_text_address(called_from);
+                struct module *calling_mod;
+                calling_mod = __module_text_address(called_from);
                 /*
                  * We must allow modules to probe themself and in this case
                  * avoid incrementing the module refcount, so as to allow
                  * unloading of self probing modules.
                  */
                 if (calling_mod && calling_mod != probed_mod) {
-                        if (unlikely(!try_module_get(probed_mod)))
+                        if (unlikely(!try_module_get(probed_mod))) {
+                                preempt_enable();
                                 return -EINVAL;
+                        }
                         p->mod_refcounted = 1;
                 } else
                         probed_mod = NULL;
         }
+        preempt_enable();
 
         p->nmissed = 0;
         INIT_LIST_HEAD(&p->list);
@@ -718,6 +725,10 @@ static void __kprobes __unregister_kprobe_bottom(struct kprobe *p)
         struct kprobe *old_p;
 
         if (p->mod_refcounted) {
+                /*
+                 * Since we've already incremented refcount,
+                 * we don't need to disable preemption.
+                 */
                 mod = module_text_address((unsigned long)p->addr);
                 if (mod)
                         module_put(mod);
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 8e7a7ce3ed0a..4fbc456f393d 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -21,6 +21,9 @@ static DEFINE_SPINLOCK(kthread_create_lock);
 static LIST_HEAD(kthread_create_list);
 struct task_struct *kthreadd_task;
 
+DEFINE_TRACE(sched_kthread_stop);
+DEFINE_TRACE(sched_kthread_stop_ret);
+
 struct kthread_create_info
 {
         /* Information passed to kthread() from kthreadd. */
diff --git a/kernel/latencytop.c b/kernel/latencytop.c
index 5e7b45c56923..449db466bdbc 100644
--- a/kernel/latencytop.c
+++ b/kernel/latencytop.c
@@ -191,7 +191,7 @@ static int lstats_show(struct seq_file *m, void *v)
                                 latency_record[i].time,
                                 latency_record[i].max);
                         for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
-                                char sym[KSYM_NAME_LEN];
+                                char sym[KSYM_SYMBOL_LEN];
                                 char *c;
                                 if (!latency_record[i].backtrace[q])
                                         break;
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 06e157119d2b..c4c7df23f8c7 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -25,6 +25,7 @@
  * Thanks to Arjan van de Ven for coming up with the initial idea of
  * mapping lock dependencies runtime.
  */
+#define DISABLE_BRANCH_PROFILING
 #include <linux/mutex.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
@@ -136,16 +137,16 @@ static inline struct lock_class *hlock_class(struct held_lock *hlock)
 #ifdef CONFIG_LOCK_STAT
 static DEFINE_PER_CPU(struct lock_class_stats[MAX_LOCKDEP_KEYS], lock_stats);
 
-static int lock_contention_point(struct lock_class *class, unsigned long ip)
+static int lock_point(unsigned long points[], unsigned long ip)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(class->contention_point); i++) {
-                if (class->contention_point[i] == 0) {
-                        class->contention_point[i] = ip;
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
+                if (points[i] == 0) {
+                        points[i] = ip;
                         break;
                 }
-                if (class->contention_point[i] == ip)
+                if (points[i] == ip)
                         break;
         }
 
@@ -185,6 +186,9 @@ struct lock_class_stats lock_stats(struct lock_class *class)
                 for (i = 0; i < ARRAY_SIZE(stats.contention_point); i++)
                         stats.contention_point[i] += pcs->contention_point[i];
 
+                for (i = 0; i < ARRAY_SIZE(stats.contending_point); i++)
+                        stats.contending_point[i] += pcs->contending_point[i];
+
                 lock_time_add(&pcs->read_waittime, &stats.read_waittime);
                 lock_time_add(&pcs->write_waittime, &stats.write_waittime);
 
@@ -209,6 +213,7 @@ void clear_lock_stats(struct lock_class *class)
                 memset(cpu_stats, 0, sizeof(struct lock_class_stats));
         }
         memset(class->contention_point, 0, sizeof(class->contention_point));
+        memset(class->contending_point, 0, sizeof(class->contending_point));
 }
 
 static struct lock_class_stats *get_lock_stats(struct lock_class *class)
@@ -2999,7 +3004,7 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
         struct held_lock *hlock, *prev_hlock;
         struct lock_class_stats *stats;
         unsigned int depth;
-        int i, point;
+        int i, contention_point, contending_point;
 
         depth = curr->lockdep_depth;
         if (DEBUG_LOCKS_WARN_ON(!depth))
@@ -3023,18 +3028,22 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
 found_it:
         hlock->waittime_stamp = sched_clock();
 
-        point = lock_contention_point(hlock_class(hlock), ip);
+        contention_point = lock_point(hlock_class(hlock)->contention_point, ip);
+        contending_point = lock_point(hlock_class(hlock)->contending_point,
+                                      lock->ip);
 
         stats = get_lock_stats(hlock_class(hlock));
-        if (point < ARRAY_SIZE(stats->contention_point))
-                stats->contention_point[point]++;
+        if (contention_point < LOCKSTAT_POINTS)
+                stats->contention_point[contention_point]++;
+        if (contending_point < LOCKSTAT_POINTS)
+                stats->contending_point[contending_point]++;
         if (lock->cpu != smp_processor_id())
                 stats->bounces[bounce_contended + !!hlock->read]++;
         put_lock_stats(stats);
 }
 
 static void
-__lock_acquired(struct lockdep_map *lock)
+__lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
         struct task_struct *curr = current;
         struct held_lock *hlock, *prev_hlock;
@@ -3083,6 +3092,7 @@ found_it:
         put_lock_stats(stats);
 
         lock->cpu = cpu;
+        lock->ip = ip;
 }
 
 void lock_contended(struct lockdep_map *lock, unsigned long ip)
@@ -3104,7 +3114,7 @@ void lock_contended(struct lockdep_map *lock, unsigned long ip)
 }
 EXPORT_SYMBOL_GPL(lock_contended);
 
-void lock_acquired(struct lockdep_map *lock)
+void lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
         unsigned long flags;
 
@@ -3117,7 +3127,7 @@ void lock_acquired(struct lockdep_map *lock)
         raw_local_irq_save(flags);
         check_flags(flags);
         current->lockdep_recursion = 1;
-        __lock_acquired(lock);
+        __lock_acquired(lock, ip);
         current->lockdep_recursion = 0;
         raw_local_irq_restore(flags);
 }
@@ -3276,10 +3286,10 @@ void __init lockdep_info(void)
 {
         printk("Lock dependency validator: Copyright (c) 2006 Red Hat, Inc., Ingo Molnar\n");
 
-        printk("... MAX_LOCKDEP_SUBCLASSES:    %lu\n", MAX_LOCKDEP_SUBCLASSES);
+        printk("... MAX_LOCKDEP_SUBCLASSES:  %lu\n", MAX_LOCKDEP_SUBCLASSES);
         printk("... MAX_LOCK_DEPTH:          %lu\n", MAX_LOCK_DEPTH);
         printk("... MAX_LOCKDEP_KEYS:        %lu\n", MAX_LOCKDEP_KEYS);
-        printk("... CLASSHASH_SIZE:           %lu\n", CLASSHASH_SIZE);
+        printk("... CLASSHASH_SIZE:          %lu\n", CLASSHASH_SIZE);
         printk("... MAX_LOCKDEP_ENTRIES:     %lu\n", MAX_LOCKDEP_ENTRIES);
         printk("... MAX_LOCKDEP_CHAINS:      %lu\n", MAX_LOCKDEP_CHAINS);
         printk("... CHAINHASH_SIZE:          %lu\n", CHAINHASH_SIZE);
diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
index 20dbcbf9c7dd..13716b813896 100644
--- a/kernel/lockdep_proc.c
+++ b/kernel/lockdep_proc.c
@@ -470,11 +470,12 @@ static void seq_line(struct seq_file *m, char c, int offset, int length)
 
 static void snprint_time(char *buf, size_t bufsiz, s64 nr)
 {
-        unsigned long rem;
+        s64 div;
+        s32 rem;
 
         nr += 5; /* for display rounding */
-        rem = do_div(nr, 1000); /* XXX: do_div_signed */
-        snprintf(buf, bufsiz, "%lld.%02d", (long long)nr, (int)rem/10);
+        div = div_s64_rem(nr, 1000, &rem);
+        snprintf(buf, bufsiz, "%lld.%02d", (long long)div, (int)rem/10);
 }
 
 static void seq_time(struct seq_file *m, s64 time)
@@ -556,7 +557,7 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
         if (stats->read_holdtime.nr)
                 namelen += 2;
 
-        for (i = 0; i < ARRAY_SIZE(class->contention_point); i++) {
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
                 char sym[KSYM_SYMBOL_LEN];
                 char ip[32];
 
@@ -573,6 +574,23 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
                                 stats->contention_point[i],
                                 ip, sym);
         }
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
+                char sym[KSYM_SYMBOL_LEN];
+                char ip[32];
+
+                if (class->contending_point[i] == 0)
+                        break;
+
+                if (!i)
+                        seq_line(m, '-', 40-namelen, namelen);
+
+                sprint_symbol(sym, class->contending_point[i]);
+                snprintf(ip, sizeof(ip), "[<%p>]",
+                                (void *)class->contending_point[i]);
+                seq_printf(m, "%40s %14lu %29s %s\n", name,
+                                stats->contending_point[i],
+                                ip, sym);
+        }
         if (i) {
                 seq_puts(m, "\n");
                 seq_line(m, '.', 0, 40 + 1 + 10 * (14 + 1));
@@ -582,7 +600,7 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
 
 static void seq_header(struct seq_file *m)
 {
-        seq_printf(m, "lock_stat version 0.2\n");
+        seq_printf(m, "lock_stat version 0.3\n");
         seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
         seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s "
                         "%14s %14s\n",
diff --git a/kernel/marker.c b/kernel/marker.c
index e9c6b2bc9400..ea54f2647868 100644
--- a/kernel/marker.c
+++ b/kernel/marker.c
@@ -43,6 +43,7 @@ static DEFINE_MUTEX(markers_mutex);
  */
 #define MARKER_HASH_BITS 6
 #define MARKER_TABLE_SIZE (1 << MARKER_HASH_BITS)
+static struct hlist_head marker_table[MARKER_TABLE_SIZE];
 
 /*
  * Note about RCU :
@@ -64,11 +65,10 @@ struct marker_entry {
         void *oldptr;
         int rcu_pending;
         unsigned char ptype:1;
+        unsigned char format_allocated:1;
         char name[0];   /* Contains name'\0'format'\0' */
 };
 
-static struct hlist_head marker_table[MARKER_TABLE_SIZE];
-
 /**
  * __mark_empty_function - Empty probe callback
  * @probe_private: probe private data
@@ -81,7 +81,7 @@ static struct hlist_head marker_table[MARKER_TABLE_SIZE];
  * though the function pointer change and the marker enabling are two distinct
  * operations that modifies the execution flow of preemptible code.
  */
-void __mark_empty_function(void *probe_private, void *call_private,
+notrace void __mark_empty_function(void *probe_private, void *call_private,
         const char *fmt, va_list *args)
 {
 }
@@ -97,7 +97,8 @@ EXPORT_SYMBOL_GPL(__mark_empty_function);
  * need to put a full smp_rmb() in this branch. This is why we do not use
  * rcu_dereference() for the pointer read.
  */
-void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
+notrace void marker_probe_cb(const struct marker *mdata,
+                void *call_private, ...)
 {
         va_list args;
         char ptype;
@@ -107,7 +108,7 @@ void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
          * sure the teardown of the callbacks can be done correctly when they
          * are in modules and they insure RCU read coherency.
          */
-        rcu_read_lock_sched();
+        rcu_read_lock_sched_notrace();
         ptype = mdata->ptype;
         if (likely(!ptype)) {
                 marker_probe_func *func;
@@ -145,7 +146,7 @@ void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
                         va_end(args);
                 }
         }
-        rcu_read_unlock_sched();
+        rcu_read_unlock_sched_notrace();
 }
 EXPORT_SYMBOL_GPL(marker_probe_cb);
 
@@ -157,12 +158,13 @@ EXPORT_SYMBOL_GPL(marker_probe_cb);
  *
  * Should be connected to markers "MARK_NOARGS".
  */
-void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
+static notrace void marker_probe_cb_noarg(const struct marker *mdata,
+                void *call_private, ...)
 {
         va_list args;   /* not initialized */
         char ptype;
 
-        rcu_read_lock_sched();
+        rcu_read_lock_sched_notrace();
         ptype = mdata->ptype;
         if (likely(!ptype)) {
                 marker_probe_func *func;
@@ -195,9 +197,8 @@ void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
                         multi[i].func(multi[i].probe_private, call_private,
                                 mdata->format, &args);
         }
-        rcu_read_unlock_sched();
+        rcu_read_unlock_sched_notrace();
 }
-EXPORT_SYMBOL_GPL(marker_probe_cb_noarg);
 
 static void free_old_closure(struct rcu_head *head)
 {
@@ -416,6 +417,7 @@ static struct marker_entry *add_marker(const char *name, const char *format)
         e->single.probe_private = NULL;
         e->multi = NULL;
         e->ptype = 0;
+        e->format_allocated = 0;
         e->refcount = 0;
         e->rcu_pending = 0;
         hlist_add_head(&e->hlist, head);
@@ -447,6 +449,8 @@ static int remove_marker(const char *name)
         if (e->single.func != __mark_empty_function)
                 return -EBUSY;
         hlist_del(&e->hlist);
+        if (e->format_allocated)
+                kfree(e->format);
         /* Make sure the call_rcu has been executed */
         if (e->rcu_pending)
                 rcu_barrier_sched();
@@ -457,57 +461,34 @@ static int remove_marker(const char *name)
 /*
  * Set the mark_entry format to the format found in the element.
  */
-static int marker_set_format(struct marker_entry **entry, const char *format)
+static int marker_set_format(struct marker_entry *entry, const char *format)
 {
-        struct marker_entry *e;
-        size_t name_len = strlen((*entry)->name) + 1;
-        size_t format_len = strlen(format) + 1;
-
-
-        e = kmalloc(sizeof(struct marker_entry) + name_len + format_len,
-                        GFP_KERNEL);
-        if (!e)
+        entry->format = kstrdup(format, GFP_KERNEL);
+        if (!entry->format)
                 return -ENOMEM;
-        memcpy(&e->name[0], (*entry)->name, name_len);
-        e->format = &e->name[name_len];
-        memcpy(e->format, format, format_len);
-        if (strcmp(e->format, MARK_NOARGS) == 0)
-                e->call = marker_probe_cb_noarg;
-        else
-                e->call = marker_probe_cb;
-        e->single = (*entry)->single;
-        e->multi = (*entry)->multi;
-        e->ptype = (*entry)->ptype;
-        e->refcount = (*entry)->refcount;
-        e->rcu_pending = 0;
-        hlist_add_before(&e->hlist, &(*entry)->hlist);
-        hlist_del(&(*entry)->hlist);
-        /* Make sure the call_rcu has been executed */
-        if ((*entry)->rcu_pending)
-                rcu_barrier_sched();
-        kfree(*entry);
-        *entry = e;
+        entry->format_allocated = 1;
+
         trace_mark(core_marker_format, "name %s format %s",
-                        e->name, e->format);
+                        entry->name, entry->format);
         return 0;
 }
 
 /*
  * Sets the probe callback corresponding to one marker.
  */
-static int set_marker(struct marker_entry **entry, struct marker *elem,
+static int set_marker(struct marker_entry *entry, struct marker *elem,
                 int active)
 {
-        int ret;
-        WARN_ON(strcmp((*entry)->name, elem->name) != 0);
+        int ret = 0;
+        WARN_ON(strcmp(entry->name, elem->name) != 0);
 
-        if ((*entry)->format) {
-                if (strcmp((*entry)->format, elem->format) != 0) {
+        if (entry->format) {
+                if (strcmp(entry->format, elem->format) != 0) {
                         printk(KERN_NOTICE
                                 "Format mismatch for probe %s "
                                 "(%s), marker (%s)\n",
-                                (*entry)->name,
-                                (*entry)->format,
+                                entry->name,
+                                entry->format,
                                 elem->format);
                         return -EPERM;
                 }
@@ -523,37 +504,67 @@ static int set_marker(struct marker_entry **entry, struct marker *elem,
          * pass from a "safe" callback (with argument) to an "unsafe"
          * callback (does not set arguments).
          */
-        elem->call = (*entry)->call;
+        elem->call = entry->call;
         /*
          * Sanity check :
          * We only update the single probe private data when the ptr is
          * set to a _non_ single probe! (0 -> 1 and N -> 1, N != 1)
          */
         WARN_ON(elem->single.func != __mark_empty_function
-                && elem->single.probe_private
-                != (*entry)->single.probe_private &&
-                !elem->ptype);
-        elem->single.probe_private = (*entry)->single.probe_private;
+                && elem->single.probe_private != entry->single.probe_private
+                && !elem->ptype);
+        elem->single.probe_private = entry->single.probe_private;
         /*
          * Make sure the private data is valid when we update the
          * single probe ptr.
          */
         smp_wmb();
-        elem->single.func = (*entry)->single.func;
+        elem->single.func = entry->single.func;
         /*
          * We also make sure that the new probe callbacks array is consistent
          * before setting a pointer to it.
          */
-        rcu_assign_pointer(elem->multi, (*entry)->multi);
+        rcu_assign_pointer(elem->multi, entry->multi);
         /*
          * Update the function or multi probe array pointer before setting the
          * ptype.
          */
         smp_wmb();
-        elem->ptype = (*entry)->ptype;
+        elem->ptype = entry->ptype;
+
+        if (elem->tp_name && (active ^ elem->state)) {
+                WARN_ON(!elem->tp_cb);
+                /*
+                 * It is ok to directly call the probe registration because type
+                 * checking has been done in the __trace_mark_tp() macro.
+                 */
+
+                if (active) {
+                        /*
+                         * try_module_get should always succeed because we hold
+                         * lock_module() to get the tp_cb address.
+                         */
+                        ret = try_module_get(__module_text_address(
+                                (unsigned long)elem->tp_cb));
+                        BUG_ON(!ret);
+                        ret = tracepoint_probe_register_noupdate(
+                                elem->tp_name,
+                                elem->tp_cb);
+                } else {
+                        ret = tracepoint_probe_unregister_noupdate(
+                                elem->tp_name,
+                                elem->tp_cb);
+                        /*
+                         * tracepoint_probe_update_all() must be called
+                         * before the module containing tp_cb is unloaded.
+                         */
+                        module_put(__module_text_address(
+                                (unsigned long)elem->tp_cb));
+                }
+        }
         elem->state = active;
 
-        return 0;
+        return ret;
 }
 
 /*
@@ -564,7 +575,24 @@ static int set_marker(struct marker_entry **entry, struct marker *elem,
  */
 static void disable_marker(struct marker *elem)
 {
+        int ret;
+
         /* leave "call" as is. It is known statically. */
+        if (elem->tp_name && elem->state) {
+                WARN_ON(!elem->tp_cb);
+                /*
+                 * It is ok to directly call the probe registration because type
+                 * checking has been done in the __trace_mark_tp() macro.
+                 */
+                ret = tracepoint_probe_unregister_noupdate(elem->tp_name,
+                        elem->tp_cb);
+                WARN_ON(ret);
+                /*
+                 * tracepoint_probe_update_all() must be called
+                 * before the module containing tp_cb is unloaded.
+                 */
+                module_put(__module_text_address((unsigned long)elem->tp_cb));
+        }
         elem->state = 0;
         elem->single.func = __mark_empty_function;
         /* Update the function before setting the ptype */
@@ -594,8 +622,7 @@ void marker_update_probe_range(struct marker *begin,
         for (iter = begin; iter < end; iter++) {
                 mark_entry = get_marker(iter->name);
                 if (mark_entry) {
-                        set_marker(&mark_entry, iter,
-                                        !!mark_entry->refcount);
+                        set_marker(mark_entry, iter, !!mark_entry->refcount);
                         /*
                          * ignore error, continue
                          */
@@ -629,6 +656,7 @@ static void marker_update_probes(void)
         marker_update_probe_range(__start___markers, __stop___markers);
         /* Markers in modules. */
         module_update_markers();
+        tracepoint_probe_update_all();
 }
 
 /**
@@ -657,7 +685,7 @@ int marker_probe_register(const char *name, const char *format,
                         ret = PTR_ERR(entry);
         } else if (format) {
                 if (!entry->format)
-                        ret = marker_set_format(&entry, format);
+                        ret = marker_set_format(entry, format);
                 else if (strcmp(entry->format, format))
                         ret = -EPERM;
         }
@@ -676,10 +704,11 @@ int marker_probe_register(const char *name, const char *format,
                 goto end;
         }
         mutex_unlock(&markers_mutex);
-        marker_update_probes();         /* may update entry */
+        marker_update_probes();
         mutex_lock(&markers_mutex);
         entry = get_marker(name);
-        WARN_ON(!entry);
+        if (!entry)
+                goto end;
         if (entry->rcu_pending)
                 rcu_barrier_sched();
         entry->oldptr = old;
@@ -720,7 +749,7 @@ int marker_probe_unregister(const char *name,
                 rcu_barrier_sched();
         old = marker_entry_remove_probe(entry, probe, probe_private);
         mutex_unlock(&markers_mutex);
-        marker_update_probes();         /* may update entry */
+        marker_update_probes();
         mutex_lock(&markers_mutex);
         entry = get_marker(name);
         if (!entry)
@@ -801,10 +830,11 @@ int marker_probe_unregister_private_data(marker_probe_func *probe,
                 rcu_barrier_sched();
         old = marker_entry_remove_probe(entry, NULL, probe_private);
         mutex_unlock(&markers_mutex);
-        marker_update_probes();         /* may update entry */
+        marker_update_probes();
         mutex_lock(&markers_mutex);
         entry = get_marker_from_private_data(probe, probe_private);
-        WARN_ON(!entry);
+        if (!entry)
+                goto end;
         if (entry->rcu_pending)
                 rcu_barrier_sched();
         entry->oldptr = old;
@@ -848,8 +878,6 @@ void *marker_get_private_data(const char *name, marker_probe_func *probe,
                         if (!e->ptype) {
                                 if (num == 0 && e->single.func == probe)
                                         return e->single.probe_private;
-                                else
-                                        break;
                         } else {
                                 struct marker_probe_closure *closure;
                                 int match = 0;
@@ -861,8 +889,42 @@ void *marker_get_private_data(const char *name, marker_probe_func *probe,
                                                 return closure[i].probe_private;
                                 }
                         }
+                        break;
                 }
         }
         return ERR_PTR(-ENOENT);
 }
 EXPORT_SYMBOL_GPL(marker_get_private_data);
+
+#ifdef CONFIG_MODULES
+
+int marker_module_notify(struct notifier_block *self,
+                         unsigned long val, void *data)
+{
+        struct module *mod = data;
+
+        switch (val) {
+        case MODULE_STATE_COMING:
+                marker_update_probe_range(mod->markers,
+                        mod->markers + mod->num_markers);
+                break;
+        case MODULE_STATE_GOING:
+                marker_update_probe_range(mod->markers,
+                        mod->markers + mod->num_markers);
+                break;
+        }
+        return 0;
+}
+
+struct notifier_block marker_module_nb = {
+        .notifier_call = marker_module_notify,
+        .priority = 0,
+};
+
+static int init_markers(void)
+{
+        return register_module_notifier(&marker_module_nb);
+}
+__initcall(init_markers);
+
+#endif /* CONFIG_MODULES */
diff --git a/kernel/module.c b/kernel/module.c
index 1f4cc00e0c20..dd2a54155b54 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -2184,24 +2184,15 @@ static noinline struct module *load_module(void __user *umod,
                 struct mod_debug *debug;
                 unsigned int num_debug;
 
-#ifdef CONFIG_MARKERS
-                marker_update_probe_range(mod->markers,
-                        mod->markers + mod->num_markers);
-#endif
                 debug = section_objs(hdr, sechdrs, secstrings, "__verbose",
                                      sizeof(*debug), &num_debug);
                 dynamic_printk_setup(debug, num_debug);
-
-#ifdef CONFIG_TRACEPOINTS
-                tracepoint_update_probe_range(mod->tracepoints,
-                        mod->tracepoints + mod->num_tracepoints);
-#endif
         }
 
         /* sechdrs[0].sh_size is always zero */
         mseg = section_objs(hdr, sechdrs, secstrings, "__mcount_loc",
                             sizeof(*mseg), &num_mcount);
-        ftrace_init_module(mseg, mseg + num_mcount);
+        ftrace_init_module(mod, mseg, mseg + num_mcount);
 
         err = module_finalize(hdr, sechdrs, mod);
         if (err < 0)
@@ -2713,7 +2704,7 @@ int is_module_address(unsigned long addr)
 
 
 /* Is this a valid kernel address? */
-struct module *__module_text_address(unsigned long addr)
+__notrace_funcgraph struct module *__module_text_address(unsigned long addr)
 {
         struct module *mod;
 
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 12c779dc65d4..4f45d4b658ef 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -59,7 +59,7 @@ EXPORT_SYMBOL(__mutex_init);
  * We also put the fastpath first in the kernel image, to make sure the
  * branch is predicted by the CPU as default-untaken.
  */
-static void noinline __sched
+static __used noinline void __sched
 __mutex_lock_slowpath(atomic_t *lock_count);
 
 /***
@@ -96,7 +96,7 @@ void inline __sched mutex_lock(struct mutex *lock)
 EXPORT_SYMBOL(mutex_lock);
 #endif
 
-static noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
+static __used noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
 
 /***
  * mutex_unlock - release the mutex
@@ -184,7 +184,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
         }
 
 done:
-        lock_acquired(&lock->dep_map);
+        lock_acquired(&lock->dep_map, ip);
         /* got the lock - rejoice! */
         mutex_remove_waiter(lock, &waiter, task_thread_info(task));
         debug_mutex_set_owner(lock, task_thread_info(task));
@@ -268,7 +268,7 @@ __mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
 /*
  * Release the lock, slowpath:
  */
-static noinline void
+static __used noinline void
 __mutex_unlock_slowpath(atomic_t *lock_count)
 {
         __mutex_unlock_common_slowpath(lock_count, 1);
@@ -313,7 +313,7 @@ int __sched mutex_lock_killable(struct mutex *lock)
 }
 EXPORT_SYMBOL(mutex_lock_killable);
 
-static noinline void __sched
+static __used noinline void __sched
 __mutex_lock_slowpath(atomic_t *lock_count)
 {
         struct mutex *lock = container_of(lock_count, struct mutex, count);
diff --git a/kernel/notifier.c b/kernel/notifier.c
index 4282c0a40a57..61d5aa5eced3 100644
--- a/kernel/notifier.c
+++ b/kernel/notifier.c
@@ -82,6 +82,14 @@ static int __kprobes notifier_call_chain(struct notifier_block **nl,
 
         while (nb && nr_to_call) {
                 next_nb = rcu_dereference(nb->next);
+
+#ifdef CONFIG_DEBUG_NOTIFIERS
+                if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {
+                        WARN(1, "Invalid notifier called!");
+                        nb = next_nb;
+                        continue;
+                }
+#endif
                 ret = nb->notifier_call(nb, val, v);
 
                 if (nr_calls)
diff --git a/kernel/panic.c b/kernel/panic.c
index 6513aac8e992..4d5088355bfe 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -167,6 +167,7 @@ static const struct tnt tnts[] = {
  *  'M' - System experienced a machine check exception.
  *  'B' - System has hit bad_page.
  *  'U' - Userspace-defined naughtiness.
+ *  'D' - Kernel has oopsed before
  *  'A' - ACPI table overridden.
  *  'W' - Taint on warning.
  *  'C' - modules from drivers/staging are loaded.
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 153dcb2639c3..157de3a47832 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -58,21 +58,21 @@ void thread_group_cputime(
         struct task_struct *tsk,
         struct task_cputime *times)
 {
-        struct signal_struct *sig;
+        struct task_cputime *totals, *tot;
         int i;
-        struct task_cputime *tot;
 
-        sig = tsk->signal;
-        if (unlikely(!sig) || !sig->cputime.totals) {
+        totals = tsk->signal->cputime.totals;
+        if (!totals) {
                 times->utime = tsk->utime;
                 times->stime = tsk->stime;
                 times->sum_exec_runtime = tsk->se.sum_exec_runtime;
                 return;
         }
+
         times->stime = times->utime = cputime_zero;
         times->sum_exec_runtime = 0;
         for_each_possible_cpu(i) {
-                tot = per_cpu_ptr(tsk->signal->cputime.totals, i);
+                tot = per_cpu_ptr(totals, i);
                 times->utime = cputime_add(times->utime, tot->utime);
                 times->stime = cputime_add(times->stime, tot->stime);
                 times->sum_exec_runtime += tot->sum_exec_runtime;
@@ -311,7 +311,7 @@ static int cpu_clock_sample_group(const clockid_t which_clock,
         struct task_cputime cputime;
 
         thread_group_cputime(p, &cputime);
-        switch (which_clock) {
+        switch (CPUCLOCK_WHICH(which_clock)) {
         default:
                 return -EINVAL;
         case CPUCLOCK_PROF:
@@ -1308,9 +1308,10 @@ static inline int task_cputime_expired(const struct task_cputime *sample,
  */
 static inline int fastpath_timer_check(struct task_struct *tsk)
 {
-        struct signal_struct *sig = tsk->signal;
+        struct signal_struct *sig;
 
-        if (unlikely(!sig))
+        /* tsk == current, ensure it is safe to use ->signal/sighand */
+        if (unlikely(tsk->exit_state))
                 return 0;
 
         if (!task_cputime_zero(&tsk->cputime_expires)) {
@@ -1323,6 +1324,8 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
                 if (task_cputime_expired(&task_sample, &tsk->cputime_expires))
                         return 1;
         }
+
+        sig = tsk->signal;
         if (!task_cputime_zero(&sig->cputime_expires)) {
                 struct task_cputime group_sample;
 
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index c9d74083746f..f77d3819ef57 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -22,7 +22,6 @@
 #include <linux/console.h>
 #include <linux/cpu.h>
 #include <linux/freezer.h>
-#include <linux/ftrace.h>
 
 #include "power.h"
 
@@ -257,7 +256,7 @@ static int create_image(int platform_mode)
 
 int hibernation_snapshot(int platform_mode)
 {
-        int error, ftrace_save;
+        int error;
 
         /* Free memory before shutting down devices. */
         error = swsusp_shrink_memory();
@@ -269,7 +268,6 @@ int hibernation_snapshot(int platform_mode)
                 goto Close;
 
         suspend_console();
-        ftrace_save = __ftrace_enabled_save();
         error = device_suspend(PMSG_FREEZE);
         if (error)
                 goto Recover_platform;
@@ -299,7 +297,6 @@ int hibernation_snapshot(int platform_mode)
  Resume_devices:
         device_resume(in_suspend ?
                 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
-        __ftrace_enabled_restore(ftrace_save);
         resume_console();
  Close:
         platform_end(platform_mode);
@@ -370,11 +367,10 @@ static int resume_target_kernel(void)
 
 int hibernation_restore(int platform_mode)
 {
-        int error, ftrace_save;
+        int error;
 
         pm_prepare_console();
         suspend_console();
-        ftrace_save = __ftrace_enabled_save();
         error = device_suspend(PMSG_QUIESCE);
         if (error)
                 goto Finish;
@@ -389,7 +385,6 @@ int hibernation_restore(int platform_mode)
         platform_restore_cleanup(platform_mode);
         device_resume(PMSG_RECOVER);
  Finish:
-        __ftrace_enabled_restore(ftrace_save);
         resume_console();
         pm_restore_console();
         return error;
@@ -402,7 +397,7 @@ int hibernation_restore(int platform_mode)
 
 int hibernation_platform_enter(void)
 {
-        int error, ftrace_save;
+        int error;
 
         if (!hibernation_ops)
                 return -ENOSYS;
@@ -417,7 +412,6 @@ int hibernation_platform_enter(void)
                 goto Close;
 
         suspend_console();
-        ftrace_save = __ftrace_enabled_save();
         error = device_suspend(PMSG_HIBERNATE);
         if (error) {
                 if (hibernation_ops->recover)
@@ -452,7 +446,6 @@ int hibernation_platform_enter(void)
         hibernation_ops->finish();
  Resume_devices:
         device_resume(PMSG_RESTORE);
-        __ftrace_enabled_restore(ftrace_save);
         resume_console();
  Close:
         hibernation_ops->end();
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 19122cf6d827..613f16941b85 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -22,7 +22,6 @@
 #include <linux/freezer.h>
 #include <linux/vmstat.h>
 #include <linux/syscalls.h>
-#include <linux/ftrace.h>
 
 #include "power.h"
 
@@ -174,7 +173,7 @@ static void suspend_test_finish(const char *label)
          * has some performance issues.  The stack dump of a WARN_ON
          * is more likely to get the right attention than a printk...
          */
-        WARN_ON(msec > (TEST_SUSPEND_SECONDS * 1000));
+        WARN(msec > (TEST_SUSPEND_SECONDS * 1000), "Component: %s\n", label);
 }
 
 #else
@@ -317,7 +316,7 @@ static int suspend_enter(suspend_state_t state)
  */
 int suspend_devices_and_enter(suspend_state_t state)
 {
-        int error, ftrace_save;
+        int error;
 
         if (!suspend_ops)
                 return -ENOSYS;
@@ -328,7 +327,6 @@ int suspend_devices_and_enter(suspend_state_t state)
                         goto Close;
         }
         suspend_console();
-        ftrace_save = __ftrace_enabled_save();
         suspend_test_start();
         error = device_suspend(PMSG_SUSPEND);
         if (error) {
@@ -360,7 +358,6 @@ int suspend_devices_and_enter(suspend_state_t state)
         suspend_test_start();
         device_resume(PMSG_RESUME);
         suspend_test_finish("resume devices");
-        __ftrace_enabled_restore(ftrace_save);
         resume_console();
  Close:
         if (suspend_ops->end)
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index b7713b53d07a..6da14358537c 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -633,7 +633,7 @@ void swsusp_close(fmode_t mode)
                 return;
         }
 
-        blkdev_put(resume_bdev, mode); /* move up */
+        blkdev_put(resume_bdev, mode);
 }
 
 static int swsusp_header_init(void)
diff --git a/kernel/profile.c b/kernel/profile.c
index 9830a037d8db..60adefb59b5e 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -351,7 +351,7 @@ out:
         put_cpu();
 }
 
-static int __devinit profile_cpu_callback(struct notifier_block *info,
+static int __cpuinit profile_cpu_callback(struct notifier_block *info,
                                         unsigned long action, void *__cpu)
 {
         int node, cpu = (unsigned long)__cpu;
@@ -544,7 +544,7 @@ static const struct file_operations proc_profile_operations = {
 };
 
 #ifdef CONFIG_SMP
-static void __init profile_nop(void *unused)
+static void profile_nop(void *unused)
 {
 }
 
@@ -596,7 +596,7 @@ out_cleanup:
 #define create_hash_tables()                    ({ 0; })
 #endif
 
-int create_proc_profile(void)
+int __ref create_proc_profile(void) /* false positive from hotcpu_notifier */
 {
         struct proc_dir_entry *entry;
 
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 1e68e4c39e2c..4c8bcd7dd8e0 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -612,7 +612,7 @@ int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
         return (copied == sizeof(data)) ? 0 : -EIO;
 }
 
-#if defined CONFIG_COMPAT && defined __ARCH_WANT_COMPAT_SYS_PTRACE
+#if defined CONFIG_COMPAT
 #include <linux/compat.h>
 
 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
@@ -709,4 +709,4 @@ asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
         unlock_kernel();
         return ret;
 }
-#endif  /* CONFIG_COMPAT && __ARCH_WANT_COMPAT_SYS_PTRACE */
+#endif  /* CONFIG_COMPAT */
diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
index 37f72e551542..c03ca3e61919 100644
--- a/kernel/rcuclassic.c
+++ b/kernel/rcuclassic.c
@@ -191,7 +191,7 @@ static void print_other_cpu_stall(struct rcu_ctrlblk *rcp)
 
         /* OK, time to rat on our buddy... */
 
-        printk(KERN_ERR "RCU detected CPU stalls:");
+        printk(KERN_ERR "INFO: RCU detected CPU stalls:");
         for_each_possible_cpu(cpu) {
                 if (cpu_isset(cpu, rcp->cpumask))
                         printk(" %d", cpu);
@@ -204,7 +204,7 @@ static void print_cpu_stall(struct rcu_ctrlblk *rcp)
 {
         unsigned long flags;
 
-        printk(KERN_ERR "RCU detected CPU %d stall (t=%lu/%lu jiffies)\n",
+        printk(KERN_ERR "INFO: RCU detected CPU %d stall (t=%lu/%lu jiffies)\n",
                         smp_processor_id(), jiffies,
                         jiffies - rcp->gp_start);
         dump_stack();
@@ -393,7 +393,7 @@ static void rcu_start_batch(struct rcu_ctrlblk *rcp)
                  * unnecessarily.
                  */
                 smp_mb();
-                cpus_andnot(rcp->cpumask, cpu_online_map, nohz_cpu_mask);
+                cpumask_andnot(&rcp->cpumask, cpu_online_mask, nohz_cpu_mask);
 
                 rcp->signaled = 0;
         }
diff --git a/kernel/relay.c b/kernel/relay.c
index 8d13a7855c08..09ac2008f77b 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -400,7 +400,7 @@ void relay_reset(struct rchan *chan)
         }
 
         mutex_lock(&relay_channels_mutex);
-        for_each_online_cpu(i)
+        for_each_possible_cpu(i)
                 if (chan->buf[i])
                         __relay_reset(chan->buf[i], 0);
         mutex_unlock(&relay_channels_mutex);
@@ -611,10 +611,9 @@ struct rchan *relay_open(const char *base_filename,
         return chan;
 
 free_bufs:
-        for_each_online_cpu(i) {
-                if (!chan->buf[i])
-                        break;
-                relay_close_buf(chan->buf[i]);
+        for_each_possible_cpu(i) {
+                if (chan->buf[i])
+                        relay_close_buf(chan->buf[i]);
         }
 
         kref_put(&chan->kref, relay_destroy_channel);
@@ -1318,12 +1317,9 @@ static ssize_t relay_file_splice_read(struct file *in,
                 if (ret < 0)
                         break;
                 else if (!ret) {
-                        if (spliced)
-                                break;
-                        if (flags & SPLICE_F_NONBLOCK) {
+                        if (flags & SPLICE_F_NONBLOCK)
                                 ret = -EAGAIN;
-                                break;
-                        }
+                        break;
                 }
 
                 *ppos += ret;
diff --git a/kernel/sched.c b/kernel/sched.c
index 57c933ffbee1..e00c92d22655 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -118,6 +118,12 @@
  */
 #define RUNTIME_INF     ((u64)~0ULL)
 
+DEFINE_TRACE(sched_wait_task);
+DEFINE_TRACE(sched_wakeup);
+DEFINE_TRACE(sched_wakeup_new);
+DEFINE_TRACE(sched_switch);
+DEFINE_TRACE(sched_migrate_task);
+
 #ifdef CONFIG_SMP
 /*
  * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
@@ -261,6 +267,10 @@ struct task_group {
         struct cgroup_subsys_state css;
 #endif
 
+#ifdef CONFIG_USER_SCHED
+        uid_t uid;
+#endif
+
 #ifdef CONFIG_FAIR_GROUP_SCHED
         /* schedulable entities of this group on each cpu */
         struct sched_entity **se;
@@ -286,6 +296,12 @@ struct task_group {
 
 #ifdef CONFIG_USER_SCHED
 
+/* Helper function to pass uid information to create_sched_user() */
+void set_tg_uid(struct user_struct *user)
+{
+        user->tg->uid = user->uid;
+}
+
 /*
  * Root task group.
  *      Every UID task group (including init_task_group aka UID-0) will
@@ -399,7 +415,7 @@ struct cfs_rq {
          */
         struct sched_entity *curr, *next, *last;
 
-        unsigned long nr_spread_over;
+        unsigned int nr_spread_over;
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
         struct rq *rq;  /* cpu runqueue to which this cfs_rq is attached */
@@ -481,14 +497,14 @@ struct rt_rq {
  */
 struct root_domain {
         atomic_t refcount;
-        cpumask_t span;
-        cpumask_t online;
+        cpumask_var_t span;
+        cpumask_var_t online;
 
         /*
          * The "RT overload" flag: it gets set if a CPU has more than
          * one runnable RT task.
          */
-        cpumask_t rto_mask;
+        cpumask_var_t rto_mask;
         atomic_t rto_count;
 #ifdef CONFIG_SMP
         struct cpupri cpupri;
@@ -703,45 +719,18 @@ static __read_mostly char *sched_feat_names[] = {
 
 #undef SCHED_FEAT
 
-static int sched_feat_open(struct inode *inode, struct file *filp)
-{
-        filp->private_data = inode->i_private;
-        return 0;
-}
-
-static ssize_t
-sched_feat_read(struct file *filp, char __user *ubuf,
-                size_t cnt, loff_t *ppos)
+static int sched_feat_show(struct seq_file *m, void *v)
 {
-        char *buf;
-        int r = 0;
-        int len = 0;
         int i;
 
         for (i = 0; sched_feat_names[i]; i++) {
-                len += strlen(sched_feat_names[i]);
-                len += 4;
+                if (!(sysctl_sched_features & (1UL << i)))
+                        seq_puts(m, "NO_");
+                seq_printf(m, "%s ", sched_feat_names[i]);
         }
+        seq_puts(m, "\n");
 
-        buf = kmalloc(len + 2, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-
-        for (i = 0; sched_feat_names[i]; i++) {
-                if (sysctl_sched_features & (1UL << i))
-                        r += sprintf(buf + r, "%s ", sched_feat_names[i]);
-                else
-                        r += sprintf(buf + r, "NO_%s ", sched_feat_names[i]);
-        }
-
-        r += sprintf(buf + r, "\n");
-        WARN_ON(r >= len + 2);
-
-        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-
-        kfree(buf);
-
-        return r;
+        return 0;
 }
 
 static ssize_t
@@ -786,10 +775,17 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
+static int sched_feat_open(struct inode *inode, struct file *filp)
+{
+        return single_open(filp, sched_feat_show, NULL);
+}
+
 static struct file_operations sched_feat_fops = {
-        .open   = sched_feat_open,
-        .read   = sched_feat_read,
-        .write  = sched_feat_write,
+        .open           = sched_feat_open,
+        .write          = sched_feat_write,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
 };
 
 static __init int sched_init_debug(void)
@@ -969,6 +965,14 @@ static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
         }
 }
 
+void task_rq_unlock_wait(struct task_struct *p)
+{
+        struct rq *rq = task_rq(p);
+
+        smp_mb(); /* spin-unlock-wait is not a full memory barrier */
+        spin_unlock_wait(&rq->lock);
+}
+
 static void __task_rq_unlock(struct rq *rq)
         __releases(rq->lock)
 {
@@ -1445,9 +1449,12 @@ static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
 static unsigned long cpu_avg_load_per_task(int cpu)
 {
         struct rq *rq = cpu_rq(cpu);
+        unsigned long nr_running = ACCESS_ONCE(rq->nr_running);
 
-        if (rq->nr_running)
-                rq->avg_load_per_task = rq->load.weight / rq->nr_running;
+        if (nr_running)
+                rq->avg_load_per_task = rq->load.weight / nr_running;
+        else
+                rq->avg_load_per_task = 0;
 
         return rq->avg_load_per_task;
 }
@@ -1463,27 +1470,13 @@ static void
 update_group_shares_cpu(struct task_group *tg, int cpu,
                         unsigned long sd_shares, unsigned long sd_rq_weight)
 {
-        int boost = 0;
         unsigned long shares;
         unsigned long rq_weight;
 
         if (!tg->se[cpu])
                 return;
 
-        rq_weight = tg->cfs_rq[cpu]->load.weight;
-
-        /*
-         * If there are currently no tasks on the cpu pretend there is one of
-         * average load so that when a new task gets to run here it will not
-         * get delayed by group starvation.
-         */
-        if (!rq_weight) {
-                boost = 1;
-                rq_weight = NICE_0_LOAD;
-        }
-
-        if (unlikely(rq_weight > sd_rq_weight))
-                rq_weight = sd_rq_weight;
+        rq_weight = tg->cfs_rq[cpu]->rq_weight;
 
         /*
          *           \Sum shares * rq_weight
@@ -1491,7 +1484,7 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
          *               \Sum rq_weight
          *
          */
-        shares = (sd_shares * rq_weight) / (sd_rq_weight + 1);
+        shares = (sd_shares * rq_weight) / sd_rq_weight;
         shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
 
         if (abs(shares - tg->se[cpu]->load.weight) >
@@ -1500,11 +1493,7 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
                 unsigned long flags;
 
                 spin_lock_irqsave(&rq->lock, flags);
-                /*
-                 * record the actual number of shares, not the boosted amount.
-                 */
-                tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
-                tg->cfs_rq[cpu]->rq_weight = rq_weight;
+                tg->cfs_rq[cpu]->shares = shares;
 
                 __set_se_shares(tg->se[cpu], shares);
                 spin_unlock_irqrestore(&rq->lock, flags);
@@ -1518,13 +1507,23 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
  */
 static int tg_shares_up(struct task_group *tg, void *data)
 {
-        unsigned long rq_weight = 0;
+        unsigned long weight, rq_weight = 0;
         unsigned long shares = 0;
         struct sched_domain *sd = data;
         int i;
 
-        for_each_cpu_mask(i, sd->span) {
-                rq_weight += tg->cfs_rq[i]->load.weight;
+        for_each_cpu(i, sched_domain_span(sd)) {
+                /*
+                 * If there are currently no tasks on the cpu pretend there
+                 * is one of average load so that when a new task gets to
+                 * run here it will not get delayed by group starvation.
+                 */
+                weight = tg->cfs_rq[i]->load.weight;
+                if (!weight)
+                        weight = NICE_0_LOAD;
+
+                tg->cfs_rq[i]->rq_weight = weight;
+                rq_weight += weight;
                 shares += tg->cfs_rq[i]->shares;
         }
 
@@ -1534,10 +1533,7 @@ static int tg_shares_up(struct task_group *tg, void *data)
         if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
                 shares = tg->shares;
 
-        if (!rq_weight)
-                rq_weight = cpus_weight(sd->span) * NICE_0_LOAD;
-
-        for_each_cpu_mask(i, sd->span)
+        for_each_cpu(i, sched_domain_span(sd))
                 update_group_shares_cpu(tg, i, shares, rq_weight);
 
         return 0;
@@ -1601,6 +1597,39 @@ static inline void update_shares_locked(struct rq *rq, struct sched_domain *sd)
 
 #endif
 
+/*
+ * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
+ */
+static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
+        __releases(this_rq->lock)
+        __acquires(busiest->lock)
+        __acquires(this_rq->lock)
+{
+        int ret = 0;
+
+        if (unlikely(!irqs_disabled())) {
+                /* printk() doesn't work good under rq->lock */
+                spin_unlock(&this_rq->lock);
+                BUG_ON(1);
+        }
+        if (unlikely(!spin_trylock(&busiest->lock))) {
+                if (busiest < this_rq) {
+                        spin_unlock(&this_rq->lock);
+                        spin_lock(&busiest->lock);
+                        spin_lock_nested(&this_rq->lock, SINGLE_DEPTH_NESTING);
+                        ret = 1;
+                } else
+                        spin_lock_nested(&busiest->lock, SINGLE_DEPTH_NESTING);
+        }
+        return ret;
+}
+
+static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
+        __releases(busiest->lock)
+{
+        spin_unlock(&busiest->lock);
+        lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
+}
 #endif
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
@@ -2068,15 +2097,17 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
                 int i;
 
                 /* Skip over this group if it has no CPUs allowed */
-                if (!cpus_intersects(group->cpumask, p->cpus_allowed))
+                if (!cpumask_intersects(sched_group_cpus(group),
+                                        &p->cpus_allowed))
                         continue;
 
-                local_group = cpu_isset(this_cpu, group->cpumask);
+                local_group = cpumask_test_cpu(this_cpu,
+                                               sched_group_cpus(group));
 
                 /* Tally up the load of all CPUs in the group */
                 avg_load = 0;
 
-                for_each_cpu_mask_nr(i, group->cpumask) {
+                for_each_cpu(i, sched_group_cpus(group)) {
                         /* Bias balancing toward cpus of our domain */
                         if (local_group)
                                 load = source_load(i, load_idx);
@@ -2108,17 +2139,14 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
  * find_idlest_cpu - find the idlest cpu among the cpus in group.
  */
 static int
-find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu,
-                cpumask_t *tmp)
+find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
 {
         unsigned long load, min_load = ULONG_MAX;
         int idlest = -1;
         int i;
 
         /* Traverse only the allowed CPUs */
-        cpus_and(*tmp, group->cpumask, p->cpus_allowed);
-
-        for_each_cpu_mask_nr(i, *tmp) {
+        for_each_cpu_and(i, sched_group_cpus(group), &p->cpus_allowed) {
                 load = weighted_cpuload(i);
 
                 if (load < min_load || (load == min_load && i == this_cpu)) {
@@ -2160,7 +2188,6 @@ static int sched_balance_self(int cpu, int flag)
                 update_shares(sd);
 
         while (sd) {
-                cpumask_t span, tmpmask;
                 struct sched_group *group;
                 int new_cpu, weight;
 
@@ -2169,14 +2196,13 @@ static int sched_balance_self(int cpu, int flag)
                         continue;
                 }
 
-                span = sd->span;
                 group = find_idlest_group(sd, t, cpu);
                 if (!group) {
                         sd = sd->child;
                         continue;
                 }
 
-                new_cpu = find_idlest_cpu(group, t, cpu, &tmpmask);
+                new_cpu = find_idlest_cpu(group, t, cpu);
                 if (new_cpu == -1 || new_cpu == cpu) {
                         /* Now try balancing at a lower domain level of cpu */
                         sd = sd->child;
@@ -2185,10 +2211,10 @@ static int sched_balance_self(int cpu, int flag)
 
                 /* Now try balancing at a lower domain level of new_cpu */
                 cpu = new_cpu;
+                weight = cpumask_weight(sched_domain_span(sd));
                 sd = NULL;
-                weight = cpus_weight(span);
                 for_each_domain(cpu, tmp) {
-                        if (weight <= cpus_weight(tmp->span))
+                        if (weight <= cpumask_weight(sched_domain_span(tmp)))
                                 break;
                         if (tmp->flags & flag)
                                 sd = tmp;
@@ -2233,7 +2259,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
                 cpu = task_cpu(p);
 
                 for_each_domain(this_cpu, sd) {
-                        if (cpu_isset(cpu, sd->span)) {
+                        if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                                 update_shares(sd);
                                 break;
                         }
@@ -2281,7 +2307,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
         else {
                 struct sched_domain *sd;
                 for_each_domain(this_cpu, sd) {
-                        if (cpu_isset(cpu, sd->span)) {
+                        if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                                 schedstat_inc(sd, ttwu_wake_remote);
                                 break;
                         }
@@ -2801,40 +2827,6 @@ static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
 }
 
 /*
- * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
- */
-static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
-        __releases(this_rq->lock)
-        __acquires(busiest->lock)
-        __acquires(this_rq->lock)
-{
-        int ret = 0;
-
-        if (unlikely(!irqs_disabled())) {
-                /* printk() doesn't work good under rq->lock */
-                spin_unlock(&this_rq->lock);
-                BUG_ON(1);
-        }
-        if (unlikely(!spin_trylock(&busiest->lock))) {
-                if (busiest < this_rq) {
-                        spin_unlock(&this_rq->lock);
-                        spin_lock(&busiest->lock);
-                        spin_lock_nested(&this_rq->lock, SINGLE_DEPTH_NESTING);
-                        ret = 1;
-                } else
-                        spin_lock_nested(&busiest->lock, SINGLE_DEPTH_NESTING);
-        }
-        return ret;
-}
-
-static void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
-        __releases(busiest->lock)
-{
-        spin_unlock(&busiest->lock);
-        lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
-}
-
-/*
  * If dest_cpu is allowed for this process, migrate the task to it.
  * This is accomplished by forcing the cpu_allowed mask to only
  * allow dest_cpu, which will force the cpu onto dest_cpu. Then
@@ -2847,7 +2839,7 @@ static void sched_migrate_task(struct task_struct *p, int dest_cpu)
         struct rq *rq;
 
         rq = task_rq_lock(p, &flags);
-        if (!cpu_isset(dest_cpu, p->cpus_allowed)
+        if (!cpumask_test_cpu(dest_cpu, &p->cpus_allowed)
             || unlikely(!cpu_active(dest_cpu)))
                 goto out;
 
@@ -2913,7 +2905,7 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
          * 2) cannot be migrated to this CPU due to cpus_allowed, or
          * 3) are cache-hot on their current CPU.
          */
-        if (!cpu_isset(this_cpu, p->cpus_allowed)) {
+        if (!cpumask_test_cpu(this_cpu, &p->cpus_allowed)) {
                 schedstat_inc(p, se.nr_failed_migrations_affine);
                 return 0;
         }
@@ -3088,7 +3080,7 @@ static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
 static struct sched_group *
 find_busiest_group(struct sched_domain *sd, int this_cpu,
                    unsigned long *imbalance, enum cpu_idle_type idle,
-                   int *sd_idle, const cpumask_t *cpus, int *balance)
+                   int *sd_idle, const struct cpumask *cpus, int *balance)
 {
         struct sched_group *busiest = NULL, *this = NULL, *group = sd->groups;
         unsigned long max_load, avg_load, total_load, this_load, total_pwr;
@@ -3124,10 +3116,11 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                 unsigned long sum_avg_load_per_task;
                 unsigned long avg_load_per_task;
 
-                local_group = cpu_isset(this_cpu, group->cpumask);
+                local_group = cpumask_test_cpu(this_cpu,
+                                               sched_group_cpus(group));
 
                 if (local_group)
-                        balance_cpu = first_cpu(group->cpumask);
+                        balance_cpu = cpumask_first(sched_group_cpus(group));
 
                 /* Tally up the load of all CPUs in the group */
                 sum_weighted_load = sum_nr_running = avg_load = 0;
@@ -3136,13 +3129,8 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                 max_cpu_load = 0;
                 min_cpu_load = ~0UL;
 
-                for_each_cpu_mask_nr(i, group->cpumask) {
-                        struct rq *rq;
-
-                        if (!cpu_isset(i, *cpus))
-                                continue;
-
-                        rq = cpu_rq(i);
+                for_each_cpu_and(i, sched_group_cpus(group), cpus) {
+                        struct rq *rq = cpu_rq(i);
 
                         if (*sd_idle && rq->nr_running)
                                 *sd_idle = 0;
@@ -3253,8 +3241,8 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                  */
                 if ((sum_nr_running < min_nr_running) ||
                     (sum_nr_running == min_nr_running &&
-                     first_cpu(group->cpumask) <
-                     first_cpu(group_min->cpumask))) {
+                     cpumask_first(sched_group_cpus(group)) <
+                     cpumask_first(sched_group_cpus(group_min)))) {
                         group_min = group;
                         min_nr_running = sum_nr_running;
                         min_load_per_task = sum_weighted_load /
@@ -3269,8 +3257,8 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                 if (sum_nr_running <= group_capacity - 1) {
                         if (sum_nr_running > leader_nr_running ||
                             (sum_nr_running == leader_nr_running &&
-                             first_cpu(group->cpumask) >
-                              first_cpu(group_leader->cpumask))) {
+                             cpumask_first(sched_group_cpus(group)) >
+                             cpumask_first(sched_group_cpus(group_leader)))) {
                                 group_leader = group;
                                 leader_nr_running = sum_nr_running;
                         }
@@ -3409,16 +3397,16 @@ ret:
  */
 static struct rq *
 find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
-                   unsigned long imbalance, const cpumask_t *cpus)
+                   unsigned long imbalance, const struct cpumask *cpus)
 {
         struct rq *busiest = NULL, *rq;
         unsigned long max_load = 0;
         int i;
 
-        for_each_cpu_mask_nr(i, group->cpumask) {
+        for_each_cpu(i, sched_group_cpus(group)) {
                 unsigned long wl;
 
-                if (!cpu_isset(i, *cpus))
+                if (!cpumask_test_cpu(i, cpus))
                         continue;
 
                 rq = cpu_rq(i);
@@ -3448,7 +3436,7 @@ find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
  */
 static int load_balance(int this_cpu, struct rq *this_rq,
                         struct sched_domain *sd, enum cpu_idle_type idle,
-                        int *balance, cpumask_t *cpus)
+                        int *balance, struct cpumask *cpus)
 {
         int ld_moved, all_pinned = 0, active_balance = 0, sd_idle = 0;
         struct sched_group *group;
@@ -3456,7 +3444,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
         struct rq *busiest;
         unsigned long flags;
 
-        cpus_setall(*cpus);
+        cpumask_setall(cpus);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -3516,8 +3504,8 @@ redo:
 
                 /* All tasks on this runqueue were pinned by CPU affinity */
                 if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), *cpus);
-                        if (!cpus_empty(*cpus))
+                        cpumask_clear_cpu(cpu_of(busiest), cpus);
+                        if (!cpumask_empty(cpus))
                                 goto redo;
                         goto out_balanced;
                 }
@@ -3534,7 +3522,8 @@ redo:
                         /* don't kick the migration_thread, if the curr
                          * task on busiest cpu can't be moved to this_cpu
                          */
-                        if (!cpu_isset(this_cpu, busiest->curr->cpus_allowed)) {
+                        if (!cpumask_test_cpu(this_cpu,
+                                              &busiest->curr->cpus_allowed)) {
                                 spin_unlock_irqrestore(&busiest->lock, flags);
                                 all_pinned = 1;
                                 goto out_one_pinned;
@@ -3609,7 +3598,7 @@ out:
  */
 static int
 load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd,
-                        cpumask_t *cpus)
+                        struct cpumask *cpus)
 {
         struct sched_group *group;
         struct rq *busiest = NULL;
@@ -3618,7 +3607,7 @@ load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd,
         int sd_idle = 0;
         int all_pinned = 0;
 
-        cpus_setall(*cpus);
+        cpumask_setall(cpus);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -3662,8 +3651,8 @@ redo:
                 double_unlock_balance(this_rq, busiest);
 
                 if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), *cpus);
-                        if (!cpus_empty(*cpus))
+                        cpumask_clear_cpu(cpu_of(busiest), cpus);
+                        if (!cpumask_empty(cpus))
                                 goto redo;
                 }
         }
@@ -3696,9 +3685,12 @@ out_balanced:
 static void idle_balance(int this_cpu, struct rq *this_rq)
 {
         struct sched_domain *sd;
-        int pulled_task = -1;
+        int pulled_task = 0;
         unsigned long next_balance = jiffies + HZ;
-        cpumask_t tmpmask;
+        cpumask_var_t tmpmask;
+
+        if (!alloc_cpumask_var(&tmpmask, GFP_ATOMIC))
+                return;
 
         for_each_domain(this_cpu, sd) {
                 unsigned long interval;
@@ -3709,7 +3701,7 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
                 if (sd->flags & SD_BALANCE_NEWIDLE)
                         /* If we've pulled tasks over stop searching: */
                         pulled_task = load_balance_newidle(this_cpu, this_rq,
-                                                           sd, &tmpmask);
+                                                           sd, tmpmask);
 
                 interval = msecs_to_jiffies(sd->balance_interval);
                 if (time_after(next_balance, sd->last_balance + interval))
@@ -3724,6 +3716,7 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
                  */
                 this_rq->next_balance = next_balance;
         }
+        free_cpumask_var(tmpmask);
 }
 
 /*
@@ -3761,7 +3754,7 @@ static void active_load_balance(struct rq *busiest_rq, int busiest_cpu)
         /* Search for an sd spanning us and the target CPU. */
         for_each_domain(target_cpu, sd) {
                 if ((sd->flags & SD_LOAD_BALANCE) &&
-                    cpu_isset(busiest_cpu, sd->span))
+                    cpumask_test_cpu(busiest_cpu, sched_domain_span(sd)))
                                 break;
         }
 
@@ -3780,10 +3773,9 @@ static void active_load_balance(struct rq *busiest_rq, int busiest_cpu)
 #ifdef CONFIG_NO_HZ
 static struct {
         atomic_t load_balancer;
-        cpumask_t cpu_mask;
+        cpumask_var_t cpu_mask;
 } nohz ____cacheline_aligned = {
         .load_balancer = ATOMIC_INIT(-1),
-        .cpu_mask = CPU_MASK_NONE,
 };
 
 /*
@@ -3811,7 +3803,7 @@ int select_nohz_load_balancer(int stop_tick)
         int cpu = smp_processor_id();
 
         if (stop_tick) {
-                cpu_set(cpu, nohz.cpu_mask);
+                cpumask_set_cpu(cpu, nohz.cpu_mask);
                 cpu_rq(cpu)->in_nohz_recently = 1;
 
                 /*
@@ -3825,7 +3817,7 @@ int select_nohz_load_balancer(int stop_tick)
                 }
 
                 /* time for ilb owner also to sleep */
-                if (cpus_weight(nohz.cpu_mask) == num_online_cpus()) {
+                if (cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                         if (atomic_read(&nohz.load_balancer) == cpu)
                                 atomic_set(&nohz.load_balancer, -1);
                         return 0;
@@ -3838,10 +3830,10 @@ int select_nohz_load_balancer(int stop_tick)
                 } else if (atomic_read(&nohz.load_balancer) == cpu)
                         return 1;
         } else {
-                if (!cpu_isset(cpu, nohz.cpu_mask))
+                if (!cpumask_test_cpu(cpu, nohz.cpu_mask))
                         return 0;
 
-                cpu_clear(cpu, nohz.cpu_mask);
+                cpumask_clear_cpu(cpu, nohz.cpu_mask);
 
                 if (atomic_read(&nohz.load_balancer) == cpu)
                         if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
@@ -3869,7 +3861,11 @@ static void rebalance_domains(int cpu, enum cpu_idle_type idle)
         unsigned long next_balance = jiffies + 60*HZ;
         int update_next_balance = 0;
         int need_serialize;
-        cpumask_t tmp;
+        cpumask_var_t tmp;
+
+        /* Fails alloc?  Rebalancing probably not a priority right now. */
+        if (!alloc_cpumask_var(&tmp, GFP_ATOMIC))
+                return;
 
         for_each_domain(cpu, sd) {
                 if (!(sd->flags & SD_LOAD_BALANCE))
@@ -3894,7 +3890,7 @@ static void rebalance_domains(int cpu, enum cpu_idle_type idle)
                 }
 
                 if (time_after_eq(jiffies, sd->last_balance + interval)) {
-                        if (load_balance(cpu, rq, sd, idle, &balance, &tmp)) {
+                        if (load_balance(cpu, rq, sd, idle, &balance, tmp)) {
                                 /*
                                  * We've pulled tasks over so either we're no
                                  * longer idle, or one of our SMT siblings is
@@ -3928,6 +3924,8 @@ out:
          */
         if (likely(update_next_balance))
                 rq->next_balance = next_balance;
+
+        free_cpumask_var(tmp);
 }
 
 /*
@@ -3952,12 +3950,13 @@ static void run_rebalance_domains(struct softirq_action *h)
          */
         if (this_rq->idle_at_tick &&
             atomic_read(&nohz.load_balancer) == this_cpu) {
-                cpumask_t cpus = nohz.cpu_mask;
                 struct rq *rq;
                 int balance_cpu;
 
-                cpu_clear(this_cpu, cpus);
-                for_each_cpu_mask_nr(balance_cpu, cpus) {
+                for_each_cpu(balance_cpu, nohz.cpu_mask) {
+                        if (balance_cpu == this_cpu)
+                                continue;
+
                         /*
                          * If this cpu gets work to do, stop the load balancing
                          * work being done for other cpus. Next load
@@ -3995,7 +3994,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
                 rq->in_nohz_recently = 0;
 
                 if (atomic_read(&nohz.load_balancer) == cpu) {
-                        cpu_clear(cpu, nohz.cpu_mask);
+                        cpumask_clear_cpu(cpu, nohz.cpu_mask);
                         atomic_set(&nohz.load_balancer, -1);
                 }
 
@@ -4008,7 +4007,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
                          * TBD: Traverse the sched domains and nominate
                          * the nearest cpu in the nohz.cpu_mask.
                          */
-                        int ilb = first_cpu(nohz.cpu_mask);
+                        int ilb = cpumask_first(nohz.cpu_mask);
 
                         if (ilb < nr_cpu_ids)
                                 resched_cpu(ilb);
@@ -4020,7 +4019,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
          * cpus with ticks stopped, is it time for that to stop?
          */
         if (rq->idle_at_tick && atomic_read(&nohz.load_balancer) == cpu &&
-            cpus_weight(nohz.cpu_mask) == num_online_cpus()) {
+            cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                 resched_cpu(cpu);
                 return;
         }
@@ -4030,7 +4029,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
          * someone else, then no need raise the SCHED_SOFTIRQ
          */
         if (rq->idle_at_tick && atomic_read(&nohz.load_balancer) != cpu &&
-            cpu_isset(cpu, nohz.cpu_mask))
+            cpumask_test_cpu(cpu, nohz.cpu_mask))
                 return;
 #endif
         if (time_after_eq(jiffies, rq->next_balance))
@@ -4192,7 +4191,6 @@ void account_steal_time(struct task_struct *p, cputime_t steal)
 
         if (p == rq->idle) {
                 p->stime = cputime_add(p->stime, steal);
-                account_group_system_time(p, steal);
                 if (atomic_read(&rq->nr_iowait) > 0)
                         cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
                 else
@@ -4328,7 +4326,7 @@ void __kprobes sub_preempt_count(int val)
         /*
          * Underflow?
          */
-        if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
+       if (DEBUG_LOCKS_WARN_ON(val > preempt_count() - (!!kernel_locked())))
                 return;
         /*
          * Is the spinlock portion underflowing?
@@ -5389,10 +5387,9 @@ out_unlock:
         return retval;
 }
 
-long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
+long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
 {
-        cpumask_t cpus_allowed;
-        cpumask_t new_mask = *in_mask;
+        cpumask_var_t cpus_allowed, new_mask;
         struct task_struct *p;
         int retval;
 
@@ -5414,6 +5411,14 @@ long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
         get_task_struct(p);
         read_unlock(&tasklist_lock);
 
+        if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
+                retval = -ENOMEM;
+                goto out_put_task;
+        }
+        if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) {
+                retval = -ENOMEM;
+                goto out_free_cpus_allowed;
+        }
         retval = -EPERM;
         if ((current->euid != p->euid) && (current->euid != p->uid) &&
                         !capable(CAP_SYS_NICE))
@@ -5423,37 +5428,41 @@ long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
         if (retval)
                 goto out_unlock;
 
-        cpuset_cpus_allowed(p, &cpus_allowed);
-        cpus_and(new_mask, new_mask, cpus_allowed);
+        cpuset_cpus_allowed(p, cpus_allowed);
+        cpumask_and(new_mask, in_mask, cpus_allowed);
  again:
-        retval = set_cpus_allowed_ptr(p, &new_mask);
+        retval = set_cpus_allowed_ptr(p, new_mask);
 
         if (!retval) {
-                cpuset_cpus_allowed(p, &cpus_allowed);
-                if (!cpus_subset(new_mask, cpus_allowed)) {
+                cpuset_cpus_allowed(p, cpus_allowed);
+                if (!cpumask_subset(new_mask, cpus_allowed)) {
                         /*
                          * We must have raced with a concurrent cpuset
                          * update. Just reset the cpus_allowed to the
                          * cpuset's cpus_allowed
                          */
-                        new_mask = cpus_allowed;
+                        cpumask_copy(new_mask, cpus_allowed);
                         goto again;
                 }
         }
 out_unlock:
+        free_cpumask_var(new_mask);
+out_free_cpus_allowed:
+        free_cpumask_var(cpus_allowed);
+out_put_task:
         put_task_struct(p);
         put_online_cpus();
         return retval;
 }
 
 static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
-                             cpumask_t *new_mask)
+                             struct cpumask *new_mask)
 {
-        if (len < sizeof(cpumask_t)) {
-                memset(new_mask, 0, sizeof(cpumask_t));
-        } else if (len > sizeof(cpumask_t)) {
-                len = sizeof(cpumask_t);
-        }
+        if (len < cpumask_size())
+                cpumask_clear(new_mask);
+        else if (len > cpumask_size())
+                len = cpumask_size();
+
         return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
 }
 
@@ -5466,17 +5475,20 @@ static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
 asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
                                       unsigned long __user *user_mask_ptr)
 {
-        cpumask_t new_mask;
+        cpumask_var_t new_mask;
         int retval;
 
-        retval = get_user_cpu_mask(user_mask_ptr, len, &new_mask);
-        if (retval)
-                return retval;
+        if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
+                return -ENOMEM;
 
-        return sched_setaffinity(pid, &new_mask);
+        retval = get_user_cpu_mask(user_mask_ptr, len, new_mask);
+        if (retval == 0)
+                retval = sched_setaffinity(pid, new_mask);
+        free_cpumask_var(new_mask);
+        return retval;
 }
 
-long sched_getaffinity(pid_t pid, cpumask_t *mask)
+long sched_getaffinity(pid_t pid, struct cpumask *mask)
 {
         struct task_struct *p;
         int retval;
@@ -5493,7 +5505,7 @@ long sched_getaffinity(pid_t pid, cpumask_t *mask)
         if (retval)
                 goto out_unlock;
 
-        cpus_and(*mask, p->cpus_allowed, cpu_online_map);
+        cpumask_and(mask, &p->cpus_allowed, cpu_online_mask);
 
 out_unlock:
         read_unlock(&tasklist_lock);
@@ -5512,19 +5524,24 @@ asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
                                       unsigned long __user *user_mask_ptr)
 {
         int ret;
-        cpumask_t mask;
+        cpumask_var_t mask;
 
-        if (len < sizeof(cpumask_t))
+        if (len < cpumask_size())
                 return -EINVAL;
 
-        ret = sched_getaffinity(pid, &mask);
-        if (ret < 0)
-                return ret;
+        if (!alloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
 
-        if (copy_to_user(user_mask_ptr, &mask, sizeof(cpumask_t)))
-                return -EFAULT;
+        ret = sched_getaffinity(pid, mask);
+        if (ret == 0) {
+                if (copy_to_user(user_mask_ptr, mask, cpumask_size()))
+                        ret = -EFAULT;
+                else
+                        ret = cpumask_size();
+        }
+        free_cpumask_var(mask);
 
-        return sizeof(cpumask_t);
+        return ret;
 }
 
 /**
@@ -5860,14 +5877,15 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
         struct rq *rq = cpu_rq(cpu);
         unsigned long flags;
 
+        spin_lock_irqsave(&rq->lock, flags);
+
         __sched_fork(idle);
         idle->se.exec_start = sched_clock();
 
         idle->prio = idle->normal_prio = MAX_PRIO;
-        idle->cpus_allowed = cpumask_of_cpu(cpu);
+        cpumask_copy(&idle->cpus_allowed, cpumask_of(cpu));
         __set_task_cpu(idle, cpu);
 
-        spin_lock_irqsave(&rq->lock, flags);
         rq->curr = rq->idle = idle;
 #if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
         idle->oncpu = 1;
@@ -5884,6 +5902,7 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
          * The idle tasks have their own, simple scheduling class:
          */
         idle->sched_class = &idle_sched_class;
+        ftrace_graph_init_task(idle);
 }
 
 /*
@@ -5891,9 +5910,9 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
  * indicates which cpus entered this state. This is used
  * in the rcu update to wait only for active cpus. For system
  * which do not switch off the HZ timer nohz_cpu_mask should
- * always be CPU_MASK_NONE.
+ * always be CPU_BITS_NONE.
  */
-cpumask_t nohz_cpu_mask = CPU_MASK_NONE;
+cpumask_var_t nohz_cpu_mask;
 
 /*
  * Increase the granularity value when there are more CPUs,
@@ -5948,7 +5967,7 @@ static inline void sched_init_granularity(void)
  * task must not exit() & deallocate itself prematurely. The
  * call is not atomic; no spinlocks may be held.
  */
-int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
+int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
 {
         struct migration_req req;
         unsigned long flags;
@@ -5956,13 +5975,13 @@ int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
         int ret = 0;
 
         rq = task_rq_lock(p, &flags);
-        if (!cpus_intersects(*new_mask, cpu_online_map)) {
+        if (!cpumask_intersects(new_mask, cpu_online_mask)) {
                 ret = -EINVAL;
                 goto out;
         }
 
         if (unlikely((p->flags & PF_THREAD_BOUND) && p != current &&
-                     !cpus_equal(p->cpus_allowed, *new_mask))) {
+                     !cpumask_equal(&p->cpus_allowed, new_mask))) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -5970,15 +5989,15 @@ int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
         if (p->sched_class->set_cpus_allowed)
                 p->sched_class->set_cpus_allowed(p, new_mask);
         else {
-                p->cpus_allowed = *new_mask;
-                p->rt.nr_cpus_allowed = cpus_weight(*new_mask);
+                cpumask_copy(&p->cpus_allowed, new_mask);
+                p->rt.nr_cpus_allowed = cpumask_weight(new_mask);
         }
 
         /* Can the task run on the task's current CPU? If so, we're done */
-        if (cpu_isset(task_cpu(p), *new_mask))
+        if (cpumask_test_cpu(task_cpu(p), new_mask))
                 goto out;
 
-        if (migrate_task(p, any_online_cpu(*new_mask), &req)) {
+        if (migrate_task(p, cpumask_any_and(cpu_online_mask, new_mask), &req)) {
                 /* Need help from migration thread: drop lock and wait. */
                 task_rq_unlock(rq, &flags);
                 wake_up_process(rq->migration_thread);
@@ -6020,7 +6039,7 @@ static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
         if (task_cpu(p) != src_cpu)
                 goto done;
         /* Affinity changed (again). */
-        if (!cpu_isset(dest_cpu, p->cpus_allowed))
+        if (!cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
                 goto fail;
 
         on_rq = p->se.on_rq;
@@ -6114,54 +6133,46 @@ static int __migrate_task_irq(struct task_struct *p, int src_cpu, int dest_cpu)
 
 /*
  * Figure out where task on dead CPU should go, use force if necessary.
- * NOTE: interrupts should be disabled by the caller
  */
 static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
 {
-        unsigned long flags;
-        cpumask_t mask;
-        struct rq *rq;
         int dest_cpu;
+        /* FIXME: Use cpumask_of_node here. */
+        cpumask_t _nodemask = node_to_cpumask(cpu_to_node(dead_cpu));
+        const struct cpumask *nodemask = &_nodemask;
+
+again:
+        /* Look for allowed, online CPU in same node. */
+        for_each_cpu_and(dest_cpu, nodemask, cpu_online_mask)
+                if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
+                        goto move;
+
+        /* Any allowed, online CPU? */
+        dest_cpu = cpumask_any_and(&p->cpus_allowed, cpu_online_mask);
+        if (dest_cpu < nr_cpu_ids)
+                goto move;
+
+        /* No more Mr. Nice Guy. */
+        if (dest_cpu >= nr_cpu_ids) {
+                cpuset_cpus_allowed_locked(p, &p->cpus_allowed);
+                dest_cpu = cpumask_any_and(cpu_online_mask, &p->cpus_allowed);
 
-        do {
-                /* On same node? */
-                mask = node_to_cpumask(cpu_to_node(dead_cpu));
-                cpus_and(mask, mask, p->cpus_allowed);
-                dest_cpu = any_online_cpu(mask);
-
-                /* On any allowed CPU? */
-                if (dest_cpu >= nr_cpu_ids)
-                        dest_cpu = any_online_cpu(p->cpus_allowed);
-
-                /* No more Mr. Nice Guy. */
-                if (dest_cpu >= nr_cpu_ids) {
-                        cpumask_t cpus_allowed;
-
-                        cpuset_cpus_allowed_locked(p, &cpus_allowed);
-                        /*
-                         * Try to stay on the same cpuset, where the
-                         * current cpuset may be a subset of all cpus.
-                         * The cpuset_cpus_allowed_locked() variant of
-                         * cpuset_cpus_allowed() will not block. It must be
-                         * called within calls to cpuset_lock/cpuset_unlock.
-                         */
-                        rq = task_rq_lock(p, &flags);
-                        p->cpus_allowed = cpus_allowed;
-                        dest_cpu = any_online_cpu(p->cpus_allowed);
-                        task_rq_unlock(rq, &flags);
-
-                        /*
-                         * Don't tell them about moving exiting tasks or
-                         * kernel threads (both mm NULL), since they never
-                         * leave kernel.
-                         */
-                        if (p->mm && printk_ratelimit()) {
-                                printk(KERN_INFO "process %d (%s) no "
-                                       "longer affine to cpu%d\n",
-                                        task_pid_nr(p), p->comm, dead_cpu);
-                        }
+                /*
+                 * Don't tell them about moving exiting tasks or
+                 * kernel threads (both mm NULL), since they never
+                 * leave kernel.
+                 */
+                if (p->mm && printk_ratelimit()) {
+                        printk(KERN_INFO "process %d (%s) no "
+                               "longer affine to cpu%d\n",
+                               task_pid_nr(p), p->comm, dead_cpu);
                 }
-        } while (!__migrate_task_irq(p, dead_cpu, dest_cpu));
+        }
+
+move:
+        /* It can have affinity changed while we were choosing. */
+        if (unlikely(!__migrate_task_irq(p, dead_cpu, dest_cpu)))
+                goto again;
 }
 
 /*
@@ -6173,7 +6184,7 @@ static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
  */
 static void migrate_nr_uninterruptible(struct rq *rq_src)
 {
-        struct rq *rq_dest = cpu_rq(any_online_cpu(*CPU_MASK_ALL_PTR));
+        struct rq *rq_dest = cpu_rq(cpumask_any(cpu_online_mask));
         unsigned long flags;
 
         local_irq_save(flags);
@@ -6463,7 +6474,7 @@ static void set_rq_online(struct rq *rq)
         if (!rq->online) {
                 const struct sched_class *class;
 
-                cpu_set(rq->cpu, rq->rd->online);
+                cpumask_set_cpu(rq->cpu, rq->rd->online);
                 rq->online = 1;
 
                 for_each_class(class) {
@@ -6483,7 +6494,7 @@ static void set_rq_offline(struct rq *rq)
                                 class->rq_offline(rq);
                 }
 
-                cpu_clear(rq->cpu, rq->rd->online);
+                cpumask_clear_cpu(rq->cpu, rq->rd->online);
                 rq->online = 0;
         }
 }
@@ -6524,7 +6535,7 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 rq = cpu_rq(cpu);
                 spin_lock_irqsave(&rq->lock, flags);
                 if (rq->rd) {
-                        BUG_ON(!cpu_isset(cpu, rq->rd->span));
+                        BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
 
                         set_rq_online(rq);
                 }
@@ -6538,7 +6549,7 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                         break;
                 /* Unbind it from offline cpu so it can run. Fall thru. */
                 kthread_bind(cpu_rq(cpu)->migration_thread,
-                             any_online_cpu(cpu_online_map));
+                             cpumask_any(cpu_online_mask));
                 kthread_stop(cpu_rq(cpu)->migration_thread);
                 cpu_rq(cpu)->migration_thread = NULL;
                 break;
@@ -6575,7 +6586,9 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                         req = list_entry(rq->migration_queue.next,
                                          struct migration_req, list);
                         list_del_init(&req->list);
+                        spin_unlock_irq(&rq->lock);
                         complete(&req->done);
+                        spin_lock_irq(&rq->lock);
                 }
                 spin_unlock_irq(&rq->lock);
                 break;
@@ -6586,7 +6599,7 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 rq = cpu_rq(cpu);
                 spin_lock_irqsave(&rq->lock, flags);
                 if (rq->rd) {
-                        BUG_ON(!cpu_isset(cpu, rq->rd->span));
+                        BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
                         set_rq_offline(rq);
                 }
                 spin_unlock_irqrestore(&rq->lock, flags);
@@ -6624,36 +6637,14 @@ early_initcall(migration_init);
 
 #ifdef CONFIG_SCHED_DEBUG
 
-static inline const char *sd_level_to_string(enum sched_domain_level lvl)
-{
-        switch (lvl) {
-        case SD_LV_NONE:
-                        return "NONE";
-        case SD_LV_SIBLING:
-                        return "SIBLING";
-        case SD_LV_MC:
-                        return "MC";
-        case SD_LV_CPU:
-                        return "CPU";
-        case SD_LV_NODE:
-                        return "NODE";
-        case SD_LV_ALLNODES:
-                        return "ALLNODES";
-        case SD_LV_MAX:
-                        return "MAX";
-
-        }
-        return "MAX";
-}
-
 static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
-                                  cpumask_t *groupmask)
+                                  struct cpumask *groupmask)
 {
         struct sched_group *group = sd->groups;
         char str[256];
 
-        cpulist_scnprintf(str, sizeof(str), sd->span);
-        cpus_clear(*groupmask);
+        cpulist_scnprintf(str, sizeof(str), *sched_domain_span(sd));
+        cpumask_clear(groupmask);
 
         printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
 
@@ -6665,14 +6656,13 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                 return -1;
         }
 
-        printk(KERN_CONT "span %s level %s\n",
-                str, sd_level_to_string(sd->level));
+        printk(KERN_CONT "span %s level %s\n", str, sd->name);
 
-        if (!cpu_isset(cpu, sd->span)) {
+        if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                 printk(KERN_ERR "ERROR: domain->span does not contain "
                                 "CPU%d\n", cpu);
         }
-        if (!cpu_isset(cpu, group->cpumask)) {
+        if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
                 printk(KERN_ERR "ERROR: domain->groups does not contain"
                                 " CPU%d\n", cpu);
         }
@@ -6692,31 +6682,32 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                         break;
                 }
 
-                if (!cpus_weight(group->cpumask)) {
+                if (!cpumask_weight(sched_group_cpus(group))) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: empty group\n");
                         break;
                 }
 
-                if (cpus_intersects(*groupmask, group->cpumask)) {
+                if (cpumask_intersects(groupmask, sched_group_cpus(group))) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: repeated CPUs\n");
                         break;
                 }
 
-                cpus_or(*groupmask, *groupmask, group->cpumask);
+                cpumask_or(groupmask, groupmask, sched_group_cpus(group));
 
-                cpulist_scnprintf(str, sizeof(str), group->cpumask);
+                cpulist_scnprintf(str, sizeof(str), *sched_group_cpus(group));
                 printk(KERN_CONT " %s", str);
 
                 group = group->next;
         } while (group != sd->groups);
         printk(KERN_CONT "\n");
 
-        if (!cpus_equal(sd->span, *groupmask))
+        if (!cpumask_equal(sched_domain_span(sd), groupmask))
                 printk(KERN_ERR "ERROR: groups don't span domain->span\n");
 
-        if (sd->parent && !cpus_subset(*groupmask, sd->parent->span))
+        if (sd->parent &&
+            !cpumask_subset(groupmask, sched_domain_span(sd->parent)))
                 printk(KERN_ERR "ERROR: parent span is not a superset "
                         "of domain->span\n");
         return 0;
@@ -6724,7 +6715,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
 
 static void sched_domain_debug(struct sched_domain *sd, int cpu)
 {
-        cpumask_t *groupmask;
+        cpumask_var_t groupmask;
         int level = 0;
 
         if (!sd) {
@@ -6734,8 +6725,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
 
         printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
 
-        groupmask = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
-        if (!groupmask) {
+        if (!alloc_cpumask_var(&groupmask, GFP_KERNEL)) {
                 printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
                 return;
         }
@@ -6748,7 +6738,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
                 if (!sd)
                         break;
         }
-        kfree(groupmask);
+        free_cpumask_var(groupmask);
 }
 #else /* !CONFIG_SCHED_DEBUG */
 # define sched_domain_debug(sd, cpu) do { } while (0)
@@ -6756,7 +6746,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
 
 static int sd_degenerate(struct sched_domain *sd)
 {
-        if (cpus_weight(sd->span) == 1)
+        if (cpumask_weight(sched_domain_span(sd)) == 1)
                 return 1;
 
         /* Following flags need at least 2 groups */
@@ -6787,7 +6777,7 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
         if (sd_degenerate(parent))
                 return 1;
 
-        if (!cpus_equal(sd->span, parent->span))
+        if (!cpumask_equal(sched_domain_span(sd), sched_domain_span(parent)))
                 return 0;
 
         /* Does parent contain flags not in child? */
@@ -6802,6 +6792,8 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
                                 SD_BALANCE_EXEC |
                                 SD_SHARE_CPUPOWER |
                                 SD_SHARE_PKG_RESOURCES);
+                if (nr_node_ids == 1)
+                        pflags &= ~SD_SERIALIZE;
         }
         if (~cflags & pflags)
                 return 0;
@@ -6809,6 +6801,16 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
         return 1;
 }
 
+static void free_rootdomain(struct root_domain *rd)
+{
+        cpupri_cleanup(&rd->cpupri);
+
+        free_cpumask_var(rd->rto_mask);
+        free_cpumask_var(rd->online);
+        free_cpumask_var(rd->span);
+        kfree(rd);
+}
+
 static void rq_attach_root(struct rq *rq, struct root_domain *rd)
 {
         unsigned long flags;
@@ -6818,38 +6820,63 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
         if (rq->rd) {
                 struct root_domain *old_rd = rq->rd;
 
-                if (cpu_isset(rq->cpu, old_rd->online))
+                if (cpumask_test_cpu(rq->cpu, old_rd->online))
                         set_rq_offline(rq);
 
-                cpu_clear(rq->cpu, old_rd->span);
+                cpumask_clear_cpu(rq->cpu, old_rd->span);
 
                 if (atomic_dec_and_test(&old_rd->refcount))
-                        kfree(old_rd);
+                        free_rootdomain(old_rd);
         }
 
         atomic_inc(&rd->refcount);
         rq->rd = rd;
 
-        cpu_set(rq->cpu, rd->span);
-        if (cpu_isset(rq->cpu, cpu_online_map))
+        cpumask_set_cpu(rq->cpu, rd->span);
+        if (cpumask_test_cpu(rq->cpu, cpu_online_mask))
                 set_rq_online(rq);
 
         spin_unlock_irqrestore(&rq->lock, flags);
 }
 
-static void init_rootdomain(struct root_domain *rd)
+static int init_rootdomain(struct root_domain *rd, bool bootmem)
 {
         memset(rd, 0, sizeof(*rd));
 
-        cpus_clear(rd->span);
-        cpus_clear(rd->online);
+        if (bootmem) {
+                alloc_bootmem_cpumask_var(&def_root_domain.span);
+                alloc_bootmem_cpumask_var(&def_root_domain.online);
+                alloc_bootmem_cpumask_var(&def_root_domain.rto_mask);
+                cpupri_init(&rd->cpupri, true);
+                return 0;
+        }
+
+        if (!alloc_cpumask_var(&rd->span, GFP_KERNEL))
+                goto free_rd;
+        if (!alloc_cpumask_var(&rd->online, GFP_KERNEL))
+                goto free_span;
+        if (!alloc_cpumask_var(&rd->rto_mask, GFP_KERNEL))
+                goto free_online;
+
+        if (cpupri_init(&rd->cpupri, false) != 0)
+                goto free_rto_mask;
+        return 0;
 
-        cpupri_init(&rd->cpupri);
+free_rto_mask:
+        free_cpumask_var(rd->rto_mask);
+free_online:
+        free_cpumask_var(rd->online);
+free_span:
+        free_cpumask_var(rd->span);
+free_rd:
+        kfree(rd);
+        return -ENOMEM;
 }
 
 static void init_defrootdomain(void)
 {
-        init_rootdomain(&def_root_domain);
+        init_rootdomain(&def_root_domain, true);
+
         atomic_set(&def_root_domain.refcount, 1);
 }
 
@@ -6861,7 +6888,10 @@ static struct root_domain *alloc_rootdomain(void)
         if (!rd)
                 return NULL;
 
-        init_rootdomain(rd);
+        if (init_rootdomain(rd, false) != 0) {
+                kfree(rd);
+                return NULL;
+        }
 
         return rd;
 }
@@ -6903,19 +6933,12 @@ cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
 }
 
 /* cpus with isolated domains */
-static cpumask_t cpu_isolated_map = CPU_MASK_NONE;
+static cpumask_var_t cpu_isolated_map;
 
 /* Setup the mask of cpus configured for isolated domains */
 static int __init isolated_cpu_setup(char *str)
 {
-        static int __initdata ints[NR_CPUS];
-        int i;
-
-        str = get_options(str, ARRAY_SIZE(ints), ints);
-        cpus_clear(cpu_isolated_map);
-        for (i = 1; i <= ints[0]; i++)
-                if (ints[i] < NR_CPUS)
-                        cpu_set(ints[i], cpu_isolated_map);
+        cpulist_parse(str, *cpu_isolated_map);
         return 1;
 }
 
@@ -6924,42 +6947,43 @@ __setup("isolcpus=", isolated_cpu_setup);
 /*
  * init_sched_build_groups takes the cpumask we wish to span, and a pointer
  * to a function which identifies what group(along with sched group) a CPU
- * belongs to. The return value of group_fn must be a >= 0 and < NR_CPUS
- * (due to the fact that we keep track of groups covered with a cpumask_t).
+ * belongs to. The return value of group_fn must be a >= 0 and < nr_cpu_ids
+ * (due to the fact that we keep track of groups covered with a struct cpumask).
  *
  * init_sched_build_groups will build a circular linked list of the groups
  * covered by the given span, and will set each group's ->cpumask correctly,
  * and ->cpu_power to 0.
  */
 static void
-init_sched_build_groups(const cpumask_t *span, const cpumask_t *cpu_map,
-                        int (*group_fn)(int cpu, const cpumask_t *cpu_map,
+init_sched_build_groups(const struct cpumask *span,
+                        const struct cpumask *cpu_map,
+                        int (*group_fn)(int cpu, const struct cpumask *cpu_map,
                                         struct sched_group **sg,
-                                        cpumask_t *tmpmask),
-                        cpumask_t *covered, cpumask_t *tmpmask)
+                                        struct cpumask *tmpmask),
+                        struct cpumask *covered, struct cpumask *tmpmask)
 {
         struct sched_group *first = NULL, *last = NULL;
         int i;
 
-        cpus_clear(*covered);
+        cpumask_clear(covered);
 
-        for_each_cpu_mask_nr(i, *span) {
+        for_each_cpu(i, span) {
                 struct sched_group *sg;
                 int group = group_fn(i, cpu_map, &sg, tmpmask);
                 int j;
 
-                if (cpu_isset(i, *covered))
+                if (cpumask_test_cpu(i, covered))
                         continue;
 
-                cpus_clear(sg->cpumask);
+                cpumask_clear(sched_group_cpus(sg));
                 sg->__cpu_power = 0;
 
-                for_each_cpu_mask_nr(j, *span) {
+                for_each_cpu(j, span) {
                         if (group_fn(j, cpu_map, NULL, tmpmask) != group)
                                 continue;
 
-                        cpu_set(j, *covered);
-                        cpu_set(j, sg->cpumask);
+                        cpumask_set_cpu(j, covered);
+                        cpumask_set_cpu(j, sched_group_cpus(sg));
                 }
                 if (!first)
                         first = sg;
@@ -7023,9 +7047,10 @@ static int find_next_best_node(int node, nodemask_t *used_nodes)
  * should be one that prevents unnecessary balancing, but also spreads tasks
  * out optimally.
  */
-static void sched_domain_node_span(int node, cpumask_t *span)
+static void sched_domain_node_span(int node, struct cpumask *span)
 {
         nodemask_t used_nodes;
+        /* FIXME: use cpumask_of_node() */
         node_to_cpumask_ptr(nodemask, node);
         int i;
 
@@ -7047,18 +7072,33 @@ static void sched_domain_node_span(int node, cpumask_t *span)
 int sched_smt_power_savings = 0, sched_mc_power_savings = 0;
 
 /*
+ * The cpus mask in sched_group and sched_domain hangs off the end.
+ * FIXME: use cpumask_var_t or dynamic percpu alloc to avoid wasting space
+ * for nr_cpu_ids < CONFIG_NR_CPUS.
+ */
+struct static_sched_group {
+        struct sched_group sg;
+        DECLARE_BITMAP(cpus, CONFIG_NR_CPUS);
+};
+
+struct static_sched_domain {
+        struct sched_domain sd;
+        DECLARE_BITMAP(span, CONFIG_NR_CPUS);
+};
+
+/*
  * SMT sched-domains:
  */
 #ifdef CONFIG_SCHED_SMT
-static DEFINE_PER_CPU(struct sched_domain, cpu_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_cpus);
+static DEFINE_PER_CPU(struct static_sched_domain, cpu_domains);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_cpus);
 
 static int
-cpu_to_cpu_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                 cpumask_t *unused)
+cpu_to_cpu_group(int cpu, const struct cpumask *cpu_map,
+                 struct sched_group **sg, struct cpumask *unused)
 {
         if (sg)
-                *sg = &per_cpu(sched_group_cpus, cpu);
+                *sg = &per_cpu(sched_group_cpus, cpu).sg;
         return cpu;
 }
 #endif /* CONFIG_SCHED_SMT */
@@ -7067,56 +7107,55 @@ cpu_to_cpu_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
  * multi-core sched-domains:
  */
 #ifdef CONFIG_SCHED_MC
-static DEFINE_PER_CPU(struct sched_domain, core_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_core);
+static DEFINE_PER_CPU(struct static_sched_domain, core_domains);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_core);
 #endif /* CONFIG_SCHED_MC */
 
 #if defined(CONFIG_SCHED_MC) && defined(CONFIG_SCHED_SMT)
 static int
-cpu_to_core_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                  cpumask_t *mask)
+cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
+                  struct sched_group **sg, struct cpumask *mask)
 {
         int group;
 
-        *mask = per_cpu(cpu_sibling_map, cpu);
-        cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        cpumask_and(mask, &per_cpu(cpu_sibling_map, cpu), cpu_map);
+        group = cpumask_first(mask);
         if (sg)
-                *sg = &per_cpu(sched_group_core, group);
+                *sg = &per_cpu(sched_group_core, group).sg;
         return group;
 }
 #elif defined(CONFIG_SCHED_MC)
 static int
-cpu_to_core_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                  cpumask_t *unused)
+cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
+                  struct sched_group **sg, struct cpumask *unused)
 {
         if (sg)
-                *sg = &per_cpu(sched_group_core, cpu);
+                *sg = &per_cpu(sched_group_core, cpu).sg;
         return cpu;
 }
 #endif
 
-static DEFINE_PER_CPU(struct sched_domain, phys_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_phys);
+static DEFINE_PER_CPU(struct static_sched_domain, phys_domains);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_phys);
 
 static int
-cpu_to_phys_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                  cpumask_t *mask)
+cpu_to_phys_group(int cpu, const struct cpumask *cpu_map,
+                  struct sched_group **sg, struct cpumask *mask)
 {
         int group;
 #ifdef CONFIG_SCHED_MC
+        /* FIXME: Use cpu_coregroup_mask. */
         *mask = cpu_coregroup_map(cpu);
         cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        group = cpumask_first(mask);
 #elif defined(CONFIG_SCHED_SMT)
-        *mask = per_cpu(cpu_sibling_map, cpu);
-        cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        cpumask_and(mask, &per_cpu(cpu_sibling_map, cpu), cpu_map);
+        group = cpumask_first(mask);
 #else
         group = cpu;
 #endif
         if (sg)
-                *sg = &per_cpu(sched_group_phys, group);
+                *sg = &per_cpu(sched_group_phys, group).sg;
         return group;
 }
 
@@ -7130,19 +7169,21 @@ static DEFINE_PER_CPU(struct sched_domain, node_domains);
 static struct sched_group ***sched_group_nodes_bycpu;
 
 static DEFINE_PER_CPU(struct sched_domain, allnodes_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_allnodes);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_allnodes);
 
-static int cpu_to_allnodes_group(int cpu, const cpumask_t *cpu_map,
-                                 struct sched_group **sg, cpumask_t *nodemask)
+static int cpu_to_allnodes_group(int cpu, const struct cpumask *cpu_map,
+                                 struct sched_group **sg,
+                                 struct cpumask *nodemask)
 {
         int group;
+        /* FIXME: use cpumask_of_node */
+        node_to_cpumask_ptr(pnodemask, cpu_to_node(cpu));
 
-        *nodemask = node_to_cpumask(cpu_to_node(cpu));
-        cpus_and(*nodemask, *nodemask, *cpu_map);
-        group = first_cpu(*nodemask);
+        cpumask_and(nodemask, pnodemask, cpu_map);
+        group = cpumask_first(nodemask);
 
         if (sg)
-                *sg = &per_cpu(sched_group_allnodes, group);
+                *sg = &per_cpu(sched_group_allnodes, group).sg;
         return group;
 }
 
@@ -7154,11 +7195,11 @@ static void init_numa_sched_groups_power(struct sched_group *group_head)
         if (!sg)
                 return;
         do {
-                for_each_cpu_mask_nr(j, sg->cpumask) {
+                for_each_cpu(j, sched_group_cpus(sg)) {
                         struct sched_domain *sd;
 
-                        sd = &per_cpu(phys_domains, j);
-                        if (j != first_cpu(sd->groups->cpumask)) {
+                        sd = &per_cpu(phys_domains, j).sd;
+                        if (j != cpumask_first(sched_group_cpus(sd->groups))) {
                                 /*
                                  * Only add "power" once for each
                                  * physical package.
@@ -7175,11 +7216,12 @@ static void init_numa_sched_groups_power(struct sched_group *group_head)
 
 #ifdef CONFIG_NUMA
 /* Free memory allocated for various sched_group structures */
-static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
+static void free_sched_groups(const struct cpumask *cpu_map,
+                              struct cpumask *nodemask)
 {
         int cpu, i;
 
-        for_each_cpu_mask_nr(cpu, *cpu_map) {
+        for_each_cpu(cpu, cpu_map) {
                 struct sched_group **sched_group_nodes
                         = sched_group_nodes_bycpu[cpu];
 
@@ -7188,10 +7230,11 @@ static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
 
                 for (i = 0; i < nr_node_ids; i++) {
                         struct sched_group *oldsg, *sg = sched_group_nodes[i];
+                        /* FIXME: Use cpumask_of_node */
+                        node_to_cpumask_ptr(pnodemask, i);
 
-                        *nodemask = node_to_cpumask(i);
-                        cpus_and(*nodemask, *nodemask, *cpu_map);
-                        if (cpus_empty(*nodemask))
+                        cpus_and(*nodemask, *pnodemask, *cpu_map);
+                        if (cpumask_empty(nodemask))
                                 continue;
 
                         if (sg == NULL)
@@ -7209,7 +7252,8 @@ next_sg:
         }
 }
 #else /* !CONFIG_NUMA */
-static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
+static void free_sched_groups(const struct cpumask *cpu_map,
+                              struct cpumask *nodemask)
 {
 }
 #endif /* CONFIG_NUMA */
@@ -7235,7 +7279,7 @@ static void init_sched_groups_power(int cpu, struct sched_domain *sd)
 
         WARN_ON(!sd || !sd->groups);
 
-        if (cpu != first_cpu(sd->groups->cpumask))
+        if (cpu != cpumask_first(sched_group_cpus(sd->groups)))
                 return;
 
         child = sd->child;
@@ -7300,40 +7344,6 @@ SD_INIT_FUNC(CPU)
  SD_INIT_FUNC(MC)
 #endif
 
-/*
- * To minimize stack usage kmalloc room for cpumasks and share the
- * space as the usage in build_sched_domains() dictates.  Used only
- * if the amount of space is significant.
- */
-struct allmasks {
-        cpumask_t tmpmask;                      /* make this one first */
-        union {
-                cpumask_t nodemask;
-                cpumask_t this_sibling_map;
-                cpumask_t this_core_map;
-        };
-        cpumask_t send_covered;
-
-#ifdef CONFIG_NUMA
-        cpumask_t domainspan;
-        cpumask_t covered;
-        cpumask_t notcovered;
-#endif
-};
-
-#if     NR_CPUS > 128
-#define SCHED_CPUMASK_ALLOC             1
-#define SCHED_CPUMASK_FREE(v)           kfree(v)
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks *v
-#else
-#define SCHED_CPUMASK_ALLOC             0
-#define SCHED_CPUMASK_FREE(v)
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks _v, *v = &_v
-#endif
-
-#define SCHED_CPUMASK_VAR(v, a)         cpumask_t *v = (cpumask_t *) \
-                        ((unsigned long)(a) + offsetof(struct allmasks, v))
-
 static int default_relax_domain_level = -1;
 
 static int __init setup_relax_domain_level(char *str)
@@ -7373,17 +7383,38 @@ static void set_domain_attribute(struct sched_domain *sd,
  * Build sched domains for a given set of cpus and attach the sched domains
  * to the individual cpus
  */
-static int __build_sched_domains(const cpumask_t *cpu_map,
+static int __build_sched_domains(const struct cpumask *cpu_map,
                                  struct sched_domain_attr *attr)
 {
-        int i;
+        int i, err = -ENOMEM;
         struct root_domain *rd;
-        SCHED_CPUMASK_DECLARE(allmasks);
-        cpumask_t *tmpmask;
+        cpumask_var_t nodemask, this_sibling_map, this_core_map, send_covered,
+                tmpmask;
 #ifdef CONFIG_NUMA
+        cpumask_var_t domainspan, covered, notcovered;
         struct sched_group **sched_group_nodes = NULL;
         int sd_allnodes = 0;
 
+        if (!alloc_cpumask_var(&domainspan, GFP_KERNEL))
+                goto out;
+        if (!alloc_cpumask_var(&covered, GFP_KERNEL))
+                goto free_domainspan;
+        if (!alloc_cpumask_var(&notcovered, GFP_KERNEL))
+                goto free_covered;
+#endif
+
+        if (!alloc_cpumask_var(&nodemask, GFP_KERNEL))
+                goto free_notcovered;
+        if (!alloc_cpumask_var(&this_sibling_map, GFP_KERNEL))
+                goto free_nodemask;
+        if (!alloc_cpumask_var(&this_core_map, GFP_KERNEL))
+                goto free_this_sibling_map;
+        if (!alloc_cpumask_var(&send_covered, GFP_KERNEL))
+                goto free_this_core_map;
+        if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
+                goto free_send_covered;
+
+#ifdef CONFIG_NUMA
         /*
          * Allocate the per-node list of sched groups
          */
@@ -7391,55 +7422,37 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                                     GFP_KERNEL);
         if (!sched_group_nodes) {
                 printk(KERN_WARNING "Can not alloc sched group node list\n");
-                return -ENOMEM;
+                goto free_tmpmask;
         }
 #endif
 
         rd = alloc_rootdomain();
         if (!rd) {
                 printk(KERN_WARNING "Cannot alloc root domain\n");
-#ifdef CONFIG_NUMA
-                kfree(sched_group_nodes);
-#endif
-                return -ENOMEM;
+                goto free_sched_groups;
         }
 
-#if SCHED_CPUMASK_ALLOC
-        /* get space for all scratch cpumask variables */
-        allmasks = kmalloc(sizeof(*allmasks), GFP_KERNEL);
-        if (!allmasks) {
-                printk(KERN_WARNING "Cannot alloc cpumask array\n");
-                kfree(rd);
-#ifdef CONFIG_NUMA
-                kfree(sched_group_nodes);
-#endif
-                return -ENOMEM;
-        }
-#endif
-        tmpmask = (cpumask_t *)allmasks;
-
-
 #ifdef CONFIG_NUMA
-        sched_group_nodes_bycpu[first_cpu(*cpu_map)] = sched_group_nodes;
+        sched_group_nodes_bycpu[cpumask_first(cpu_map)] = sched_group_nodes;
 #endif
 
         /*
          * Set up domains for cpus specified by the cpu_map.
          */
-        for_each_cpu_mask_nr(i, *cpu_map) {
+        for_each_cpu(i, cpu_map) {
                 struct sched_domain *sd = NULL, *p;
-                SCHED_CPUMASK_VAR(nodemask, allmasks);
 
+                /* FIXME: use cpumask_of_node */
                 *nodemask = node_to_cpumask(cpu_to_node(i));
                 cpus_and(*nodemask, *nodemask, *cpu_map);
 
 #ifdef CONFIG_NUMA
-                if (cpus_weight(*cpu_map) >
-                                SD_NODES_PER_DOMAIN*cpus_weight(*nodemask)) {
+                if (cpumask_weight(cpu_map) >
+                                SD_NODES_PER_DOMAIN*cpumask_weight(nodemask)) {
                         sd = &per_cpu(allnodes_domains, i);
                         SD_INIT(sd, ALLNODES);
                         set_domain_attribute(sd, attr);
-                        sd->span = *cpu_map;
+                        cpumask_copy(sched_domain_span(sd), cpu_map);
                         cpu_to_allnodes_group(i, cpu_map, &sd->groups, tmpmask);
                         p = sd;
                         sd_allnodes = 1;
@@ -7449,18 +7462,19 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                 sd = &per_cpu(node_domains, i);
                 SD_INIT(sd, NODE);
                 set_domain_attribute(sd, attr);
-                sched_domain_node_span(cpu_to_node(i), &sd->span);
+                sched_domain_node_span(cpu_to_node(i), sched_domain_span(sd));
                 sd->parent = p;
                 if (p)
                         p->child = sd;
-                cpus_and(sd->span, sd->span, *cpu_map);
+                cpumask_and(sched_domain_span(sd),
+                            sched_domain_span(sd), cpu_map);
 #endif
 
                 p = sd;
-                sd = &per_cpu(phys_domains, i);
+                sd = &per_cpu(phys_domains, i).sd;
                 SD_INIT(sd, CPU);
                 set_domain_attribute(sd, attr);
-                sd->span = *nodemask;
+                cpumask_copy(sched_domain_span(sd), nodemask);
                 sd->parent = p;
                 if (p)
                         p->child = sd;
@@ -7468,11 +7482,12 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_MC
                 p = sd;
-                sd = &per_cpu(core_domains, i);
+                sd = &per_cpu(core_domains, i).sd;
                 SD_INIT(sd, MC);
                 set_domain_attribute(sd, attr);
-                sd->span = cpu_coregroup_map(i);
-                cpus_and(sd->span, sd->span, *cpu_map);
+                *sched_domain_span(sd) = cpu_coregroup_map(i);
+                cpumask_and(sched_domain_span(sd),
+                            sched_domain_span(sd), cpu_map);
                 sd->parent = p;
                 p->child = sd;
                 cpu_to_core_group(i, cpu_map, &sd->groups, tmpmask);
@@ -7480,11 +7495,11 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_SMT
                 p = sd;
-                sd = &per_cpu(cpu_domains, i);
+                sd = &per_cpu(cpu_domains, i).sd;
                 SD_INIT(sd, SIBLING);
                 set_domain_attribute(sd, attr);
-                sd->span = per_cpu(cpu_sibling_map, i);
-                cpus_and(sd->span, sd->span, *cpu_map);
+                cpumask_and(sched_domain_span(sd),
+                            &per_cpu(cpu_sibling_map, i), cpu_map);
                 sd->parent = p;
                 p->child = sd;
                 cpu_to_cpu_group(i, cpu_map, &sd->groups, tmpmask);
@@ -7493,13 +7508,10 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_SMT
         /* Set up CPU (sibling) groups */
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                SCHED_CPUMASK_VAR(this_sibling_map, allmasks);
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
-                *this_sibling_map = per_cpu(cpu_sibling_map, i);
-                cpus_and(*this_sibling_map, *this_sibling_map, *cpu_map);
-                if (i != first_cpu(*this_sibling_map))
+        for_each_cpu(i, cpu_map) {
+                cpumask_and(this_sibling_map,
+                            &per_cpu(cpu_sibling_map, i), cpu_map);
+                if (i != cpumask_first(this_sibling_map))
                         continue;
 
                 init_sched_build_groups(this_sibling_map, cpu_map,
@@ -7510,13 +7522,11 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_MC
         /* Set up multi-core groups */
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                SCHED_CPUMASK_VAR(this_core_map, allmasks);
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
+        for_each_cpu(i, cpu_map) {
+                /* FIXME: Use cpu_coregroup_mask */
                 *this_core_map = cpu_coregroup_map(i);
                 cpus_and(*this_core_map, *this_core_map, *cpu_map);
-                if (i != first_cpu(*this_core_map))
+                if (i != cpumask_first(this_core_map))
                         continue;
 
                 init_sched_build_groups(this_core_map, cpu_map,
@@ -7527,12 +7537,10 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
         /* Set up physical groups */
         for (i = 0; i < nr_node_ids; i++) {
-                SCHED_CPUMASK_VAR(nodemask, allmasks);
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
+                /* FIXME: Use cpumask_of_node */
                 *nodemask = node_to_cpumask(i);
                 cpus_and(*nodemask, *nodemask, *cpu_map);
-                if (cpus_empty(*nodemask))
+                if (cpumask_empty(nodemask))
                         continue;
 
                 init_sched_build_groups(nodemask, cpu_map,
@@ -7543,8 +7551,6 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 #ifdef CONFIG_NUMA
         /* Set up node groups */
         if (sd_allnodes) {
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
                 init_sched_build_groups(cpu_map, cpu_map,
                                         &cpu_to_allnodes_group,
                                         send_covered, tmpmask);
@@ -7553,58 +7559,58 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
         for (i = 0; i < nr_node_ids; i++) {
                 /* Set up node groups */
                 struct sched_group *sg, *prev;
-                SCHED_CPUMASK_VAR(nodemask, allmasks);
-                SCHED_CPUMASK_VAR(domainspan, allmasks);
-                SCHED_CPUMASK_VAR(covered, allmasks);
                 int j;
 
+                /* FIXME: Use cpumask_of_node */
                 *nodemask = node_to_cpumask(i);
-                cpus_clear(*covered);
+                cpumask_clear(covered);
 
                 cpus_and(*nodemask, *nodemask, *cpu_map);
-                if (cpus_empty(*nodemask)) {
+                if (cpumask_empty(nodemask)) {
                         sched_group_nodes[i] = NULL;
                         continue;
                 }
 
                 sched_domain_node_span(i, domainspan);
-                cpus_and(*domainspan, *domainspan, *cpu_map);
+                cpumask_and(domainspan, domainspan, cpu_map);
 
-                sg = kmalloc_node(sizeof(struct sched_group), GFP_KERNEL, i);
+                sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
+                                  GFP_KERNEL, i);
                 if (!sg) {
                         printk(KERN_WARNING "Can not alloc domain group for "
                                 "node %d\n", i);
                         goto error;
                 }
                 sched_group_nodes[i] = sg;
-                for_each_cpu_mask_nr(j, *nodemask) {
+                for_each_cpu(j, nodemask) {
                         struct sched_domain *sd;
 
                         sd = &per_cpu(node_domains, j);
                         sd->groups = sg;
                 }
                 sg->__cpu_power = 0;
-                sg->cpumask = *nodemask;
+                cpumask_copy(sched_group_cpus(sg), nodemask);
                 sg->next = sg;
-                cpus_or(*covered, *covered, *nodemask);
+                cpumask_or(covered, covered, nodemask);
                 prev = sg;
 
                 for (j = 0; j < nr_node_ids; j++) {
-                        SCHED_CPUMASK_VAR(notcovered, allmasks);
                         int n = (i + j) % nr_node_ids;
+                        /* FIXME: Use cpumask_of_node */
                         node_to_cpumask_ptr(pnodemask, n);
 
-                        cpus_complement(*notcovered, *covered);
-                        cpus_and(*tmpmask, *notcovered, *cpu_map);
-                        cpus_and(*tmpmask, *tmpmask, *domainspan);
-                        if (cpus_empty(*tmpmask))
+                        cpumask_complement(notcovered, covered);
+                        cpumask_and(tmpmask, notcovered, cpu_map);
+                        cpumask_and(tmpmask, tmpmask, domainspan);
+                        if (cpumask_empty(tmpmask))
                                 break;
 
-                        cpus_and(*tmpmask, *tmpmask, *pnodemask);
-                        if (cpus_empty(*tmpmask))
+                        cpumask_and(tmpmask, tmpmask, pnodemask);
+                        if (cpumask_empty(tmpmask))
                                 continue;
 
-                        sg = kmalloc_node(sizeof(struct sched_group),
+                        sg = kmalloc_node(sizeof(struct sched_group) +
+                                          cpumask_size(),
                                           GFP_KERNEL, i);
                         if (!sg) {
                                 printk(KERN_WARNING
@@ -7612,9 +7618,9 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                                 goto error;
                         }
                         sg->__cpu_power = 0;
-                        sg->cpumask = *tmpmask;
+                        cpumask_copy(sched_group_cpus(sg), tmpmask);
                         sg->next = prev->next;
-                        cpus_or(*covered, *covered, *tmpmask);
+                        cpumask_or(covered, covered, tmpmask);
                         prev->next = sg;
                         prev = sg;
                 }
@@ -7623,22 +7629,22 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
         /* Calculate CPU power for physical packages and nodes */
 #ifdef CONFIG_SCHED_SMT
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                struct sched_domain *sd = &per_cpu(cpu_domains, i);
+        for_each_cpu(i, cpu_map) {
+                struct sched_domain *sd = &per_cpu(cpu_domains, i).sd;
 
                 init_sched_groups_power(i, sd);
         }
 #endif
 #ifdef CONFIG_SCHED_MC
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                struct sched_domain *sd = &per_cpu(core_domains, i);
+        for_each_cpu(i, cpu_map) {
+                struct sched_domain *sd = &per_cpu(core_domains, i).sd;
 
                 init_sched_groups_power(i, sd);
         }
 #endif
 
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                struct sched_domain *sd = &per_cpu(phys_domains, i);
+        for_each_cpu(i, cpu_map) {
+                struct sched_domain *sd = &per_cpu(phys_domains, i).sd;
 
                 init_sched_groups_power(i, sd);
         }
@@ -7650,56 +7656,87 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
         if (sd_allnodes) {
                 struct sched_group *sg;
 
-                cpu_to_allnodes_group(first_cpu(*cpu_map), cpu_map, &sg,
+                cpu_to_allnodes_group(cpumask_first(cpu_map), cpu_map, &sg,
                                                                 tmpmask);
                 init_numa_sched_groups_power(sg);
         }
 #endif
 
         /* Attach the domains */
-        for_each_cpu_mask_nr(i, *cpu_map) {
+        for_each_cpu(i, cpu_map) {
                 struct sched_domain *sd;
 #ifdef CONFIG_SCHED_SMT
-                sd = &per_cpu(cpu_domains, i);
+                sd = &per_cpu(cpu_domains, i).sd;
 #elif defined(CONFIG_SCHED_MC)
-                sd = &per_cpu(core_domains, i);
+                sd = &per_cpu(core_domains, i).sd;
 #else
-                sd = &per_cpu(phys_domains, i);
+                sd = &per_cpu(phys_domains, i).sd;
 #endif
                 cpu_attach_domain(sd, rd, i);
         }
 
-        SCHED_CPUMASK_FREE((void *)allmasks);
-        return 0;
+        err = 0;
+
+free_tmpmask:
+        free_cpumask_var(tmpmask);
+free_send_covered:
+        free_cpumask_var(send_covered);
+free_this_core_map:
+        free_cpumask_var(this_core_map);
+free_this_sibling_map:
+        free_cpumask_var(this_sibling_map);
+free_nodemask:
+        free_cpumask_var(nodemask);
+free_notcovered:
+#ifdef CONFIG_NUMA
+        free_cpumask_var(notcovered);
+free_covered:
+        free_cpumask_var(covered);
+free_domainspan:
+        free_cpumask_var(domainspan);
+out:
+#endif
+        return err;
+
+free_sched_groups:
+#ifdef CONFIG_NUMA
+        kfree(sched_group_nodes);
+#endif
+        goto free_tmpmask;
 
 #ifdef CONFIG_NUMA
 error:
         free_sched_groups(cpu_map, tmpmask);
-        SCHED_CPUMASK_FREE((void *)allmasks);
-        kfree(rd);
-        return -ENOMEM;
+        free_rootdomain(rd);
+        goto free_tmpmask;
 #endif
 }
 
-static int build_sched_domains(const cpumask_t *cpu_map)
+static int build_sched_domains(const struct cpumask *cpu_map)
 {
         return __build_sched_domains(cpu_map, NULL);
 }
 
-static cpumask_t *doms_cur;     /* current sched domains */
+static struct cpumask *doms_cur;        /* current sched domains */
 static int ndoms_cur;           /* number of sched domains in 'doms_cur' */
 static struct sched_domain_attr *dattr_cur;
                                 /* attribues of custom domains in 'doms_cur' */
 
 /*
  * Special case: If a kmalloc of a doms_cur partition (array of
- * cpumask_t) fails, then fallback to a single sched domain,
- * as determined by the single cpumask_t fallback_doms.
+ * cpumask) fails, then fallback to a single sched domain,
+ * as determined by the single cpumask fallback_doms.
  */
-static cpumask_t fallback_doms;
+static cpumask_var_t fallback_doms;
 
-void __attribute__((weak)) arch_update_cpu_topology(void)
+/*
+ * arch_update_cpu_topology lets virtualized architectures update the
+ * cpu core maps. It is supposed to return 1 if the topology changed
+ * or 0 if it stayed the same.
+ */
+int __attribute__((weak)) arch_update_cpu_topology(void)
 {
+        return 0;
 }
 
 /*
@@ -7707,16 +7744,16 @@ void __attribute__((weak)) arch_update_cpu_topology(void)
  * For now this just excludes isolated cpus, but could be used to
  * exclude other special cases in the future.
  */
-static int arch_init_sched_domains(const cpumask_t *cpu_map)
+static int arch_init_sched_domains(const struct cpumask *cpu_map)
 {
         int err;
 
         arch_update_cpu_topology();
         ndoms_cur = 1;
-        doms_cur = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
+        doms_cur = kmalloc(cpumask_size(), GFP_KERNEL);
         if (!doms_cur)
-                doms_cur = &fallback_doms;
-        cpus_andnot(*doms_cur, *cpu_map, cpu_isolated_map);
+                doms_cur = fallback_doms;
+        cpumask_andnot(doms_cur, cpu_map, cpu_isolated_map);
         dattr_cur = NULL;
         err = build_sched_domains(doms_cur);
         register_sched_domain_sysctl();
@@ -7724,8 +7761,8 @@ static int arch_init_sched_domains(const cpumask_t *cpu_map)
         return err;
 }
 
-static void arch_destroy_sched_domains(const cpumask_t *cpu_map,
-                                       cpumask_t *tmpmask)
+static void arch_destroy_sched_domains(const struct cpumask *cpu_map,
+                                       struct cpumask *tmpmask)
 {
         free_sched_groups(cpu_map, tmpmask);
 }
@@ -7734,17 +7771,16 @@ static void arch_destroy_sched_domains(const cpumask_t *cpu_map,
  * Detach sched domains from a group of cpus specified in cpu_map
  * These cpus will now be attached to the NULL domain
  */
-static void detach_destroy_domains(const cpumask_t *cpu_map)
+static void detach_destroy_domains(const struct cpumask *cpu_map)
 {
-        cpumask_t tmpmask;
+        /* Save because hotplug lock held. */
+        static DECLARE_BITMAP(tmpmask, CONFIG_NR_CPUS);
         int i;
 
-        unregister_sched_domain_sysctl();
-
-        for_each_cpu_mask_nr(i, *cpu_map)
+        for_each_cpu(i, cpu_map)
                 cpu_attach_domain(NULL, &def_root_domain, i);
         synchronize_sched();
-        arch_destroy_sched_domains(cpu_map, &tmpmask);
+        arch_destroy_sched_domains(cpu_map, to_cpumask(tmpmask));
 }
 
 /* handle null as "default" */
@@ -7769,7 +7805,7 @@ static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  * doms_new[] to the current sched domain partitioning, doms_cur[].
  * It destroys each deleted domain and builds each new domain.
  *
- * 'doms_new' is an array of cpumask_t's of length 'ndoms_new'.
+ * 'doms_new' is an array of cpumask's of length 'ndoms_new'.
  * The masks don't intersect (don't overlap.) We should setup one
  * sched domain for each mask. CPUs not in any of the cpumasks will
  * not be load balanced. If the same cpumask appears both in the
@@ -7778,32 +7814,38 @@ static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  *
  * The passed in 'doms_new' should be kmalloc'd. This routine takes
  * ownership of it and will kfree it when done with it. If the caller
- * failed the kmalloc call, then it can pass in doms_new == NULL,
- * and partition_sched_domains() will fallback to the single partition
- * 'fallback_doms', it also forces the domains to be rebuilt.
+ * failed the kmalloc call, then it can pass in doms_new == NULL &&
+ * ndoms_new == 1, and partition_sched_domains() will fallback to
+ * the single partition 'fallback_doms', it also forces the domains
+ * to be rebuilt.
  *
- * If doms_new==NULL it will be replaced with cpu_online_map.
- * ndoms_new==0 is a special case for destroying existing domains.
- * It will not create the default domain.
+ * If doms_new == NULL it will be replaced with cpu_online_mask.
+ * ndoms_new == 0 is a special case for destroying existing domains,
+ * and it will not create the default domain.
  *
  * Call with hotplug lock held
  */
-void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
+/* FIXME: Change to struct cpumask *doms_new[] */
+void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
                              struct sched_domain_attr *dattr_new)
 {
         int i, j, n;
+        int new_topology;
 
         mutex_lock(&sched_domains_mutex);
 
         /* always unregister in case we don't destroy any domains */
         unregister_sched_domain_sysctl();
 
+        /* Let architecture update cpu core mappings. */
+        new_topology = arch_update_cpu_topology();
+
         n = doms_new ? ndoms_new : 0;
 
         /* Destroy deleted domains */
         for (i = 0; i < ndoms_cur; i++) {
-                for (j = 0; j < n; j++) {
-                        if (cpus_equal(doms_cur[i], doms_new[j])
+                for (j = 0; j < n && !new_topology; j++) {
+                        if (cpumask_equal(&doms_cur[i], &doms_new[j])
                             && dattrs_equal(dattr_cur, i, dattr_new, j))
                                 goto match1;
                 }
@@ -7815,15 +7857,15 @@ match1:
 
         if (doms_new == NULL) {
                 ndoms_cur = 0;
-                doms_new = &fallback_doms;
-                cpus_andnot(doms_new[0], cpu_online_map, cpu_isolated_map);
-                dattr_new = NULL;
+                doms_new = fallback_doms;
+                cpumask_andnot(&doms_new[0], cpu_online_mask, cpu_isolated_map);
+                WARN_ON_ONCE(dattr_new);
         }
 
         /* Build new domains */
         for (i = 0; i < ndoms_new; i++) {
-                for (j = 0; j < ndoms_cur; j++) {
-                        if (cpus_equal(doms_new[i], doms_cur[j])
+                for (j = 0; j < ndoms_cur && !new_topology; j++) {
+                        if (cpumask_equal(&doms_new[i], &doms_cur[j])
                             && dattrs_equal(dattr_new, i, dattr_cur, j))
                                 goto match2;
                 }
@@ -7835,7 +7877,7 @@ match2:
         }
 
         /* Remember the new sched domains */
-        if (doms_cur != &fallback_doms)
+        if (doms_cur != fallback_doms)
                 kfree(doms_cur);
         kfree(dattr_cur);       /* kfree(NULL) is safe */
         doms_cur = doms_new;
@@ -7975,7 +8017,9 @@ static int update_runtime(struct notifier_block *nfb,
 
 void __init sched_init_smp(void)
 {
-        cpumask_t non_isolated_cpus;
+        cpumask_var_t non_isolated_cpus;
+
+        alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
 
 #if defined(CONFIG_NUMA)
         sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
@@ -7984,10 +8028,10 @@ void __init sched_init_smp(void)
 #endif
         get_online_cpus();
         mutex_lock(&sched_domains_mutex);
-        arch_init_sched_domains(&cpu_online_map);
-        cpus_andnot(non_isolated_cpus, cpu_possible_map, cpu_isolated_map);
-        if (cpus_empty(non_isolated_cpus))
-                cpu_set(smp_processor_id(), non_isolated_cpus);
+        arch_init_sched_domains(cpu_online_mask);
+        cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
+        if (cpumask_empty(non_isolated_cpus))
+                cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
         mutex_unlock(&sched_domains_mutex);
         put_online_cpus();
 
@@ -8002,9 +8046,13 @@ void __init sched_init_smp(void)
         init_hrtick();
 
         /* Move init over to a non-isolated CPU */
-        if (set_cpus_allowed_ptr(current, &non_isolated_cpus) < 0)
+        if (set_cpus_allowed_ptr(current, non_isolated_cpus) < 0)
                 BUG();
         sched_init_granularity();
+        free_cpumask_var(non_isolated_cpus);
+
+        alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
+        init_sched_rt_class();
 }
 #else
 void __init sched_init_smp(void)
@@ -8319,6 +8367,15 @@ void __init sched_init(void)
          */
         current->sched_class = &fair_sched_class;
 
+        /* Allocate the nohz_cpu_mask if CONFIG_CPUMASK_OFFSTACK */
+        alloc_bootmem_cpumask_var(&nohz_cpu_mask);
+#ifdef CONFIG_SMP
+#ifdef CONFIG_NO_HZ
+        alloc_bootmem_cpumask_var(&nohz.cpu_mask);
+#endif
+        alloc_bootmem_cpumask_var(&cpu_isolated_map);
+#endif /* SMP */
+
         scheduler_running = 1;
 }
 
@@ -8477,7 +8534,7 @@ static
 int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 {
         struct cfs_rq *cfs_rq;
-        struct sched_entity *se, *parent_se;
+        struct sched_entity *se;
         struct rq *rq;
         int i;
 
@@ -8493,18 +8550,17 @@ int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
         for_each_possible_cpu(i) {
                 rq = cpu_rq(i);
 
-                cfs_rq = kmalloc_node(sizeof(struct cfs_rq),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
+                                      GFP_KERNEL, cpu_to_node(i));
                 if (!cfs_rq)
                         goto err;
 
-                se = kmalloc_node(sizeof(struct sched_entity),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                se = kzalloc_node(sizeof(struct sched_entity),
+                                  GFP_KERNEL, cpu_to_node(i));
                 if (!se)
                         goto err;
 
-                parent_se = parent ? parent->se[i] : NULL;
-                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent_se);
+                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent->se[i]);
         }
 
         return 1;
@@ -8565,7 +8621,7 @@ static
 int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
 {
         struct rt_rq *rt_rq;
-        struct sched_rt_entity *rt_se, *parent_se;
+        struct sched_rt_entity *rt_se;
         struct rq *rq;
         int i;
 
@@ -8582,18 +8638,17 @@ int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
         for_each_possible_cpu(i) {
                 rq = cpu_rq(i);
 
-                rt_rq = kmalloc_node(sizeof(struct rt_rq),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                rt_rq = kzalloc_node(sizeof(struct rt_rq),
+                                     GFP_KERNEL, cpu_to_node(i));
                 if (!rt_rq)
                         goto err;
 
-                rt_se = kmalloc_node(sizeof(struct sched_rt_entity),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
+                                     GFP_KERNEL, cpu_to_node(i));
                 if (!rt_se)
                         goto err;
 
-                parent_se = parent ? parent->rt_se[i] : NULL;
-                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent_se);
+                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent->rt_se[i]);
         }
 
         return 1;
@@ -9236,11 +9291,12 @@ struct cgroup_subsys cpu_cgroup_subsys = {
  * (balbir@in.ibm.com).
  */
 
-/* track cpu usage of a group of tasks */
+/* track cpu usage of a group of tasks and its child groups */
 struct cpuacct {
         struct cgroup_subsys_state css;
         /* cpuusage holds pointer to a u64-type object on every cpu */
         u64 *cpuusage;
+        struct cpuacct *parent;
 };
 
 struct cgroup_subsys cpuacct_subsys;
@@ -9274,6 +9330,9 @@ static struct cgroup_subsys_state *cpuacct_create(
                 return ERR_PTR(-ENOMEM);
         }
 
+        if (cgrp->parent)
+                ca->parent = cgroup_ca(cgrp->parent);
+
         return &ca->css;
 }
 
@@ -9353,14 +9412,16 @@ static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
 static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
 {
         struct cpuacct *ca;
+        int cpu;
 
         if (!cpuacct_subsys.active)
                 return;
 
+        cpu = task_cpu(tsk);
         ca = task_ca(tsk);
-        if (ca) {
-                u64 *cpuusage = percpu_ptr(ca->cpuusage, task_cpu(tsk));
 
+        for (; ca; ca = ca->parent) {
+                u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
                 *cpuusage += cputime;
         }
 }
diff --git a/kernel/sched_cpupri.c b/kernel/sched_cpupri.c
index 52154fefab7e..018b7be1db2e 100644
--- a/kernel/sched_cpupri.c
+++ b/kernel/sched_cpupri.c
@@ -67,24 +67,21 @@ static int convert_prio(int prio)
  * Returns: (int)bool - CPUs were found
  */
 int cpupri_find(struct cpupri *cp, struct task_struct *p,
-                cpumask_t *lowest_mask)
+                struct cpumask *lowest_mask)
 {
         int                  idx      = 0;
         int                  task_pri = convert_prio(p->prio);
 
         for_each_cpupri_active(cp->pri_active, idx) {
                 struct cpupri_vec *vec  = &cp->pri_to_cpu[idx];
-                cpumask_t mask;
 
                 if (idx >= task_pri)
                         break;
 
-                cpus_and(mask, p->cpus_allowed, vec->mask);
-
-                if (cpus_empty(mask))
+                if (cpumask_any_and(&p->cpus_allowed, vec->mask) >= nr_cpu_ids)
                         continue;
 
-                *lowest_mask = mask;
+                cpumask_and(lowest_mask, &p->cpus_allowed, vec->mask);
                 return 1;
         }
 
@@ -126,7 +123,7 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
                 vec->count--;
                 if (!vec->count)
                         clear_bit(oldpri, cp->pri_active);
-                cpu_clear(cpu, vec->mask);
+                cpumask_clear_cpu(cpu, vec->mask);
 
                 spin_unlock_irqrestore(&vec->lock, flags);
         }
@@ -136,7 +133,7 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
 
                 spin_lock_irqsave(&vec->lock, flags);
 
-                cpu_set(cpu, vec->mask);
+                cpumask_set_cpu(cpu, vec->mask);
                 vec->count++;
                 if (vec->count == 1)
                         set_bit(newpri, cp->pri_active);
@@ -150,10 +147,11 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
 /**
  * cpupri_init - initialize the cpupri structure
  * @cp: The cpupri context
+ * @bootmem: true if allocations need to use bootmem
  *
- * Returns: (void)
+ * Returns: -ENOMEM if memory fails.
  */
-void cpupri_init(struct cpupri *cp)
+int cpupri_init(struct cpupri *cp, bool bootmem)
 {
         int i;
 
@@ -164,11 +162,30 @@ void cpupri_init(struct cpupri *cp)
 
                 spin_lock_init(&vec->lock);
                 vec->count = 0;
-                cpus_clear(vec->mask);
+                if (bootmem)
+                        alloc_bootmem_cpumask_var(&vec->mask);
+                else if (!alloc_cpumask_var(&vec->mask, GFP_KERNEL))
+                        goto cleanup;
         }
 
         for_each_possible_cpu(i)
                 cp->cpu_to_pri[i] = CPUPRI_INVALID;
+        return 0;
+
+cleanup:
+        for (i--; i >= 0; i--)
+                free_cpumask_var(cp->pri_to_cpu[i].mask);
+        return -ENOMEM;
 }
 
+/**
+ * cpupri_cleanup - clean up the cpupri structure
+ * @cp: The cpupri context
+ */
+void cpupri_cleanup(struct cpupri *cp)
+{
+        int i;
 
+        for (i = 0; i < CPUPRI_NR_PRIORITIES; i++)
+                free_cpumask_var(cp->pri_to_cpu[i].mask);
+}
diff --git a/kernel/sched_cpupri.h b/kernel/sched_cpupri.h
index f25811b0f931..642a94ef8a0a 100644
--- a/kernel/sched_cpupri.h
+++ b/kernel/sched_cpupri.h
@@ -14,7 +14,7 @@
 struct cpupri_vec {
         spinlock_t lock;
         int        count;
-        cpumask_t  mask;
+        cpumask_var_t mask;
 };
 
 struct cpupri {
@@ -27,7 +27,8 @@ struct cpupri {
 int  cpupri_find(struct cpupri *cp,
                  struct task_struct *p, cpumask_t *lowest_mask);
 void cpupri_set(struct cpupri *cp, int cpu, int pri);
-void cpupri_init(struct cpupri *cp);
+int cpupri_init(struct cpupri *cp, bool bootmem);
+void cpupri_cleanup(struct cpupri *cp);
 #else
 #define cpupri_set(cp, cpu, pri) do { } while (0)
 #define cpupri_init() do { } while (0)
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 5ae17762ec32..4293cfa9681d 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -53,6 +53,40 @@ static unsigned long nsec_low(unsigned long long nsec)
 
 #define SPLIT_NS(x) nsec_high(x), nsec_low(x)
 
+#ifdef CONFIG_FAIR_GROUP_SCHED
+static void print_cfs_group_stats(struct seq_file *m, int cpu,
+                struct task_group *tg)
+{
+        struct sched_entity *se = tg->se[cpu];
+        if (!se)
+                return;
+
+#define P(F) \
+        SEQ_printf(m, "  .%-30s: %lld\n", #F, (long long)F)
+#define PN(F) \
+        SEQ_printf(m, "  .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
+
+        PN(se->exec_start);
+        PN(se->vruntime);
+        PN(se->sum_exec_runtime);
+#ifdef CONFIG_SCHEDSTATS
+        PN(se->wait_start);
+        PN(se->sleep_start);
+        PN(se->block_start);
+        PN(se->sleep_max);
+        PN(se->block_max);
+        PN(se->exec_max);
+        PN(se->slice_max);
+        PN(se->wait_max);
+        PN(se->wait_sum);
+        P(se->wait_count);
+#endif
+        P(se->load.weight);
+#undef PN
+#undef P
+}
+#endif
+
 static void
 print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
 {
@@ -121,20 +155,19 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
         char path[128] = "";
-        struct cgroup *cgroup = NULL;
         struct task_group *tg = cfs_rq->tg;
 
-        if (tg)
-                cgroup = tg->css.cgroup;
-
-        if (cgroup)
-                cgroup_path(cgroup, path, sizeof(path));
+        cgroup_path(tg->css.cgroup, path, sizeof(path));
 
         SEQ_printf(m, "\ncfs_rq[%d]:%s\n", cpu, path);
+#elif defined(CONFIG_USER_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
+        {
+                uid_t uid = cfs_rq->tg->uid;
+                SEQ_printf(m, "\ncfs_rq[%d] for UID: %u\n", cpu, uid);
+        }
 #else
         SEQ_printf(m, "\ncfs_rq[%d]:\n", cpu);
 #endif
-
         SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", "exec_clock",
                         SPLIT_NS(cfs_rq->exec_clock));
 
@@ -144,7 +177,7 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
         last = __pick_last_entity(cfs_rq);
         if (last)
                 max_vruntime = last->vruntime;
-        min_vruntime = rq->cfs.min_vruntime;
+        min_vruntime = cfs_rq->min_vruntime;
         rq0_min_vruntime = per_cpu(runqueues, 0).cfs.min_vruntime;
         spin_unlock_irqrestore(&rq->lock, flags);
         SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", "MIN_vruntime",
@@ -161,31 +194,14 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
                         SPLIT_NS(spread0));
         SEQ_printf(m, "  .%-30s: %ld\n", "nr_running", cfs_rq->nr_running);
         SEQ_printf(m, "  .%-30s: %ld\n", "load", cfs_rq->load.weight);
-#ifdef CONFIG_SCHEDSTATS
-#define P(n) SEQ_printf(m, "  .%-30s: %d\n", #n, rq->n);
-
-        P(yld_exp_empty);
-        P(yld_act_empty);
-        P(yld_both_empty);
-        P(yld_count);
-
-        P(sched_switch);
-        P(sched_count);
-        P(sched_goidle);
 
-        P(ttwu_count);
-        P(ttwu_local);
-
-        P(bkl_count);
-
-#undef P
-#endif
-        SEQ_printf(m, "  .%-30s: %ld\n", "nr_spread_over",
+        SEQ_printf(m, "  .%-30s: %d\n", "nr_spread_over",
                         cfs_rq->nr_spread_over);
 #ifdef CONFIG_FAIR_GROUP_SCHED
 #ifdef CONFIG_SMP
         SEQ_printf(m, "  .%-30s: %lu\n", "shares", cfs_rq->shares);
 #endif
+        print_cfs_group_stats(m, cpu, cfs_rq->tg);
 #endif
 }
 
@@ -193,14 +209,9 @@ void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
 {
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_RT_GROUP_SCHED)
         char path[128] = "";
-        struct cgroup *cgroup = NULL;
         struct task_group *tg = rt_rq->tg;
 
-        if (tg)
-                cgroup = tg->css.cgroup;
-
-        if (cgroup)
-                cgroup_path(cgroup, path, sizeof(path));
+        cgroup_path(tg->css.cgroup, path, sizeof(path));
 
         SEQ_printf(m, "\nrt_rq[%d]:%s\n", cpu, path);
 #else
@@ -260,6 +271,25 @@ static void print_cpu(struct seq_file *m, int cpu)
 #undef P
 #undef PN
 
+#ifdef CONFIG_SCHEDSTATS
+#define P(n) SEQ_printf(m, "  .%-30s: %d\n", #n, rq->n);
+
+        P(yld_exp_empty);
+        P(yld_act_empty);
+        P(yld_both_empty);
+        P(yld_count);
+
+        P(sched_switch);
+        P(sched_count);
+        P(sched_goidle);
+
+        P(ttwu_count);
+        P(ttwu_local);
+
+        P(bkl_count);
+
+#undef P
+#endif
         print_cfs_stats(m, cpu);
         print_rt_stats(m, cpu);
 
@@ -271,7 +301,7 @@ static int sched_debug_show(struct seq_file *m, void *v)
         u64 now = ktime_to_ns(ktime_get());
         int cpu;
 
-        SEQ_printf(m, "Sched Debug Version: v0.07, %s %.*s\n",
+        SEQ_printf(m, "Sched Debug Version: v0.08, %s %.*s\n",
                 init_utsname()->release,
                 (int)strcspn(init_utsname()->version, " "),
                 init_utsname()->version);
@@ -422,10 +452,11 @@ void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 #undef __P
 
         {
+                unsigned int this_cpu = raw_smp_processor_id();
                 u64 t0, t1;
 
-                t0 = sched_clock();
-                t1 = sched_clock();
+                t0 = cpu_clock(this_cpu);
+                t1 = cpu_clock(this_cpu);
                 SEQ_printf(m, "%-35s:%21Ld\n",
                            "clock-delta", (long long)(t1-t0));
         }
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 51aa3e102acb..08ffffd4a410 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -716,6 +716,15 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int wakeup)
                 __enqueue_entity(cfs_rq, se);
 }
 
+static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+{
+        if (cfs_rq->last == se)
+                cfs_rq->last = NULL;
+
+        if (cfs_rq->next == se)
+                cfs_rq->next = NULL;
+}
+
 static void
 dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
 {
@@ -738,11 +747,7 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
 #endif
         }
 
-        if (cfs_rq->last == se)
-                cfs_rq->last = NULL;
-
-        if (cfs_rq->next == se)
-                cfs_rq->next = NULL;
+        clear_buddies(cfs_rq, se);
 
         if (se != cfs_rq->curr)
                 __dequeue_entity(cfs_rq, se);
@@ -977,6 +982,8 @@ static void yield_task_fair(struct rq *rq)
         if (unlikely(cfs_rq->nr_running == 1))
                 return;
 
+        clear_buddies(cfs_rq, se);
+
         if (likely(!sysctl_sched_compat_yield) && curr->policy != SCHED_BATCH) {
                 update_rq_clock(rq);
                 /*
@@ -1010,14 +1017,13 @@ static void yield_task_fair(struct rq *rq)
  * search starts with cpus closest then further out as needed,
  * so we always favor a closer, idle cpu.
  * Domains may include CPUs that are not usable for migration,
- * hence we need to mask them out (cpu_active_map)
+ * hence we need to mask them out (cpu_active_mask)
  *
  * Returns the CPU we should wake onto.
  */
 #if defined(ARCH_HAS_SCHED_WAKE_IDLE)
 static int wake_idle(int cpu, struct task_struct *p)
 {
-        cpumask_t tmp;
         struct sched_domain *sd;
         int i;
 
@@ -1037,10 +1043,9 @@ static int wake_idle(int cpu, struct task_struct *p)
                 if ((sd->flags & SD_WAKE_IDLE)
                     || ((sd->flags & SD_WAKE_IDLE_FAR)
                         && !task_hot(p, task_rq(p)->clock, sd))) {
-                        cpus_and(tmp, sd->span, p->cpus_allowed);
-                        cpus_and(tmp, tmp, cpu_active_map);
-                        for_each_cpu_mask_nr(i, tmp) {
-                                if (idle_cpu(i)) {
+                        for_each_cpu_and(i, sched_domain_span(sd),
+                                         &p->cpus_allowed) {
+                                if (cpu_active(i) && idle_cpu(i)) {
                                         if (i != task_cpu(p)) {
                                                 schedstat_inc(p,
                                                        se.nr_wakeups_idle);
@@ -1233,13 +1238,13 @@ static int select_task_rq_fair(struct task_struct *p, int sync)
          * this_cpu and prev_cpu are present in:
          */
         for_each_domain(this_cpu, sd) {
-                if (cpu_isset(prev_cpu, sd->span)) {
+                if (cpumask_test_cpu(prev_cpu, sched_domain_span(sd))) {
                         this_sd = sd;
                         break;
                 }
         }
 
-        if (unlikely(!cpu_isset(this_cpu, p->cpus_allowed)))
+        if (unlikely(!cpumask_test_cpu(this_cpu, &p->cpus_allowed)))
                 goto out;
 
         /*
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index d9ba9d5f99d6..1bbd99014011 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -15,7 +15,7 @@ static inline void rt_set_overload(struct rq *rq)
         if (!rq->online)
                 return;
 
-        cpu_set(rq->cpu, rq->rd->rto_mask);
+        cpumask_set_cpu(rq->cpu, rq->rd->rto_mask);
         /*
          * Make sure the mask is visible before we set
          * the overload count. That is checked to determine
@@ -34,7 +34,7 @@ static inline void rt_clear_overload(struct rq *rq)
 
         /* the order here really doesn't matter */
         atomic_dec(&rq->rd->rto_count);
-        cpu_clear(rq->cpu, rq->rd->rto_mask);
+        cpumask_clear_cpu(rq->cpu, rq->rd->rto_mask);
 }
 
 static void update_rt_migration(struct rq *rq)
@@ -139,14 +139,14 @@ static int rt_se_boosted(struct sched_rt_entity *rt_se)
 }
 
 #ifdef CONFIG_SMP
-static inline cpumask_t sched_rt_period_mask(void)
+static inline const struct cpumask *sched_rt_period_mask(void)
 {
         return cpu_rq(smp_processor_id())->rd->span;
 }
 #else
-static inline cpumask_t sched_rt_period_mask(void)
+static inline const struct cpumask *sched_rt_period_mask(void)
 {
-        return cpu_online_map;
+        return cpu_online_mask;
 }
 #endif
 
@@ -212,9 +212,9 @@ static inline int rt_rq_throttled(struct rt_rq *rt_rq)
         return rt_rq->rt_throttled;
 }
 
-static inline cpumask_t sched_rt_period_mask(void)
+static inline const struct cpumask *sched_rt_period_mask(void)
 {
-        return cpu_online_map;
+        return cpu_online_mask;
 }
 
 static inline
@@ -241,11 +241,11 @@ static int do_balance_runtime(struct rt_rq *rt_rq)
         int i, weight, more = 0;
         u64 rt_period;
 
-        weight = cpus_weight(rd->span);
+        weight = cpumask_weight(rd->span);
 
         spin_lock(&rt_b->rt_runtime_lock);
         rt_period = ktime_to_ns(rt_b->rt_period);
-        for_each_cpu_mask_nr(i, rd->span) {
+        for_each_cpu(i, rd->span) {
                 struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
                 s64 diff;
 
@@ -324,7 +324,7 @@ static void __disable_runtime(struct rq *rq)
                 /*
                  * Greedy reclaim, take back as much as we can.
                  */
-                for_each_cpu_mask(i, rd->span) {
+                for_each_cpu(i, rd->span) {
                         struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
                         s64 diff;
 
@@ -429,13 +429,13 @@ static inline int balance_runtime(struct rt_rq *rt_rq)
 static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
 {
         int i, idle = 1;
-        cpumask_t span;
+        const struct cpumask *span;
 
         if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
                 return 1;
 
         span = sched_rt_period_mask();
-        for_each_cpu_mask(i, span) {
+        for_each_cpu(i, span) {
                 int enqueue = 0;
                 struct rt_rq *rt_rq = sched_rt_period_rt_rq(rt_b, i);
                 struct rq *rq = rq_of_rt_rq(rt_rq);
@@ -537,13 +537,13 @@ static void update_curr_rt(struct rq *rq)
         for_each_sched_rt_entity(rt_se) {
                 rt_rq = rt_rq_of_se(rt_se);
 
-                spin_lock(&rt_rq->rt_runtime_lock);
                 if (sched_rt_runtime(rt_rq) != RUNTIME_INF) {
+                        spin_lock(&rt_rq->rt_runtime_lock);
                         rt_rq->rt_time += delta_exec;
                         if (sched_rt_runtime_exceeded(rt_rq))
                                 resched_task(curr);
+                        spin_unlock(&rt_rq->rt_runtime_lock);
                 }
-                spin_unlock(&rt_rq->rt_runtime_lock);
         }
 }
 
@@ -805,17 +805,20 @@ static int select_task_rq_rt(struct task_struct *p, int sync)
 
 static void check_preempt_equal_prio(struct rq *rq, struct task_struct *p)
 {
-        cpumask_t mask;
+        cpumask_var_t mask;
 
         if (rq->curr->rt.nr_cpus_allowed == 1)
                 return;
 
-        if (p->rt.nr_cpus_allowed != 1
-            && cpupri_find(&rq->rd->cpupri, p, &mask))
+        if (!alloc_cpumask_var(&mask, GFP_ATOMIC))
                 return;
 
-        if (!cpupri_find(&rq->rd->cpupri, rq->curr, &mask))
-                return;
+        if (p->rt.nr_cpus_allowed != 1
+            && cpupri_find(&rq->rd->cpupri, p, mask))
+                goto free;
+
+        if (!cpupri_find(&rq->rd->cpupri, rq->curr, mask))
+                goto free;
 
         /*
          * There appears to be other cpus that can accept
@@ -824,6 +827,8 @@ static void check_preempt_equal_prio(struct rq *rq, struct task_struct *p)
          */
         requeue_task_rt(rq, p, 1);
         resched_task(rq->curr);
+free:
+        free_cpumask_var(mask);
 }
 
 #endif /* CONFIG_SMP */
@@ -909,15 +914,12 @@ static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
 /* Only try algorithms three times */
 #define RT_MAX_TRIES 3
 
-static int double_lock_balance(struct rq *this_rq, struct rq *busiest);
-static void double_unlock_balance(struct rq *this_rq, struct rq *busiest);
-
 static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep);
 
 static int pick_rt_task(struct rq *rq, struct task_struct *p, int cpu)
 {
         if (!task_running(rq, p) &&
-            (cpu < 0 || cpu_isset(cpu, p->cpus_allowed)) &&
+            (cpu < 0 || cpumask_test_cpu(cpu, &p->cpus_allowed)) &&
             (p->rt.nr_cpus_allowed > 1))
                 return 1;
         return 0;
@@ -956,7 +958,7 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
         return next;
 }
 
-static DEFINE_PER_CPU(cpumask_t, local_cpu_mask);
+static DEFINE_PER_CPU(cpumask_var_t, local_cpu_mask);
 
 static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
 {
@@ -976,7 +978,7 @@ static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
 static int find_lowest_rq(struct task_struct *task)
 {
         struct sched_domain *sd;
-        cpumask_t *lowest_mask = &__get_cpu_var(local_cpu_mask);
+        struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
         int this_cpu = smp_processor_id();
         int cpu      = task_cpu(task);
 
@@ -991,7 +993,7 @@ static int find_lowest_rq(struct task_struct *task)
          * I guess we might want to change cpupri_find() to ignore those
          * in the first place.
          */
-        cpus_and(*lowest_mask, *lowest_mask, cpu_active_map);
+        cpumask_and(lowest_mask, lowest_mask, cpu_active_mask);
 
         /*
          * At this point we have built a mask of cpus representing the
@@ -1001,7 +1003,7 @@ static int find_lowest_rq(struct task_struct *task)
          * We prioritize the last cpu that the task executed on since
          * it is most likely cache-hot in that location.
          */
-        if (cpu_isset(cpu, *lowest_mask))
+        if (cpumask_test_cpu(cpu, lowest_mask))
                 return cpu;
 
         /*
@@ -1016,7 +1018,8 @@ static int find_lowest_rq(struct task_struct *task)
                         cpumask_t domain_mask;
                         int       best_cpu;
 
-                        cpus_and(domain_mask, sd->span, *lowest_mask);
+                        cpumask_and(&domain_mask, sched_domain_span(sd),
+                                    lowest_mask);
 
                         best_cpu = pick_optimal_cpu(this_cpu,
                                                     &domain_mask);
@@ -1057,8 +1060,8 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
                          * Also make sure that it wasn't scheduled on its rq.
                          */
                         if (unlikely(task_rq(task) != rq ||
-                                     !cpu_isset(lowest_rq->cpu,
-                                                task->cpus_allowed) ||
+                                     !cpumask_test_cpu(lowest_rq->cpu,
+                                                       &task->cpus_allowed) ||
                                      task_running(rq, task) ||
                                      !task->se.on_rq)) {
 
@@ -1179,7 +1182,7 @@ static int pull_rt_task(struct rq *this_rq)
 
         next = pick_next_task_rt(this_rq);
 
-        for_each_cpu_mask_nr(cpu, this_rq->rd->rto_mask) {
+        for_each_cpu(cpu, this_rq->rd->rto_mask) {
                 if (this_cpu == cpu)
                         continue;
 
@@ -1308,9 +1311,9 @@ move_one_task_rt(struct rq *this_rq, int this_cpu, struct rq *busiest,
 }
 
 static void set_cpus_allowed_rt(struct task_struct *p,
-                                const cpumask_t *new_mask)
+                                const struct cpumask *new_mask)
 {
-        int weight = cpus_weight(*new_mask);
+        int weight = cpumask_weight(new_mask);
 
         BUG_ON(!rt_task(p));
 
@@ -1331,7 +1334,7 @@ static void set_cpus_allowed_rt(struct task_struct *p,
                 update_rt_migration(rq);
         }
 
-        p->cpus_allowed    = *new_mask;
+        cpumask_copy(&p->cpus_allowed, new_mask);
         p->rt.nr_cpus_allowed = weight;
 }
 
@@ -1374,6 +1377,14 @@ static void switched_from_rt(struct rq *rq, struct task_struct *p,
         if (!rq->rt.rt_nr_running)
                 pull_rt_task(rq);
 }
+
+static inline void init_sched_rt_class(void)
+{
+        unsigned int i;
+
+        for_each_possible_cpu(i)
+                alloc_cpumask_var(&per_cpu(local_cpu_mask, i), GFP_KERNEL);
+}
 #endif /* CONFIG_SMP */
 
 /*
@@ -1544,3 +1555,4 @@ static void print_rt_stats(struct seq_file *m, int cpu)
         rcu_read_unlock();
 }
 #endif /* CONFIG_SCHED_DEBUG */
+
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index ee71bec1da66..ce340835d055 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -42,7 +42,8 @@ static int show_schedstat(struct seq_file *seq, void *v)
                 for_each_domain(cpu, sd) {
                         enum cpu_idle_type itype;
 
-                        cpumask_scnprintf(mask_str, mask_len, sd->span);
+                        cpumask_scnprintf(mask_str, mask_len,
+                                          *sched_domain_span(sd));
                         seq_printf(seq, "domain%d %s", dcount++, mask_str);
                         for (itype = CPU_IDLE; itype < CPU_MAX_IDLE_TYPES;
                                         itype++) {
@@ -298,9 +299,11 @@ static inline void account_group_user_time(struct task_struct *tsk,
 {
         struct signal_struct *sig;
 
-        sig = tsk->signal;
-        if (unlikely(!sig))
+        /* tsk == current, ensure it is safe to use ->signal */
+        if (unlikely(tsk->exit_state))
                 return;
+
+        sig = tsk->signal;
         if (sig->cputime.totals) {
                 struct task_cputime *times;
 
@@ -325,9 +328,11 @@ static inline void account_group_system_time(struct task_struct *tsk,
 {
         struct signal_struct *sig;
 
-        sig = tsk->signal;
-        if (unlikely(!sig))
+        /* tsk == current, ensure it is safe to use ->signal */
+        if (unlikely(tsk->exit_state))
                 return;
+
+        sig = tsk->signal;
         if (sig->cputime.totals) {
                 struct task_cputime *times;
 
@@ -353,8 +358,11 @@ static inline void account_group_exec_runtime(struct task_struct *tsk,
         struct signal_struct *sig;
 
         sig = tsk->signal;
+        /* see __exit_signal()->task_rq_unlock_wait() */
+        barrier();
         if (unlikely(!sig))
                 return;
+
         if (sig->cputime.totals) {
                 struct task_cputime *times;
 
diff --git a/kernel/signal.c b/kernel/signal.c
index 4530fc654455..e9afe63da24b 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -41,6 +41,8 @@
 
 static struct kmem_cache *sigqueue_cachep;
 
+DEFINE_TRACE(sched_signal_send);
+
 static void __user *sig_handler(struct task_struct *t, int sig)
 {
         return t->sighand->action[sig - 1].sa.sa_handler;
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 7110daeb9a90..e7c69a720d69 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -269,10 +269,11 @@ void irq_enter(void)
 {
         int cpu = smp_processor_id();
 
-        if (idle_cpu(cpu) && !in_interrupt())
+        if (idle_cpu(cpu) && !in_interrupt()) {
+                __irq_enter();
                 tick_check_idle(cpu);
-
-        __irq_enter();
+        } else
+                __irq_enter();
 }
 
 #ifdef __ARCH_IRQ_EXIT_IRQS_DISABLED
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 3953e4aed733..1ab790c67b17 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -164,7 +164,7 @@ unsigned long __read_mostly sysctl_hung_task_check_count = 1024;
 /*
  * Zero means infinite timeout - no checking done:
  */
-unsigned long __read_mostly sysctl_hung_task_timeout_secs = 120;
+unsigned long __read_mostly sysctl_hung_task_timeout_secs = 480;
 
 unsigned long __read_mostly sysctl_hung_task_warnings = 10;
 
@@ -188,7 +188,7 @@ static void check_hung_task(struct task_struct *t, unsigned long now)
         if ((long)(now - t->last_switch_timestamp) <
                                         sysctl_hung_task_timeout_secs)
                 return;
-        if (sysctl_hung_task_warnings < 0)
+        if (!sysctl_hung_task_warnings)
                 return;
         sysctl_hung_task_warnings--;
 
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index 9bc4c00872c9..24e8ceacc388 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -112,7 +112,7 @@ static int chill(void *unused)
 int __stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus)
 {
         struct work_struct *sm_work;
-        int i;
+        int i, ret;
 
         /* Set up initial state. */
         mutex_lock(&lock);
@@ -137,8 +137,9 @@ int __stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus)
         /* This will release the thread on our CPU. */
         put_cpu();
         flush_workqueue(stop_machine_wq);
+        ret = active.fnret;
         mutex_unlock(&lock);
-        return active.fnret;
+        return ret;
 }
 
 int stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus)
diff --git a/kernel/sys.c b/kernel/sys.c
index 31deba8f7d16..5fc3a0cfb994 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -858,8 +858,8 @@ void do_sys_times(struct tms *tms)
         struct task_cputime cputime;
         cputime_t cutime, cstime;
 
-        spin_lock_irq(&current->sighand->siglock);
         thread_group_cputime(current, &cputime);
+        spin_lock_irq(&current->sighand->siglock);
         cutime = current->signal->cutime;
         cstime = current->signal->cstime;
         spin_unlock_irq(&current->sighand->siglock);
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index a77b27b11b04..e14a23281707 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -31,7 +31,7 @@ cond_syscall(sys_socketpair);
 cond_syscall(sys_bind);
 cond_syscall(sys_listen);
 cond_syscall(sys_accept);
-cond_syscall(sys_paccept);
+cond_syscall(sys_accept4);
 cond_syscall(sys_connect);
 cond_syscall(sys_getsockname);
 cond_syscall(sys_getpeername);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 9d048fa2d902..c83f566e940a 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -176,6 +176,9 @@ extern struct ctl_table random_table[];
 #ifdef CONFIG_INOTIFY_USER
 extern struct ctl_table inotify_table[];
 #endif
+#ifdef CONFIG_EPOLL
+extern struct ctl_table epoll_table[];
+#endif
 
 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
 int sysctl_legacy_va_layout;
@@ -484,6 +487,16 @@ static struct ctl_table kern_table[] = {
                 .proc_handler   = &ftrace_enable_sysctl,
         },
 #endif
+#ifdef CONFIG_TRACING
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "ftrace_dump_on_oops",
+                .data           = &ftrace_dump_on_oops,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
+#endif
 #ifdef CONFIG_MODULES
         {
                 .ctl_name       = KERN_MODPROBE,
@@ -1325,6 +1338,13 @@ static struct ctl_table fs_table[] = {
                 .child          = inotify_table,
         },
 #endif  
+#ifdef CONFIG_EPOLL
+        {
+                .procname       = "epoll",
+                .mode           = 0555,
+                .child          = epoll_table,
+        },
+#endif
 #endif
         {
                 .ctl_name       = KERN_SETUID_DUMPABLE,
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 5bbb1044f847..70f872c71f4e 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -144,7 +144,7 @@ void tick_nohz_update_jiffies(void)
         if (!ts->tick_stopped)
                 return;
 
-        cpu_clear(cpu, nohz_cpu_mask);
+        cpumask_clear_cpu(cpu, nohz_cpu_mask);
         now = ktime_get();
         ts->idle_waketime = now;
 
@@ -283,7 +283,7 @@ void tick_nohz_stop_sched_tick(int inidle)
         if ((long)delta_jiffies >= 1) {
 
                 if (delta_jiffies > 1)
-                        cpu_set(cpu, nohz_cpu_mask);
+                        cpumask_set_cpu(cpu, nohz_cpu_mask);
                 /*
                  * nohz_stop_sched_tick can be called several times before
                  * the nohz_restart_sched_tick is called. This happens when
@@ -296,7 +296,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                                 /*
                                  * sched tick not stopped!
                                  */
-                                cpu_clear(cpu, nohz_cpu_mask);
+                                cpumask_clear_cpu(cpu, nohz_cpu_mask);
                                 goto out;
                         }
 
@@ -354,7 +354,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                  * softirq.
                  */
                 tick_do_update_jiffies64(ktime_get());
-                cpu_clear(cpu, nohz_cpu_mask);
+                cpumask_clear_cpu(cpu, nohz_cpu_mask);
         }
         raise_softirq_irqoff(TIMER_SOFTIRQ);
 out:
@@ -432,7 +432,7 @@ void tick_nohz_restart_sched_tick(void)
         select_nohz_load_balancer(0);
         now = ktime_get();
         tick_do_update_jiffies64(now);
-        cpu_clear(cpu, nohz_cpu_mask);
+        cpumask_clear_cpu(cpu, nohz_cpu_mask);
 
         /*
          * We stopped the tick in idle. Update process times would miss the
@@ -568,6 +568,9 @@ static void tick_nohz_switch_to_nohz(void)
  */
 static void tick_nohz_kick_tick(int cpu)
 {
+#if 0
+        /* Switch back to 2.6.27 behaviour */
+
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
         ktime_t delta, now;
 
@@ -584,6 +587,7 @@ static void tick_nohz_kick_tick(int cpu)
                 return;
 
         tick_nohz_restart(ts, now);
+#endif
 }
 
 #else
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index e7acfb482a68..fa05e88aa76f 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -518,6 +518,28 @@ void update_wall_time(void)
         /* correct the clock when NTP error is too big */
         clocksource_adjust(offset);
 
+        /*
+         * Since in the loop above, we accumulate any amount of time
+         * in xtime_nsec over a second into xtime.tv_sec, its possible for
+         * xtime_nsec to be fairly small after the loop. Further, if we're
+         * slightly speeding the clocksource up in clocksource_adjust(),
+         * its possible the required corrective factor to xtime_nsec could
+         * cause it to underflow.
+         *
+         * Now, we cannot simply roll the accumulated second back, since
+         * the NTP subsystem has been notified via second_overflow. So
+         * instead we push xtime_nsec forward by the amount we underflowed,
+         * and add that amount into the error.
+         *
+         * We'll correct this error next time through this function, when
+         * xtime_nsec is not as small.
+         */
+        if (unlikely((s64)clock->xtime_nsec < 0)) {
+                s64 neg = -(s64)clock->xtime_nsec;
+                clock->xtime_nsec = 0;
+                clock->error += neg << (NTP_SCALE_SHIFT - clock->shift);
+        }
+
         /* store full nanoseconds into xtime after rounding it up and
          * add the remainder to the error difference.
          */
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 33dbefd471e8..bde6f03512d5 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -3,18 +3,34 @@
 #  select HAVE_FUNCTION_TRACER:
 #
 
+config USER_STACKTRACE_SUPPORT
+        bool
+
 config NOP_TRACER
         bool
 
 config HAVE_FUNCTION_TRACER
         bool
 
+config HAVE_FUNCTION_GRAPH_TRACER
+        bool
+
+config HAVE_FUNCTION_TRACE_MCOUNT_TEST
+        bool
+        help
+         This gets selected when the arch tests the function_trace_stop
+         variable at the mcount call site. Otherwise, this variable
+         is tested by the called function.
+
 config HAVE_DYNAMIC_FTRACE
         bool
 
 config HAVE_FTRACE_MCOUNT_RECORD
         bool
 
+config HAVE_HW_BRANCH_TRACER
+        bool
+
 config TRACER_MAX_TRACE
         bool
 
@@ -47,6 +63,20 @@ config FUNCTION_TRACER
           (the bootup default), then the overhead of the instructions is very
           small and not measurable even in micro-benchmarks.
 
+config FUNCTION_GRAPH_TRACER
+        bool "Kernel Function Graph Tracer"
+        depends on HAVE_FUNCTION_GRAPH_TRACER
+        depends on FUNCTION_TRACER
+        default y
+        help
+          Enable the kernel to trace a function at both its return
+          and its entry.
+          It's first purpose is to trace the duration of functions and
+          draw a call graph for each thread with some informations like
+          the return value.
+          This is done by setting the current return address on the current
+          task structure into a stack of calls.
+
 config IRQSOFF_TRACER
         bool "Interrupts-off Latency Tracer"
         default n
@@ -138,6 +168,70 @@ config BOOT_TRACER
             selected, because the self-tests are an initcall as well and that
             would invalidate the boot trace. )
 
+config TRACE_BRANCH_PROFILING
+        bool "Trace likely/unlikely profiler"
+        depends on DEBUG_KERNEL
+        select TRACING
+        help
+          This tracer profiles all the the likely and unlikely macros
+          in the kernel. It will display the results in:
+
+          /debugfs/tracing/profile_annotated_branch
+
+          Note: this will add a significant overhead, only turn this
+          on if you need to profile the system's use of these macros.
+
+          Say N if unsure.
+
+config PROFILE_ALL_BRANCHES
+        bool "Profile all if conditionals"
+        depends on TRACE_BRANCH_PROFILING
+        help
+          This tracer profiles all branch conditions. Every if ()
+          taken in the kernel is recorded whether it hit or miss.
+          The results will be displayed in:
+
+          /debugfs/tracing/profile_branch
+
+          This configuration, when enabled, will impose a great overhead
+          on the system. This should only be enabled when the system
+          is to be analyzed
+
+          Say N if unsure.
+
+config TRACING_BRANCHES
+        bool
+        help
+          Selected by tracers that will trace the likely and unlikely
+          conditions. This prevents the tracers themselves from being
+          profiled. Profiling the tracing infrastructure can only happen
+          when the likelys and unlikelys are not being traced.
+
+config BRANCH_TRACER
+        bool "Trace likely/unlikely instances"
+        depends on TRACE_BRANCH_PROFILING
+        select TRACING_BRANCHES
+        help
+          This traces the events of likely and unlikely condition
+          calls in the kernel.  The difference between this and the
+          "Trace likely/unlikely profiler" is that this is not a
+          histogram of the callers, but actually places the calling
+          events into a running trace buffer to see when and where the
+          events happened, as well as their results.
+
+          Say N if unsure.
+
+config POWER_TRACER
+        bool "Trace power consumption behavior"
+        depends on DEBUG_KERNEL
+        depends on X86
+        select TRACING
+        help
+          This tracer helps developers to analyze and optimize the kernels
+          power management decisions, specifically the C-state and P-state
+          behavior.
+
+
 config STACK_TRACER
         bool "Trace max stack"
         depends on HAVE_FUNCTION_TRACER
@@ -157,6 +251,14 @@ config STACK_TRACER
 
           Say N if unsure.
 
+config BTS_TRACER
+        depends on HAVE_HW_BRANCH_TRACER
+        bool "Trace branches"
+        select TRACING
+        help
+          This tracer records all branches on the system in a circular
+          buffer giving access to the last N branches for each cpu.
+
 config DYNAMIC_FTRACE
         bool "enable/disable ftrace tracepoints dynamically"
         depends on FUNCTION_TRACER
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index c8228b1a49e9..62dc561b6676 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -10,6 +10,11 @@ CFLAGS_trace_selftest_dynamic.o = -pg
 obj-y += trace_selftest_dynamic.o
 endif
 
+# If unlikely tracing is enabled, do not trace these files
+ifdef CONFIG_TRACING_BRANCHES
+KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
+endif
+
 obj-$(CONFIG_FUNCTION_TRACER) += libftrace.o
 obj-$(CONFIG_RING_BUFFER) += ring_buffer.o
 
@@ -24,5 +29,9 @@ obj-$(CONFIG_NOP_TRACER) += trace_nop.o
 obj-$(CONFIG_STACK_TRACER) += trace_stack.o
 obj-$(CONFIG_MMIOTRACE) += trace_mmiotrace.o
 obj-$(CONFIG_BOOT_TRACER) += trace_boot.o
+obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += trace_functions_graph.o
+obj-$(CONFIG_TRACE_BRANCH_PROFILING) += trace_branch.o
+obj-$(CONFIG_BTS_TRACER) += trace_bts.o
+obj-$(CONFIG_POWER_TRACER) += trace_power.o
 
 libftrace-y := ftrace.o
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 4a39d24568c8..a12f80efceaa 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -47,6 +47,13 @@
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
 
+/* set when tracing only a pid */
+struct pid *ftrace_pid_trace;
+static struct pid * const ftrace_swapper_pid = &init_struct_pid;
+
+/* Quick disabling of function tracer. */
+int function_trace_stop;
+
 /*
  * ftrace_disabled is set when an anomaly is discovered.
  * ftrace_disabled is much stronger than ftrace_enabled.
@@ -55,6 +62,7 @@ static int ftrace_disabled __read_mostly;
 
 static DEFINE_SPINLOCK(ftrace_lock);
 static DEFINE_MUTEX(ftrace_sysctl_lock);
+static DEFINE_MUTEX(ftrace_start_lock);
 
 static struct ftrace_ops ftrace_list_end __read_mostly =
 {
@@ -63,6 +71,8 @@ static struct ftrace_ops ftrace_list_end __read_mostly =
 
 static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
+ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
+ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 
 static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 {
@@ -79,6 +89,21 @@ static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
         };
 }
 
+static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip)
+{
+        if (!test_tsk_trace_trace(current))
+                return;
+
+        ftrace_pid_function(ip, parent_ip);
+}
+
+static void set_ftrace_pid_function(ftrace_func_t func)
+{
+        /* do not set ftrace_pid_function to itself! */
+        if (func != ftrace_pid_func)
+                ftrace_pid_function = func;
+}
+
 /**
  * clear_ftrace_function - reset the ftrace function
  *
@@ -88,8 +113,24 @@ static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 void clear_ftrace_function(void)
 {
         ftrace_trace_function = ftrace_stub;
+        __ftrace_trace_function = ftrace_stub;
+        ftrace_pid_function = ftrace_stub;
 }
 
+#ifndef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+/*
+ * For those archs that do not test ftrace_trace_stop in their
+ * mcount call site, we need to do it from C.
+ */
+static void ftrace_test_stop_func(unsigned long ip, unsigned long parent_ip)
+{
+        if (function_trace_stop)
+                return;
+
+        __ftrace_trace_function(ip, parent_ip);
+}
+#endif
+
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
         /* should not be called from interrupt context */
@@ -106,14 +147,28 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         ftrace_list = ops;
 
         if (ftrace_enabled) {
+                ftrace_func_t func;
+
+                if (ops->next == &ftrace_list_end)
+                        func = ops->func;
+                else
+                        func = ftrace_list_func;
+
+                if (ftrace_pid_trace) {
+                        set_ftrace_pid_function(func);
+                        func = ftrace_pid_func;
+                }
+
                 /*
                  * For one func, simply call it directly.
                  * For more than one func, call the chain.
                  */
-                if (ops->next == &ftrace_list_end)
-                        ftrace_trace_function = ops->func;
-                else
-                        ftrace_trace_function = ftrace_list_func;
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+                ftrace_trace_function = func;
+#else
+                __ftrace_trace_function = func;
+                ftrace_trace_function = ftrace_test_stop_func;
+#endif
         }
 
         spin_unlock(&ftrace_lock);
@@ -152,9 +207,19 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
 
         if (ftrace_enabled) {
                 /* If we only have one func left, then call that directly */
-                if (ftrace_list == &ftrace_list_end ||
-                    ftrace_list->next == &ftrace_list_end)
-                        ftrace_trace_function = ftrace_list->func;
+                if (ftrace_list->next == &ftrace_list_end) {
+                        ftrace_func_t func = ftrace_list->func;
+
+                        if (ftrace_pid_trace) {
+                                set_ftrace_pid_function(func);
+                                func = ftrace_pid_func;
+                        }
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+                        ftrace_trace_function = func;
+#else
+                        __ftrace_trace_function = func;
+#endif
+                }
         }
 
  out:
@@ -163,6 +228,36 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         return ret;
 }
 
+static void ftrace_update_pid_func(void)
+{
+        ftrace_func_t func;
+
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
+
+        if (ftrace_trace_function == ftrace_stub)
+                goto out;
+
+        func = ftrace_trace_function;
+
+        if (ftrace_pid_trace) {
+                set_ftrace_pid_function(func);
+                func = ftrace_pid_func;
+        } else {
+                if (func == ftrace_pid_func)
+                        func = ftrace_pid_function;
+        }
+
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+        ftrace_trace_function = func;
+#else
+        __ftrace_trace_function = func;
+#endif
+
+ out:
+        spin_unlock(&ftrace_lock);
+}
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
 # error Dynamic ftrace depends on MCOUNT_RECORD
@@ -182,10 +277,11 @@ enum {
         FTRACE_UPDATE_TRACE_FUNC        = (1 << 2),
         FTRACE_ENABLE_MCOUNT            = (1 << 3),
         FTRACE_DISABLE_MCOUNT           = (1 << 4),
+        FTRACE_START_FUNC_RET           = (1 << 5),
+        FTRACE_STOP_FUNC_RET            = (1 << 6),
 };
 
 static int ftrace_filtered;
-static int tracing_on;
 
 static LIST_HEAD(ftrace_new_addrs);
 
@@ -309,7 +405,7 @@ ftrace_record_ip(unsigned long ip)
 {
         struct dyn_ftrace *rec;
 
-        if (!ftrace_enabled || ftrace_disabled)
+        if (ftrace_disabled)
                 return NULL;
 
         rec = ftrace_alloc_dyn_node(ip);
@@ -323,107 +419,131 @@ ftrace_record_ip(unsigned long ip)
         return rec;
 }
 
-#define FTRACE_ADDR ((long)(ftrace_caller))
+static void print_ip_ins(const char *fmt, unsigned char *p)
+{
+        int i;
+
+        printk(KERN_CONT "%s", fmt);
+
+        for (i = 0; i < MCOUNT_INSN_SIZE; i++)
+                printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
+}
+
+static void ftrace_bug(int failed, unsigned long ip)
+{
+        switch (failed) {
+        case -EFAULT:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace faulted on modifying ");
+                print_ip_sym(ip);
+                break;
+        case -EINVAL:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace failed to modify ");
+                print_ip_sym(ip);
+                print_ip_ins(" actual: ", (unsigned char *)ip);
+                printk(KERN_CONT "\n");
+                break;
+        case -EPERM:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace faulted on writing ");
+                print_ip_sym(ip);
+                break;
+        default:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace faulted on unknown error ");
+                print_ip_sym(ip);
+        }
+}
+
 
 static int
-__ftrace_replace_code(struct dyn_ftrace *rec,
-                      unsigned char *old, unsigned char *new, int enable)
+__ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 {
         unsigned long ip, fl;
+        unsigned long ftrace_addr;
+
+        ftrace_addr = (unsigned long)ftrace_caller;
 
         ip = rec->ip;
 
-        if (ftrace_filtered && enable) {
+        /*
+         * If this record is not to be traced and
+         * it is not enabled then do nothing.
+         *
+         * If this record is not to be traced and
+         * it is enabled then disabled it.
+         *
+         */
+        if (rec->flags & FTRACE_FL_NOTRACE) {
+                if (rec->flags & FTRACE_FL_ENABLED)
+                        rec->flags &= ~FTRACE_FL_ENABLED;
+                else
+                        return 0;
+
+        } else if (ftrace_filtered && enable) {
                 /*
-                 * If filtering is on:
-                 *
-                 * If this record is set to be filtered and
-                 * is enabled then do nothing.
-                 *
-                 * If this record is set to be filtered and
-                 * it is not enabled, enable it.
-                 *
-                 * If this record is not set to be filtered
-                 * and it is not enabled do nothing.
-                 *
-                 * If this record is set not to trace then
-                 * do nothing.
-                 *
-                 * If this record is set not to trace and
-                 * it is enabled then disable it.
-                 *
-                 * If this record is not set to be filtered and
-                 * it is enabled, disable it.
+                 * Filtering is on:
                  */
 
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
-                                   FTRACE_FL_ENABLED);
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
 
-                if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
-                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
-                    !fl || (fl == FTRACE_FL_NOTRACE))
+                /* Record is filtered and enabled, do nothing */
+                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
                         return 0;
 
-                /*
-                 * If it is enabled disable it,
-                 * otherwise enable it!
-                 */
-                if (fl & FTRACE_FL_ENABLED) {
-                        /* swap new and old */
-                        new = old;
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
+                /* Record is not filtered and is not enabled do nothing */
+                if (!fl)
+                        return 0;
+
+                /* Record is not filtered but enabled, disable it */
+                if (fl == FTRACE_FL_ENABLED)
                         rec->flags &= ~FTRACE_FL_ENABLED;
-                } else {
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
+                else
+                /* Otherwise record is filtered but not enabled, enable it */
                         rec->flags |= FTRACE_FL_ENABLED;
-                }
         } else {
+                /* Disable or not filtered */
 
                 if (enable) {
-                        /*
-                         * If this record is set not to trace and is
-                         * not enabled, do nothing.
-                         */
-                        fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
-                        if (fl == FTRACE_FL_NOTRACE)
-                                return 0;
-
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
-                } else
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
-
-                if (enable) {
+                        /* if record is enabled, do nothing */
                         if (rec->flags & FTRACE_FL_ENABLED)
                                 return 0;
+
                         rec->flags |= FTRACE_FL_ENABLED;
+
                 } else {
+
+                        /* if record is not enabled do nothing */
                         if (!(rec->flags & FTRACE_FL_ENABLED))
                                 return 0;
+
                         rec->flags &= ~FTRACE_FL_ENABLED;
                 }
         }
 
-        return ftrace_modify_code(ip, old, new);
+        if (rec->flags & FTRACE_FL_ENABLED)
+                return ftrace_make_call(rec, ftrace_addr);
+        else
+                return ftrace_make_nop(NULL, rec, ftrace_addr);
 }
 
 static void ftrace_replace_code(int enable)
 {
         int i, failed;
-        unsigned char *new = NULL, *old = NULL;
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
 
-        if (enable)
-                old = ftrace_nop_replace();
-        else
-                new = ftrace_nop_replace();
-
         for (pg = ftrace_pages_start; pg; pg = pg->next) {
                 for (i = 0; i < pg->index; i++) {
                         rec = &pg->records[i];
 
-                        /* don't modify code that has already faulted */
-                        if (rec->flags & FTRACE_FL_FAILED)
+                        /*
+                         * Skip over free records and records that have
+                         * failed.
+                         */
+                        if (rec->flags & FTRACE_FL_FREE ||
+                            rec->flags & FTRACE_FL_FAILED)
                                 continue;
 
                         /* ignore updates to this record's mcount site */
@@ -434,68 +554,30 @@ static void ftrace_replace_code(int enable)
                                 unfreeze_record(rec);
                         }
 
-                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        failed = __ftrace_replace_code(rec, enable);
                         if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
                                 rec->flags |= FTRACE_FL_FAILED;
                                 if ((system_state == SYSTEM_BOOTING) ||
                                     !core_kernel_text(rec->ip)) {
                                         ftrace_free_rec(rec);
-                                }
+                                } else
+                                        ftrace_bug(failed, rec->ip);
                         }
                 }
         }
 }
 
-static void print_ip_ins(const char *fmt, unsigned char *p)
-{
-        int i;
-
-        printk(KERN_CONT "%s", fmt);
-
-        for (i = 0; i < MCOUNT_INSN_SIZE; i++)
-                printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
-}
-
 static int
-ftrace_code_disable(struct dyn_ftrace *rec)
+ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
 {
         unsigned long ip;
-        unsigned char *nop, *call;
         int ret;
 
         ip = rec->ip;
 
-        nop = ftrace_nop_replace();
-        call = ftrace_call_replace(ip, mcount_addr);
-
-        ret = ftrace_modify_code(ip, call, nop);
+        ret = ftrace_make_nop(mod, rec, mcount_addr);
         if (ret) {
-                switch (ret) {
-                case -EFAULT:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace faulted on modifying ");
-                        print_ip_sym(ip);
-                        break;
-                case -EINVAL:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace failed to modify ");
-                        print_ip_sym(ip);
-                        print_ip_ins(" expected: ", call);
-                        print_ip_ins(" actual: ", (unsigned char *)ip);
-                        print_ip_ins(" replace: ", nop);
-                        printk(KERN_CONT "\n");
-                        break;
-                case -EPERM:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace faulted on writing ");
-                        print_ip_sym(ip);
-                        break;
-                default:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace faulted on unknown error ");
-                        print_ip_sym(ip);
-                }
-
+                ftrace_bug(ret, ip);
                 rec->flags |= FTRACE_FL_FAILED;
                 return 0;
         }
@@ -506,17 +588,19 @@ static int __ftrace_modify_code(void *data)
 {
         int *command = data;
 
-        if (*command & FTRACE_ENABLE_CALLS) {
+        if (*command & FTRACE_ENABLE_CALLS)
                 ftrace_replace_code(1);
-                tracing_on = 1;
-        } else if (*command & FTRACE_DISABLE_CALLS) {
+        else if (*command & FTRACE_DISABLE_CALLS)
                 ftrace_replace_code(0);
-                tracing_on = 0;
-        }
 
         if (*command & FTRACE_UPDATE_TRACE_FUNC)
                 ftrace_update_ftrace_func(ftrace_trace_function);
 
+        if (*command & FTRACE_START_FUNC_RET)
+                ftrace_enable_ftrace_graph_caller();
+        else if (*command & FTRACE_STOP_FUNC_RET)
+                ftrace_disable_ftrace_graph_caller();
+
         return 0;
 }
 
@@ -526,44 +610,43 @@ static void ftrace_run_update_code(int command)
 }
 
 static ftrace_func_t saved_ftrace_func;
-static int ftrace_start;
-static DEFINE_MUTEX(ftrace_start_lock);
+static int ftrace_start_up;
 
-static void ftrace_startup(void)
+static void ftrace_startup_enable(int command)
 {
-        int command = 0;
-
-        if (unlikely(ftrace_disabled))
-                return;
-
-        mutex_lock(&ftrace_start_lock);
-        ftrace_start++;
-        if (ftrace_start == 1)
-                command |= FTRACE_ENABLE_CALLS;
-
         if (saved_ftrace_func != ftrace_trace_function) {
                 saved_ftrace_func = ftrace_trace_function;
                 command |= FTRACE_UPDATE_TRACE_FUNC;
         }
 
         if (!command || !ftrace_enabled)
-                goto out;
+                return;
 
         ftrace_run_update_code(command);
- out:
-        mutex_unlock(&ftrace_start_lock);
 }
 
-static void ftrace_shutdown(void)
+static void ftrace_startup(int command)
 {
-        int command = 0;
+        if (unlikely(ftrace_disabled))
+                return;
+
+        mutex_lock(&ftrace_start_lock);
+        ftrace_start_up++;
+        command |= FTRACE_ENABLE_CALLS;
+
+        ftrace_startup_enable(command);
 
+        mutex_unlock(&ftrace_start_lock);
+}
+
+static void ftrace_shutdown(int command)
+{
         if (unlikely(ftrace_disabled))
                 return;
 
         mutex_lock(&ftrace_start_lock);
-        ftrace_start--;
-        if (!ftrace_start)
+        ftrace_start_up--;
+        if (!ftrace_start_up)
                 command |= FTRACE_DISABLE_CALLS;
 
         if (saved_ftrace_func != ftrace_trace_function) {
@@ -589,8 +672,8 @@ static void ftrace_startup_sysctl(void)
         mutex_lock(&ftrace_start_lock);
         /* Force update next time */
         saved_ftrace_func = NULL;
-        /* ftrace_start is true if we want ftrace running */
-        if (ftrace_start)
+        /* ftrace_start_up is true if we want ftrace running */
+        if (ftrace_start_up)
                 command |= FTRACE_ENABLE_CALLS;
 
         ftrace_run_update_code(command);
@@ -605,8 +688,8 @@ static void ftrace_shutdown_sysctl(void)
                 return;
 
         mutex_lock(&ftrace_start_lock);
-        /* ftrace_start is true if ftrace is running */
-        if (ftrace_start)
+        /* ftrace_start_up is true if ftrace is running */
+        if (ftrace_start_up)
                 command |= FTRACE_DISABLE_CALLS;
 
         ftrace_run_update_code(command);
@@ -617,7 +700,7 @@ static cycle_t		ftrace_update_time;
 static unsigned long    ftrace_update_cnt;
 unsigned long           ftrace_update_tot_cnt;
 
-static int ftrace_update_code(void)
+static int ftrace_update_code(struct module *mod)
 {
         struct dyn_ftrace *p, *t;
         cycle_t start, stop;
@@ -634,7 +717,7 @@ static int ftrace_update_code(void)
                 list_del_init(&p->list);
 
                 /* convert record (i.e, patch mcount-call with NOP) */
-                if (ftrace_code_disable(p)) {
+                if (ftrace_code_disable(mod, p)) {
                         p->flags |= FTRACE_FL_CONVERTED;
                         ftrace_update_cnt++;
                 } else
@@ -677,7 +760,7 @@ static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
 
         cnt = num_to_init / ENTRIES_PER_PAGE;
         pr_info("ftrace: allocating %ld entries in %d pages\n",
-                num_to_init, cnt);
+                num_to_init, cnt + 1);
 
         for (i = 0; i < cnt; i++) {
                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
@@ -702,7 +785,6 @@ enum {
 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
 
 struct ftrace_iterator {
-        loff_t                  pos;
         struct ftrace_page      *pg;
         unsigned                idx;
         unsigned                flags;
@@ -727,6 +809,8 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                         iter->pg = iter->pg->next;
                         iter->idx = 0;
                         goto retry;
+                } else {
+                        iter->idx = -1;
                 }
         } else {
                 rec = &iter->pg->records[iter->idx++];
@@ -738,6 +822,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                     ((iter->flags & FTRACE_ITER_FAILURES) &&
                      !(rec->flags & FTRACE_FL_FAILED)) ||
 
+                    ((iter->flags & FTRACE_ITER_FILTER) &&
+                     !(rec->flags & FTRACE_FL_FILTER)) ||
+
                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
                      !(rec->flags & FTRACE_FL_NOTRACE))) {
                         rec = NULL;
@@ -746,8 +833,6 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
         }
         spin_unlock(&ftrace_lock);
 
-        iter->pos = *pos;
-
         return rec;
 }
 
@@ -755,16 +840,16 @@ static void *t_start(struct seq_file *m, loff_t *pos)
 {
         struct ftrace_iterator *iter = m->private;
         void *p = NULL;
-        loff_t l = -1;
 
-        if (*pos != iter->pos) {
-                for (p = t_next(m, p, &l); p && l < *pos; p = t_next(m, p, &l))
-                        ;
-        } else {
-                l = *pos;
-                p = t_next(m, p, &l);
+        if (*pos > 0) {
+                if (iter->idx < 0)
+                        return p;
+                (*pos)--;
+                iter->idx--;
         }
 
+        p = t_next(m, p, pos);
+
         return p;
 }
 
@@ -808,7 +893,6 @@ ftrace_avail_open(struct inode *inode, struct file *file)
                 return -ENOMEM;
 
         iter->pg = ftrace_pages_start;
-        iter->pos = -1;
 
         ret = seq_open(file, &show_ftrace_seq_ops);
         if (!ret) {
@@ -895,7 +979,6 @@ ftrace_regex_open(struct inode *inode, struct file *file, int enable)
 
         if (file->f_mode & FMODE_READ) {
                 iter->pg = ftrace_pages_start;
-                iter->pos = -1;
                 iter->flags = enable ? FTRACE_ITER_FILTER :
                         FTRACE_ITER_NOTRACE;
 
@@ -1186,7 +1269,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
 
         mutex_lock(&ftrace_sysctl_lock);
         mutex_lock(&ftrace_start_lock);
-        if (iter->filtered && ftrace_start && ftrace_enabled)
+        if (ftrace_start_up && ftrace_enabled)
                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
         mutex_unlock(&ftrace_start_lock);
         mutex_unlock(&ftrace_sysctl_lock);
@@ -1238,12 +1321,233 @@ static struct file_operations ftrace_notrace_fops = {
         .release = ftrace_notrace_release,
 };
 
-static __init int ftrace_init_debugfs(void)
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+
+static DEFINE_MUTEX(graph_lock);
+
+int ftrace_graph_count;
+unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS] __read_mostly;
+
+static void *
+g_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct dentry *d_tracer;
-        struct dentry *entry;
+        unsigned long *array = m->private;
+        int index = *pos;
 
-        d_tracer = tracing_init_dentry();
+        (*pos)++;
+
+        if (index >= ftrace_graph_count)
+                return NULL;
+
+        return &array[index];
+}
+
+static void *g_start(struct seq_file *m, loff_t *pos)
+{
+        void *p = NULL;
+
+        mutex_lock(&graph_lock);
+
+        p = g_next(m, p, pos);
+
+        return p;
+}
+
+static void g_stop(struct seq_file *m, void *p)
+{
+        mutex_unlock(&graph_lock);
+}
+
+static int g_show(struct seq_file *m, void *v)
+{
+        unsigned long *ptr = v;
+        char str[KSYM_SYMBOL_LEN];
+
+        if (!ptr)
+                return 0;
+
+        kallsyms_lookup(*ptr, NULL, NULL, NULL, str);
+
+        seq_printf(m, "%s\n", str);
+
+        return 0;
+}
+
+static struct seq_operations ftrace_graph_seq_ops = {
+        .start = g_start,
+        .next = g_next,
+        .stop = g_stop,
+        .show = g_show,
+};
+
+static int
+ftrace_graph_open(struct inode *inode, struct file *file)
+{
+        int ret = 0;
+
+        if (unlikely(ftrace_disabled))
+                return -ENODEV;
+
+        mutex_lock(&graph_lock);
+        if ((file->f_mode & FMODE_WRITE) &&
+            !(file->f_flags & O_APPEND)) {
+                ftrace_graph_count = 0;
+                memset(ftrace_graph_funcs, 0, sizeof(ftrace_graph_funcs));
+        }
+
+        if (file->f_mode & FMODE_READ) {
+                ret = seq_open(file, &ftrace_graph_seq_ops);
+                if (!ret) {
+                        struct seq_file *m = file->private_data;
+                        m->private = ftrace_graph_funcs;
+                }
+        } else
+                file->private_data = ftrace_graph_funcs;
+        mutex_unlock(&graph_lock);
+
+        return ret;
+}
+
+static ssize_t
+ftrace_graph_read(struct file *file, char __user *ubuf,
+                       size_t cnt, loff_t *ppos)
+{
+        if (file->f_mode & FMODE_READ)
+                return seq_read(file, ubuf, cnt, ppos);
+        else
+                return -EPERM;
+}
+
+static int
+ftrace_set_func(unsigned long *array, int idx, char *buffer)
+{
+        char str[KSYM_SYMBOL_LEN];
+        struct dyn_ftrace *rec;
+        struct ftrace_page *pg;
+        int found = 0;
+        int i, j;
+
+        if (ftrace_disabled)
+                return -ENODEV;
+
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
+
+        for (pg = ftrace_pages_start; pg; pg = pg->next) {
+                for (i = 0; i < pg->index; i++) {
+                        rec = &pg->records[i];
+
+                        if (rec->flags & (FTRACE_FL_FAILED | FTRACE_FL_FREE))
+                                continue;
+
+                        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
+                        if (strcmp(str, buffer) == 0) {
+                                found = 1;
+                                for (j = 0; j < idx; j++)
+                                        if (array[j] == rec->ip) {
+                                                found = 0;
+                                                break;
+                                        }
+                                if (found)
+                                        array[idx] = rec->ip;
+                                break;
+                        }
+                }
+        }
+        spin_unlock(&ftrace_lock);
+
+        return found ? 0 : -EINVAL;
+}
+
+static ssize_t
+ftrace_graph_write(struct file *file, const char __user *ubuf,
+                   size_t cnt, loff_t *ppos)
+{
+        unsigned char buffer[FTRACE_BUFF_MAX+1];
+        unsigned long *array;
+        size_t read = 0;
+        ssize_t ret;
+        int index = 0;
+        char ch;
+
+        if (!cnt || cnt < 0)
+                return 0;
+
+        mutex_lock(&graph_lock);
+
+        if (ftrace_graph_count >= FTRACE_GRAPH_MAX_FUNCS) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        if (file->f_mode & FMODE_READ) {
+                struct seq_file *m = file->private_data;
+                array = m->private;
+        } else
+                array = file->private_data;
+
+        ret = get_user(ch, ubuf++);
+        if (ret)
+                goto out;
+        read++;
+        cnt--;
+
+        /* skip white space */
+        while (cnt && isspace(ch)) {
+                ret = get_user(ch, ubuf++);
+                if (ret)
+                        goto out;
+                read++;
+                cnt--;
+        }
+
+        if (isspace(ch)) {
+                *ppos += read;
+                ret = read;
+                goto out;
+        }
+
+        while (cnt && !isspace(ch)) {
+                if (index < FTRACE_BUFF_MAX)
+                        buffer[index++] = ch;
+                else {
+                        ret = -EINVAL;
+                        goto out;
+                }
+                ret = get_user(ch, ubuf++);
+                if (ret)
+                        goto out;
+                read++;
+                cnt--;
+        }
+        buffer[index] = 0;
+
+        /* we allow only one at a time */
+        ret = ftrace_set_func(array, ftrace_graph_count, buffer);
+        if (ret)
+                goto out;
+
+        ftrace_graph_count++;
+
+        file->f_pos += read;
+
+        ret = read;
+ out:
+        mutex_unlock(&graph_lock);
+
+        return ret;
+}
+
+static const struct file_operations ftrace_graph_fops = {
+        .open = ftrace_graph_open,
+        .read = ftrace_graph_read,
+        .write = ftrace_graph_write,
+};
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+
+static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
+{
+        struct dentry *entry;
 
         entry = debugfs_create_file("available_filter_functions", 0444,
                                     d_tracer, NULL, &ftrace_avail_fops);
@@ -1268,12 +1572,20 @@ static __init int ftrace_init_debugfs(void)
                 pr_warning("Could not create debugfs "
                            "'set_ftrace_notrace' entry\n");
 
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+        entry = debugfs_create_file("set_graph_function", 0444, d_tracer,
+                                    NULL,
+                                    &ftrace_graph_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'set_graph_function' entry\n");
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+
         return 0;
 }
 
-fs_initcall(ftrace_init_debugfs);
-
-static int ftrace_convert_nops(unsigned long *start,
+static int ftrace_convert_nops(struct module *mod,
+                               unsigned long *start,
                                unsigned long *end)
 {
         unsigned long *p;
@@ -1284,23 +1596,32 @@ static int ftrace_convert_nops(unsigned long *start,
         p = start;
         while (p < end) {
                 addr = ftrace_call_adjust(*p++);
+                /*
+                 * Some architecture linkers will pad between
+                 * the different mcount_loc sections of different
+                 * object files to satisfy alignments.
+                 * Skip any NULL pointers.
+                 */
+                if (!addr)
+                        continue;
                 ftrace_record_ip(addr);
         }
 
         /* disable interrupts to prevent kstop machine */
         local_irq_save(flags);
-        ftrace_update_code();
+        ftrace_update_code(mod);
         local_irq_restore(flags);
         mutex_unlock(&ftrace_start_lock);
 
         return 0;
 }
 
-void ftrace_init_module(unsigned long *start, unsigned long *end)
+void ftrace_init_module(struct module *mod,
+                        unsigned long *start, unsigned long *end)
 {
         if (ftrace_disabled || start == end)
                 return;
-        ftrace_convert_nops(start, end);
+        ftrace_convert_nops(mod, start, end);
 }
 
 extern unsigned long __start_mcount_loc[];
@@ -1330,7 +1651,8 @@ void __init ftrace_init(void)
 
         last_ftrace_enabled = ftrace_enabled = 1;
 
-        ret = ftrace_convert_nops(__start_mcount_loc,
+        ret = ftrace_convert_nops(NULL,
+                                  __start_mcount_loc,
                                   __stop_mcount_loc);
 
         return;
@@ -1347,12 +1669,186 @@ static int __init ftrace_nodyn_init(void)
 }
 device_initcall(ftrace_nodyn_init);
 
-# define ftrace_startup()               do { } while (0)
-# define ftrace_shutdown()              do { } while (0)
+static inline int ftrace_init_dyn_debugfs(struct dentry *d_tracer) { return 0; }
+static inline void ftrace_startup_enable(int command) { }
+/* Keep as macros so we do not need to define the commands */
+# define ftrace_startup(command)        do { } while (0)
+# define ftrace_shutdown(command)       do { } while (0)
 # define ftrace_startup_sysctl()        do { } while (0)
 # define ftrace_shutdown_sysctl()       do { } while (0)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
+static ssize_t
+ftrace_pid_read(struct file *file, char __user *ubuf,
+                       size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        int r;
+
+        if (ftrace_pid_trace == ftrace_swapper_pid)
+                r = sprintf(buf, "swapper tasks\n");
+        else if (ftrace_pid_trace)
+                r = sprintf(buf, "%u\n", pid_nr(ftrace_pid_trace));
+        else
+                r = sprintf(buf, "no pid\n");
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static void clear_ftrace_swapper(void)
+{
+        struct task_struct *p;
+        int cpu;
+
+        get_online_cpus();
+        for_each_online_cpu(cpu) {
+                p = idle_task(cpu);
+                clear_tsk_trace_trace(p);
+        }
+        put_online_cpus();
+}
+
+static void set_ftrace_swapper(void)
+{
+        struct task_struct *p;
+        int cpu;
+
+        get_online_cpus();
+        for_each_online_cpu(cpu) {
+                p = idle_task(cpu);
+                set_tsk_trace_trace(p);
+        }
+        put_online_cpus();
+}
+
+static void clear_ftrace_pid(struct pid *pid)
+{
+        struct task_struct *p;
+
+        do_each_pid_task(pid, PIDTYPE_PID, p) {
+                clear_tsk_trace_trace(p);
+        } while_each_pid_task(pid, PIDTYPE_PID, p);
+        put_pid(pid);
+}
+
+static void set_ftrace_pid(struct pid *pid)
+{
+        struct task_struct *p;
+
+        do_each_pid_task(pid, PIDTYPE_PID, p) {
+                set_tsk_trace_trace(p);
+        } while_each_pid_task(pid, PIDTYPE_PID, p);
+}
+
+static void clear_ftrace_pid_task(struct pid **pid)
+{
+        if (*pid == ftrace_swapper_pid)
+                clear_ftrace_swapper();
+        else
+                clear_ftrace_pid(*pid);
+
+        *pid = NULL;
+}
+
+static void set_ftrace_pid_task(struct pid *pid)
+{
+        if (pid == ftrace_swapper_pid)
+                set_ftrace_swapper();
+        else
+                set_ftrace_pid(pid);
+}
+
+static ssize_t
+ftrace_pid_write(struct file *filp, const char __user *ubuf,
+                   size_t cnt, loff_t *ppos)
+{
+        struct pid *pid;
+        char buf[64];
+        long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtol(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        mutex_lock(&ftrace_start_lock);
+        if (val < 0) {
+                /* disable pid tracing */
+                if (!ftrace_pid_trace)
+                        goto out;
+
+                clear_ftrace_pid_task(&ftrace_pid_trace);
+
+        } else {
+                /* swapper task is special */
+                if (!val) {
+                        pid = ftrace_swapper_pid;
+                        if (pid == ftrace_pid_trace)
+                                goto out;
+                } else {
+                        pid = find_get_pid(val);
+
+                        if (pid == ftrace_pid_trace) {
+                                put_pid(pid);
+                                goto out;
+                        }
+                }
+
+                if (ftrace_pid_trace)
+                        clear_ftrace_pid_task(&ftrace_pid_trace);
+
+                if (!pid)
+                        goto out;
+
+                ftrace_pid_trace = pid;
+
+                set_ftrace_pid_task(ftrace_pid_trace);
+        }
+
+        /* update the function call */
+        ftrace_update_pid_func();
+        ftrace_startup_enable(0);
+
+ out:
+        mutex_unlock(&ftrace_start_lock);
+
+        return cnt;
+}
+
+static struct file_operations ftrace_pid_fops = {
+        .read = ftrace_pid_read,
+        .write = ftrace_pid_write,
+};
+
+static __init int ftrace_init_debugfs(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+        if (!d_tracer)
+                return 0;
+
+        ftrace_init_dyn_debugfs(d_tracer);
+
+        entry = debugfs_create_file("set_ftrace_pid", 0644, d_tracer,
+                                    NULL, &ftrace_pid_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'set_ftrace_pid' entry\n");
+        return 0;
+}
+
+fs_initcall(ftrace_init_debugfs);
+
 /**
  * ftrace_kill - kill ftrace
  *
@@ -1386,10 +1882,11 @@ int register_ftrace_function(struct ftrace_ops *ops)
                 return -1;
 
         mutex_lock(&ftrace_sysctl_lock);
+
         ret = __register_ftrace_function(ops);
-        ftrace_startup();
-        mutex_unlock(&ftrace_sysctl_lock);
+        ftrace_startup(0);
 
+        mutex_unlock(&ftrace_sysctl_lock);
         return ret;
 }
 
@@ -1405,7 +1902,7 @@ int unregister_ftrace_function(struct ftrace_ops *ops)
 
         mutex_lock(&ftrace_sysctl_lock);
         ret = __unregister_ftrace_function(ops);
-        ftrace_shutdown();
+        ftrace_shutdown(0);
         mutex_unlock(&ftrace_sysctl_lock);
 
         return ret;
@@ -1454,3 +1951,153 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
         return ret;
 }
 
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+
+static atomic_t ftrace_graph_active;
+
+int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)
+{
+        return 0;
+}
+
+/* The callbacks that hook a function */
+trace_func_graph_ret_t ftrace_graph_return =
+                        (trace_func_graph_ret_t)ftrace_stub;
+trace_func_graph_ent_t ftrace_graph_entry = ftrace_graph_entry_stub;
+
+/* Try to assign a return stack array on FTRACE_RETSTACK_ALLOC_SIZE tasks. */
+static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list)
+{
+        int i;
+        int ret = 0;
+        unsigned long flags;
+        int start = 0, end = FTRACE_RETSTACK_ALLOC_SIZE;
+        struct task_struct *g, *t;
+
+        for (i = 0; i < FTRACE_RETSTACK_ALLOC_SIZE; i++) {
+                ret_stack_list[i] = kmalloc(FTRACE_RETFUNC_DEPTH
+                                        * sizeof(struct ftrace_ret_stack),
+                                        GFP_KERNEL);
+                if (!ret_stack_list[i]) {
+                        start = 0;
+                        end = i;
+                        ret = -ENOMEM;
+                        goto free;
+                }
+        }
+
+        read_lock_irqsave(&tasklist_lock, flags);
+        do_each_thread(g, t) {
+                if (start == end) {
+                        ret = -EAGAIN;
+                        goto unlock;
+                }
+
+                if (t->ret_stack == NULL) {
+                        t->curr_ret_stack = -1;
+                        /* Make sure IRQs see the -1 first: */
+                        barrier();
+                        t->ret_stack = ret_stack_list[start++];
+                        atomic_set(&t->tracing_graph_pause, 0);
+                        atomic_set(&t->trace_overrun, 0);
+                }
+        } while_each_thread(g, t);
+
+unlock:
+        read_unlock_irqrestore(&tasklist_lock, flags);
+free:
+        for (i = start; i < end; i++)
+                kfree(ret_stack_list[i]);
+        return ret;
+}
+
+/* Allocate a return stack for each task */
+static int start_graph_tracing(void)
+{
+        struct ftrace_ret_stack **ret_stack_list;
+        int ret;
+
+        ret_stack_list = kmalloc(FTRACE_RETSTACK_ALLOC_SIZE *
+                                sizeof(struct ftrace_ret_stack *),
+                                GFP_KERNEL);
+
+        if (!ret_stack_list)
+                return -ENOMEM;
+
+        do {
+                ret = alloc_retstack_tasklist(ret_stack_list);
+        } while (ret == -EAGAIN);
+
+        kfree(ret_stack_list);
+        return ret;
+}
+
+int register_ftrace_graph(trace_func_graph_ret_t retfunc,
+                        trace_func_graph_ent_t entryfunc)
+{
+        int ret = 0;
+
+        mutex_lock(&ftrace_sysctl_lock);
+
+        atomic_inc(&ftrace_graph_active);
+        ret = start_graph_tracing();
+        if (ret) {
+                atomic_dec(&ftrace_graph_active);
+                goto out;
+        }
+
+        ftrace_graph_return = retfunc;
+        ftrace_graph_entry = entryfunc;
+
+        ftrace_startup(FTRACE_START_FUNC_RET);
+
+out:
+        mutex_unlock(&ftrace_sysctl_lock);
+        return ret;
+}
+
+void unregister_ftrace_graph(void)
+{
+        mutex_lock(&ftrace_sysctl_lock);
+
+        atomic_dec(&ftrace_graph_active);
+        ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
+        ftrace_graph_entry = ftrace_graph_entry_stub;
+        ftrace_shutdown(FTRACE_STOP_FUNC_RET);
+
+        mutex_unlock(&ftrace_sysctl_lock);
+}
+
+/* Allocate a return stack for newly created task */
+void ftrace_graph_init_task(struct task_struct *t)
+{
+        if (atomic_read(&ftrace_graph_active)) {
+                t->ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
+                                * sizeof(struct ftrace_ret_stack),
+                                GFP_KERNEL);
+                if (!t->ret_stack)
+                        return;
+                t->curr_ret_stack = -1;
+                atomic_set(&t->tracing_graph_pause, 0);
+                atomic_set(&t->trace_overrun, 0);
+        } else
+                t->ret_stack = NULL;
+}
+
+void ftrace_graph_exit_task(struct task_struct *t)
+{
+        struct ftrace_ret_stack *ret_stack = t->ret_stack;
+
+        t->ret_stack = NULL;
+        /* NULL must become visible to IRQs before we free it: */
+        barrier();
+
+        kfree(ret_stack);
+}
+
+void ftrace_graph_stop(void)
+{
+        ftrace_stop();
+}
+#endif
+
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 3f3380638646..7f69cfeaadf7 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -16,14 +16,100 @@
 #include <linux/list.h>
 #include <linux/fs.h>
 
+#include "trace.h"
+
+/*
+ * A fast way to enable or disable all ring buffers is to
+ * call tracing_on or tracing_off. Turning off the ring buffers
+ * prevents all ring buffers from being recorded to.
+ * Turning this switch on, makes it OK to write to the
+ * ring buffer, if the ring buffer is enabled itself.
+ *
+ * There's three layers that must be on in order to write
+ * to the ring buffer.
+ *
+ * 1) This global flag must be set.
+ * 2) The ring buffer must be enabled for recording.
+ * 3) The per cpu buffer must be enabled for recording.
+ *
+ * In case of an anomaly, this global flag has a bit set that
+ * will permantly disable all ring buffers.
+ */
+
+/*
+ * Global flag to disable all recording to ring buffers
+ *  This has two bits: ON, DISABLED
+ *
+ *  ON   DISABLED
+ * ---- ----------
+ *   0      0        : ring buffers are off
+ *   1      0        : ring buffers are on
+ *   X      1        : ring buffers are permanently disabled
+ */
+
+enum {
+        RB_BUFFERS_ON_BIT       = 0,
+        RB_BUFFERS_DISABLED_BIT = 1,
+};
+
+enum {
+        RB_BUFFERS_ON           = 1 << RB_BUFFERS_ON_BIT,
+        RB_BUFFERS_DISABLED     = 1 << RB_BUFFERS_DISABLED_BIT,
+};
+
+static long ring_buffer_flags __read_mostly = RB_BUFFERS_ON;
+
+/**
+ * tracing_on - enable all tracing buffers
+ *
+ * This function enables all tracing buffers that may have been
+ * disabled with tracing_off.
+ */
+void tracing_on(void)
+{
+        set_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
+}
+
+/**
+ * tracing_off - turn off all tracing buffers
+ *
+ * This function stops all tracing buffers from recording data.
+ * It does not disable any overhead the tracers themselves may
+ * be causing. This function simply causes all recording to
+ * the ring buffers to fail.
+ */
+void tracing_off(void)
+{
+        clear_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
+}
+
+/**
+ * tracing_off_permanent - permanently disable ring buffers
+ *
+ * This function, once called, will disable all ring buffers
+ * permanenty.
+ */
+void tracing_off_permanent(void)
+{
+        set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
+}
+
+#include "trace.h"
+
 /* Up this if you want to test the TIME_EXTENTS and normalization */
 #define DEBUG_SHIFT 0
 
 /* FIXME!!! */
 u64 ring_buffer_time_stamp(int cpu)
 {
+        u64 time;
+
+        preempt_disable_notrace();
         /* shift to debug/test normalization and TIME_EXTENTS */
-        return sched_clock() << DEBUG_SHIFT;
+        time = sched_clock() << DEBUG_SHIFT;
+        preempt_enable_notrace();
+
+        return time;
 }
 
 void ring_buffer_normalize_time_stamp(int cpu, u64 *ts)
@@ -109,20 +195,24 @@ void *ring_buffer_event_data(struct ring_buffer_event *event)
 #define TS_MASK         ((1ULL << TS_SHIFT) - 1)
 #define TS_DELTA_TEST   (~TS_MASK)
 
-/*
- * This hack stolen from mm/slob.c.
- * We can store per page timing information in the page frame of the page.
- * Thanks to Peter Zijlstra for suggesting this idea.
- */
-struct buffer_page {
+struct buffer_data_page {
         u64              time_stamp;    /* page time stamp */
-        local_t          write;         /* index for next write */
         local_t          commit;        /* write commited index */
+        unsigned char    data[];        /* data of buffer page */
+};
+
+struct buffer_page {
+        local_t          write;         /* index for next write */
         unsigned         read;          /* index for next read */
         struct list_head list;          /* list of free pages */
-        void *page;                     /* Actual data page */
+        struct buffer_data_page *page;  /* Actual data page */
 };
 
+static void rb_init_page(struct buffer_data_page *bpage)
+{
+        local_set(&bpage->commit, 0);
+}
+
 /*
  * Also stolen from mm/slob.c. Thanks to Mathieu Desnoyers for pointing
  * this issue out.
@@ -144,7 +234,7 @@ static inline int test_time_stamp(u64 delta)
         return 0;
 }
 
-#define BUF_PAGE_SIZE PAGE_SIZE
+#define BUF_PAGE_SIZE (PAGE_SIZE - sizeof(struct buffer_data_page))
 
 /*
  * head_page == tail_page && head == tail then buffer is empty.
@@ -152,7 +242,8 @@ static inline int test_time_stamp(u64 delta)
 struct ring_buffer_per_cpu {
         int                             cpu;
         struct ring_buffer              *buffer;
-        spinlock_t                      lock;
+        spinlock_t                      reader_lock; /* serialize readers */
+        raw_spinlock_t                  lock;
         struct lock_class_key           lock_key;
         struct list_head                pages;
         struct buffer_page              *head_page;     /* read from head */
@@ -186,32 +277,16 @@ struct ring_buffer_iter {
         u64                             read_stamp;
 };
 
+/* buffer may be either ring_buffer or ring_buffer_per_cpu */
 #define RB_WARN_ON(buffer, cond)                                \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                }                                               \
-        } while (0)
-
-#define RB_WARN_ON_RET(buffer, cond)                            \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                        return -1;                              \
-                }                                               \
-        } while (0)
-
-#define RB_WARN_ON_ONCE(buffer, cond)                           \
-        do {                                                    \
-                static int once;                                \
-                if (unlikely(cond) && !once) {                  \
-                        once++;                                 \
+        ({                                                      \
+                int _____ret = unlikely(cond);                  \
+                if (_____ret) {                                 \
                         atomic_inc(&buffer->record_disabled);   \
                         WARN_ON(1);                             \
                 }                                               \
-        } while (0)
+                _____ret;                                       \
+        })
 
 /**
  * check_pages - integrity check of buffer pages
@@ -223,16 +298,20 @@ struct ring_buffer_iter {
 static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
 {
         struct list_head *head = &cpu_buffer->pages;
-        struct buffer_page *page, *tmp;
+        struct buffer_page *bpage, *tmp;
 
-        RB_WARN_ON_RET(cpu_buffer, head->next->prev != head);
-        RB_WARN_ON_RET(cpu_buffer, head->prev->next != head);
+        if (RB_WARN_ON(cpu_buffer, head->next->prev != head))
+                return -1;
+        if (RB_WARN_ON(cpu_buffer, head->prev->next != head))
+                return -1;
 
-        list_for_each_entry_safe(page, tmp, head, list) {
-                RB_WARN_ON_RET(cpu_buffer,
-                               page->list.next->prev != &page->list);
-                RB_WARN_ON_RET(cpu_buffer,
-                               page->list.prev->next != &page->list);
+        list_for_each_entry_safe(bpage, tmp, head, list) {
+                if (RB_WARN_ON(cpu_buffer,
+                               bpage->list.next->prev != &bpage->list))
+                        return -1;
+                if (RB_WARN_ON(cpu_buffer,
+                               bpage->list.prev->next != &bpage->list))
+                        return -1;
         }
 
         return 0;
@@ -242,22 +321,23 @@ static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
                              unsigned nr_pages)
 {
         struct list_head *head = &cpu_buffer->pages;
-        struct buffer_page *page, *tmp;
+        struct buffer_page *bpage, *tmp;
         unsigned long addr;
         LIST_HEAD(pages);
         unsigned i;
 
         for (i = 0; i < nr_pages; i++) {
-                page = kzalloc_node(ALIGN(sizeof(*page), cache_line_size()),
+                bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                                     GFP_KERNEL, cpu_to_node(cpu_buffer->cpu));
-                if (!page)
+                if (!bpage)
                         goto free_pages;
-                list_add(&page->list, &pages);
+                list_add(&bpage->list, &pages);
 
                 addr = __get_free_page(GFP_KERNEL);
                 if (!addr)
                         goto free_pages;
-                page->page = (void *)addr;
+                bpage->page = (void *)addr;
+                rb_init_page(bpage->page);
         }
 
         list_splice(&pages, head);
@@ -267,9 +347,9 @@ static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
         return 0;
 
  free_pages:
-        list_for_each_entry_safe(page, tmp, &pages, list) {
-                list_del_init(&page->list);
-                free_buffer_page(page);
+        list_for_each_entry_safe(bpage, tmp, &pages, list) {
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
         }
         return -ENOMEM;
 }
@@ -278,7 +358,7 @@ static struct ring_buffer_per_cpu *
 rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
-        struct buffer_page *page;
+        struct buffer_page *bpage;
         unsigned long addr;
         int ret;
 
@@ -289,19 +369,21 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 
         cpu_buffer->cpu = cpu;
         cpu_buffer->buffer = buffer;
-        spin_lock_init(&cpu_buffer->lock);
+        spin_lock_init(&cpu_buffer->reader_lock);
+        cpu_buffer->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
         INIT_LIST_HEAD(&cpu_buffer->pages);
 
-        page = kzalloc_node(ALIGN(sizeof(*page), cache_line_size()),
+        bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                             GFP_KERNEL, cpu_to_node(cpu));
-        if (!page)
+        if (!bpage)
                 goto fail_free_buffer;
 
-        cpu_buffer->reader_page = page;
+        cpu_buffer->reader_page = bpage;
         addr = __get_free_page(GFP_KERNEL);
         if (!addr)
                 goto fail_free_reader;
-        page->page = (void *)addr;
+        bpage->page = (void *)addr;
+        rb_init_page(bpage->page);
 
         INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
 
@@ -326,14 +408,14 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)
 {
         struct list_head *head = &cpu_buffer->pages;
-        struct buffer_page *page, *tmp;
+        struct buffer_page *bpage, *tmp;
 
         list_del_init(&cpu_buffer->reader_page->list);
         free_buffer_page(cpu_buffer->reader_page);
 
-        list_for_each_entry_safe(page, tmp, head, list) {
-                list_del_init(&page->list);
-                free_buffer_page(page);
+        list_for_each_entry_safe(bpage, tmp, head, list) {
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
         }
         kfree(cpu_buffer);
 }
@@ -430,7 +512,7 @@ static void rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer);
 static void
 rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
 {
-        struct buffer_page *page;
+        struct buffer_page *bpage;
         struct list_head *p;
         unsigned i;
 
@@ -438,13 +520,15 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
         synchronize_sched();
 
         for (i = 0; i < nr_pages; i++) {
-                BUG_ON(list_empty(&cpu_buffer->pages));
+                if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                        return;
                 p = cpu_buffer->pages.next;
-                page = list_entry(p, struct buffer_page, list);
-                list_del_init(&page->list);
-                free_buffer_page(page);
+                bpage = list_entry(p, struct buffer_page, list);
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
         }
-        BUG_ON(list_empty(&cpu_buffer->pages));
+        if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                return;
 
         rb_reset_cpu(cpu_buffer);
 
@@ -458,7 +542,7 @@ static void
 rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
                 struct list_head *pages, unsigned nr_pages)
 {
-        struct buffer_page *page;
+        struct buffer_page *bpage;
         struct list_head *p;
         unsigned i;
 
@@ -466,11 +550,12 @@ rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
         synchronize_sched();
 
         for (i = 0; i < nr_pages; i++) {
-                BUG_ON(list_empty(pages));
+                if (RB_WARN_ON(cpu_buffer, list_empty(pages)))
+                        return;
                 p = pages->next;
-                page = list_entry(p, struct buffer_page, list);
-                list_del_init(&page->list);
-                list_add_tail(&page->list, &cpu_buffer->pages);
+                bpage = list_entry(p, struct buffer_page, list);
+                list_del_init(&bpage->list);
+                list_add_tail(&bpage->list, &cpu_buffer->pages);
         }
         rb_reset_cpu(cpu_buffer);
 
@@ -497,12 +582,18 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         unsigned nr_pages, rm_pages, new_pages;
-        struct buffer_page *page, *tmp;
+        struct buffer_page *bpage, *tmp;
         unsigned long buffer_size;
         unsigned long addr;
         LIST_HEAD(pages);
         int i, cpu;
 
+        /*
+         * Always succeed at resizing a non-existent buffer:
+         */
+        if (!buffer)
+                return size;
+
         size = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
         size *= BUF_PAGE_SIZE;
         buffer_size = buffer->pages * BUF_PAGE_SIZE;
@@ -521,7 +612,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
         if (size < buffer_size) {
 
                 /* easy case, just free pages */
-                BUG_ON(nr_pages >= buffer->pages);
+                if (RB_WARN_ON(buffer, nr_pages >= buffer->pages)) {
+                        mutex_unlock(&buffer->mutex);
+                        return -1;
+                }
 
                 rm_pages = buffer->pages - nr_pages;
 
@@ -540,21 +634,26 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
          * add these pages to the cpu_buffers. Otherwise we just free
          * them all and return -ENOMEM;
          */
-        BUG_ON(nr_pages <= buffer->pages);
+        if (RB_WARN_ON(buffer, nr_pages <= buffer->pages)) {
+                mutex_unlock(&buffer->mutex);
+                return -1;
+        }
+
         new_pages = nr_pages - buffer->pages;
 
         for_each_buffer_cpu(buffer, cpu) {
                 for (i = 0; i < new_pages; i++) {
-                        page = kzalloc_node(ALIGN(sizeof(*page),
+                        bpage = kzalloc_node(ALIGN(sizeof(*bpage),
                                                   cache_line_size()),
                                             GFP_KERNEL, cpu_to_node(cpu));
-                        if (!page)
+                        if (!bpage)
                                 goto free_pages;
-                        list_add(&page->list, &pages);
+                        list_add(&bpage->list, &pages);
                         addr = __get_free_page(GFP_KERNEL);
                         if (!addr)
                                 goto free_pages;
-                        page->page = (void *)addr;
+                        bpage->page = (void *)addr;
+                        rb_init_page(bpage->page);
                 }
         }
 
@@ -563,7 +662,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 rb_insert_pages(cpu_buffer, &pages, new_pages);
         }
 
-        BUG_ON(!list_empty(&pages));
+        if (RB_WARN_ON(buffer, !list_empty(&pages))) {
+                mutex_unlock(&buffer->mutex);
+                return -1;
+        }
 
  out:
         buffer->pages = nr_pages;
@@ -572,10 +674,11 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
         return size;
 
  free_pages:
-        list_for_each_entry_safe(page, tmp, &pages, list) {
-                list_del_init(&page->list);
-                free_buffer_page(page);
+        list_for_each_entry_safe(bpage, tmp, &pages, list) {
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
         }
+        mutex_unlock(&buffer->mutex);
         return -ENOMEM;
 }
 
@@ -584,9 +687,15 @@ static inline int rb_null_event(struct ring_buffer_event *event)
         return event->type == RINGBUF_TYPE_PADDING;
 }
 
-static inline void *__rb_page_index(struct buffer_page *page, unsigned index)
+static inline void *
+__rb_data_page_index(struct buffer_data_page *bpage, unsigned index)
 {
-        return page->page + index;
+        return bpage->data + index;
+}
+
+static inline void *__rb_page_index(struct buffer_page *bpage, unsigned index)
+{
+        return bpage->page->data + index;
 }
 
 static inline struct ring_buffer_event *
@@ -616,7 +725,7 @@ static inline unsigned rb_page_write(struct buffer_page *bpage)
 
 static inline unsigned rb_page_commit(struct buffer_page *bpage)
 {
-        return local_read(&bpage->commit);
+        return local_read(&bpage->page->commit);
 }
 
 /* Size is determined by what has been commited */
@@ -651,7 +760,8 @@ static void rb_update_overflow(struct ring_buffer_per_cpu *cpu_buffer)
              head += rb_event_length(event)) {
 
                 event = __rb_page_index(cpu_buffer->head_page, head);
-                BUG_ON(rb_null_event(event));
+                if (RB_WARN_ON(cpu_buffer, rb_null_event(event)))
+                        return;
                 /* Only count data entries */
                 if (event->type != RINGBUF_TYPE_DATA)
                         continue;
@@ -661,14 +771,14 @@ static void rb_update_overflow(struct ring_buffer_per_cpu *cpu_buffer)
 }
 
 static inline void rb_inc_page(struct ring_buffer_per_cpu *cpu_buffer,
-                               struct buffer_page **page)
+                               struct buffer_page **bpage)
 {
-        struct list_head *p = (*page)->list.next;
+        struct list_head *p = (*bpage)->list.next;
 
         if (p == &cpu_buffer->pages)
                 p = p->next;
 
-        *page = list_entry(p, struct buffer_page, list);
+        *bpage = list_entry(p, struct buffer_page, list);
 }
 
 static inline unsigned
@@ -704,16 +814,18 @@ rb_set_commit_event(struct ring_buffer_per_cpu *cpu_buffer,
         addr &= PAGE_MASK;
 
         while (cpu_buffer->commit_page->page != (void *)addr) {
-                RB_WARN_ON(cpu_buffer,
-                           cpu_buffer->commit_page == cpu_buffer->tail_page);
-                cpu_buffer->commit_page->commit =
+                if (RB_WARN_ON(cpu_buffer,
+                          cpu_buffer->commit_page == cpu_buffer->tail_page))
+                        return;
+                cpu_buffer->commit_page->page->commit =
                         cpu_buffer->commit_page->write;
                 rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
-                cpu_buffer->write_stamp = cpu_buffer->commit_page->time_stamp;
+                cpu_buffer->write_stamp =
+                        cpu_buffer->commit_page->page->time_stamp;
         }
 
         /* Now set the commit to the event's index */
-        local_set(&cpu_buffer->commit_page->commit, index);
+        local_set(&cpu_buffer->commit_page->page->commit, index);
 }
 
 static inline void
@@ -728,16 +840,17 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
          * assign the commit to the tail.
          */
         while (cpu_buffer->commit_page != cpu_buffer->tail_page) {
-                cpu_buffer->commit_page->commit =
+                cpu_buffer->commit_page->page->commit =
                         cpu_buffer->commit_page->write;
                 rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
-                cpu_buffer->write_stamp = cpu_buffer->commit_page->time_stamp;
+                cpu_buffer->write_stamp =
+                        cpu_buffer->commit_page->page->time_stamp;
                 /* add barrier to keep gcc from optimizing too much */
                 barrier();
         }
         while (rb_commit_index(cpu_buffer) !=
                rb_page_write(cpu_buffer->commit_page)) {
-                cpu_buffer->commit_page->commit =
+                cpu_buffer->commit_page->page->commit =
                         cpu_buffer->commit_page->write;
                 barrier();
         }
@@ -745,7 +858,7 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
 
 static void rb_reset_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
 {
-        cpu_buffer->read_stamp = cpu_buffer->reader_page->time_stamp;
+        cpu_buffer->read_stamp = cpu_buffer->reader_page->page->time_stamp;
         cpu_buffer->reader_page->read = 0;
 }
 
@@ -764,7 +877,7 @@ static inline void rb_inc_iter(struct ring_buffer_iter *iter)
         else
                 rb_inc_page(cpu_buffer, &iter->head_page);
 
-        iter->read_stamp = iter->head_page->time_stamp;
+        iter->read_stamp = iter->head_page->page->time_stamp;
         iter->head = 0;
 }
 
@@ -852,7 +965,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
         if (write > BUF_PAGE_SIZE) {
                 struct buffer_page *next_page = tail_page;
 
-                spin_lock_irqsave(&cpu_buffer->lock, flags);
+                local_irq_save(flags);
+                __raw_spin_lock(&cpu_buffer->lock);
 
                 rb_inc_page(cpu_buffer, &next_page);
 
@@ -860,7 +974,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                 reader_page = cpu_buffer->reader_page;
 
                 /* we grabbed the lock before incrementing */
-                RB_WARN_ON(cpu_buffer, next_page == reader_page);
+                if (RB_WARN_ON(cpu_buffer, next_page == reader_page))
+                        goto out_unlock;
 
                 /*
                  * If for some reason, we had an interrupt storm that made
@@ -898,12 +1013,12 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                  */
                 if (tail_page == cpu_buffer->tail_page) {
                         local_set(&next_page->write, 0);
-                        local_set(&next_page->commit, 0);
+                        local_set(&next_page->page->commit, 0);
                         cpu_buffer->tail_page = next_page;
 
                         /* reread the time stamp */
                         *ts = ring_buffer_time_stamp(cpu_buffer->cpu);
-                        cpu_buffer->tail_page->time_stamp = *ts;
+                        cpu_buffer->tail_page->page->time_stamp = *ts;
                 }
 
                 /*
@@ -928,7 +1043,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                         rb_set_commit_to_write(cpu_buffer);
                 }
 
-                spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+                __raw_spin_unlock(&cpu_buffer->lock);
+                local_irq_restore(flags);
 
                 /* fail and let the caller try again */
                 return ERR_PTR(-EAGAIN);
@@ -936,7 +1052,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
 
         /* We reserved something on the buffer */
 
-        BUG_ON(write > BUF_PAGE_SIZE);
+        if (RB_WARN_ON(cpu_buffer, write > BUF_PAGE_SIZE))
+                return NULL;
 
         event = __rb_page_index(tail_page, tail);
         rb_update_event(event, type, length);
@@ -946,12 +1063,13 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
          * this page's time stamp.
          */
         if (!tail && rb_is_commit(cpu_buffer, event))
-                cpu_buffer->commit_page->time_stamp = *ts;
+                cpu_buffer->commit_page->page->time_stamp = *ts;
 
         return event;
 
  out_unlock:
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        local_irq_restore(flags);
         return NULL;
 }
 
@@ -996,7 +1114,7 @@ rb_add_time_stamp(struct ring_buffer_per_cpu *cpu_buffer,
                         event->time_delta = *delta & TS_MASK;
                         event->array[0] = *delta >> TS_SHIFT;
                 } else {
-                        cpu_buffer->commit_page->time_stamp = *ts;
+                        cpu_buffer->commit_page->page->time_stamp = *ts;
                         event->time_delta = 0;
                         event->array[0] = 0;
                 }
@@ -1034,10 +1152,8 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
          * storm or we have something buggy.
          * Bail!
          */
-        if (unlikely(++nr_loops > 1000)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 1000))
                 return NULL;
-        }
 
         ts = ring_buffer_time_stamp(cpu_buffer->cpu);
 
@@ -1060,7 +1176,7 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
 
                 /* Did the write stamp get updated already? */
                 if (unlikely(ts < cpu_buffer->write_stamp))
-                        goto again;
+                        delta = 0;
 
                 if (test_time_stamp(delta)) {
 
@@ -1133,12 +1249,14 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
         struct ring_buffer_event *event;
         int cpu, resched;
 
+        if (ring_buffer_flags != RB_BUFFERS_ON)
+                return NULL;
+
         if (atomic_read(&buffer->record_disabled))
                 return NULL;
 
         /* If we are tracing schedule, we don't want to recurse */
-        resched = need_resched();
-        preempt_disable_notrace();
+        resched = ftrace_preempt_disable();
 
         cpu = raw_smp_processor_id();
 
@@ -1169,10 +1287,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
         return event;
 
  out:
-        if (resched)
-                preempt_enable_notrace();
-        else
-                preempt_enable_notrace();
+        ftrace_preempt_enable(resched);
         return NULL;
 }
 
@@ -1214,12 +1329,9 @@ int ring_buffer_unlock_commit(struct ring_buffer *buffer,
         /*
          * Only the last preempt count needs to restore preemption.
          */
-        if (preempt_count() == 1) {
-                if (per_cpu(rb_need_resched, cpu))
-                        preempt_enable_no_resched_notrace();
-                else
-                        preempt_enable_notrace();
-        } else
+        if (preempt_count() == 1)
+                ftrace_preempt_enable(per_cpu(rb_need_resched, cpu));
+        else
                 preempt_enable_no_resched_notrace();
 
         return 0;
@@ -1249,11 +1361,13 @@ int ring_buffer_write(struct ring_buffer *buffer,
         int ret = -EBUSY;
         int cpu, resched;
 
+        if (ring_buffer_flags != RB_BUFFERS_ON)
+                return -EBUSY;
+
         if (atomic_read(&buffer->record_disabled))
                 return -EBUSY;
 
-        resched = need_resched();
-        preempt_disable_notrace();
+        resched = ftrace_preempt_disable();
 
         cpu = raw_smp_processor_id();
 
@@ -1279,10 +1393,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
 
         ret = 0;
  out:
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
+        ftrace_preempt_enable(resched);
 
         return ret;
 }
@@ -1441,14 +1552,7 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
         return overruns;
 }
 
-/**
- * ring_buffer_iter_reset - reset an iterator
- * @iter: The iterator to reset
- *
- * Resets the iterator, so that it will start from the beginning
- * again.
- */
-void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
+static void rb_iter_reset(struct ring_buffer_iter *iter)
 {
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
 
@@ -1463,7 +1567,24 @@ void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
         if (iter->head)
                 iter->read_stamp = cpu_buffer->read_stamp;
         else
-                iter->read_stamp = iter->head_page->time_stamp;
+                iter->read_stamp = iter->head_page->page->time_stamp;
+}
+
+/**
+ * ring_buffer_iter_reset - reset an iterator
+ * @iter: The iterator to reset
+ *
+ * Resets the iterator, so that it will start from the beginning
+ * again.
+ */
+void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        rb_iter_reset(iter);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 
 /**
@@ -1549,7 +1670,8 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         unsigned long flags;
         int nr_loops = 0;
 
-        spin_lock_irqsave(&cpu_buffer->lock, flags);
+        local_irq_save(flags);
+        __raw_spin_lock(&cpu_buffer->lock);
 
  again:
         /*
@@ -1558,8 +1680,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
          * a case where we will loop three times. There should be no
          * reason to loop four times (that I know of).
          */
-        if (unlikely(++nr_loops > 3)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 3)) {
                 reader = NULL;
                 goto out;
         }
@@ -1571,8 +1692,9 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
                 goto out;
 
         /* Never should we have an index greater than the size */
-        RB_WARN_ON(cpu_buffer,
-                   cpu_buffer->reader_page->read > rb_page_size(reader));
+        if (RB_WARN_ON(cpu_buffer,
+                       cpu_buffer->reader_page->read > rb_page_size(reader)))
+                goto out;
 
         /* check if we caught up to the tail */
         reader = NULL;
@@ -1589,7 +1711,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         cpu_buffer->reader_page->list.prev = reader->list.prev;
 
         local_set(&cpu_buffer->reader_page->write, 0);
-        local_set(&cpu_buffer->reader_page->commit, 0);
+        local_set(&cpu_buffer->reader_page->page->commit, 0);
 
         /* Make the reader page now replace the head */
         reader->list.prev->next = &cpu_buffer->reader_page->list;
@@ -1611,7 +1733,8 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         goto again;
 
  out:
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        local_irq_restore(flags);
 
         return reader;
 }
@@ -1625,7 +1748,8 @@ static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer)
         reader = rb_get_reader_page(cpu_buffer);
 
         /* This function should not be called when buffer is empty */
-        BUG_ON(!reader);
+        if (RB_WARN_ON(cpu_buffer, !reader))
+                return;
 
         event = rb_reader_event(cpu_buffer);
 
@@ -1652,7 +1776,9 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
          * Check if we are at the end of the buffer.
          */
         if (iter->head >= rb_page_size(iter->head_page)) {
-                BUG_ON(iter->head_page == cpu_buffer->commit_page);
+                if (RB_WARN_ON(buffer,
+                               iter->head_page == cpu_buffer->commit_page))
+                        return;
                 rb_inc_iter(iter);
                 return;
         }
@@ -1665,8 +1791,10 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
          * This should not be called to advance the header if we are
          * at the tail of the buffer.
          */
-        BUG_ON((iter->head_page == cpu_buffer->commit_page) &&
-               (iter->head + length > rb_commit_index(cpu_buffer)));
+        if (RB_WARN_ON(cpu_buffer,
+                       (iter->head_page == cpu_buffer->commit_page) &&
+                       (iter->head + length > rb_commit_index(cpu_buffer))))
+                return;
 
         rb_update_iter_read_stamp(iter, event);
 
@@ -1678,17 +1806,8 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
                 rb_advance_iter(iter);
 }
 
-/**
- * ring_buffer_peek - peek at the next event to be read
- * @buffer: The ring buffer to read
- * @cpu: The cpu to peak at
- * @ts: The timestamp counter of this event.
- *
- * This will return the event that will be read next, but does
- * not consume the data.
- */
-struct ring_buffer_event *
-ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
+static struct ring_buffer_event *
+rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
@@ -1709,10 +1828,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
          * can have.  Nesting 10 deep of interrupts is clearly
          * an anomaly.
          */
-        if (unlikely(++nr_loops > 10)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 10))
                 return NULL;
-        }
 
         reader = rb_get_reader_page(cpu_buffer);
         if (!reader)
@@ -1750,16 +1867,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         return NULL;
 }
 
-/**
- * ring_buffer_iter_peek - peek at the next event to be read
- * @iter: The ring buffer iterator
- * @ts: The timestamp counter of this event.
- *
- * This will return the event that will be read next, but does
- * not increment the iterator.
- */
-struct ring_buffer_event *
-ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
+static struct ring_buffer_event *
+rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 {
         struct ring_buffer *buffer;
         struct ring_buffer_per_cpu *cpu_buffer;
@@ -1781,10 +1890,8 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
          * can have. Nesting 10 deep of interrupts is clearly
          * an anomaly.
          */
-        if (unlikely(++nr_loops > 10)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 10))
                 return NULL;
-        }
 
         if (rb_per_cpu_empty(cpu_buffer))
                 return NULL;
@@ -1821,6 +1928,51 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 }
 
 /**
+ * ring_buffer_peek - peek at the next event to be read
+ * @buffer: The ring buffer to read
+ * @cpu: The cpu to peak at
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not consume the data.
+ */
+struct ring_buffer_event *
+ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
+        struct ring_buffer_event *event;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_buffer_peek(buffer, cpu, ts);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+        return event;
+}
+
+/**
+ * ring_buffer_iter_peek - peek at the next event to be read
+ * @iter: The ring buffer iterator
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not increment the iterator.
+ */
+struct ring_buffer_event *
+ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        struct ring_buffer_event *event;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_iter_peek(iter, ts);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+        return event;
+}
+
+/**
  * ring_buffer_consume - return an event and consume it
  * @buffer: The ring buffer to get the next event from
  *
@@ -1831,19 +1983,24 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 struct ring_buffer_event *
 ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
-        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
         struct ring_buffer_event *event;
+        unsigned long flags;
 
         if (!cpu_isset(cpu, buffer->cpumask))
                 return NULL;
 
-        event = ring_buffer_peek(buffer, cpu, ts);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+
+        event = rb_buffer_peek(buffer, cpu, ts);
         if (!event)
-                return NULL;
+                goto out;
 
-        cpu_buffer = buffer->buffers[cpu];
         rb_advance_reader(cpu_buffer);
 
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
         return event;
 }
 
@@ -1880,9 +2037,11 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
         atomic_inc(&cpu_buffer->record_disabled);
         synchronize_sched();
 
-        spin_lock_irqsave(&cpu_buffer->lock, flags);
-        ring_buffer_iter_reset(iter);
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        __raw_spin_lock(&cpu_buffer->lock);
+        rb_iter_reset(iter);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return iter;
 }
@@ -1914,12 +2073,17 @@ struct ring_buffer_event *
 ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
 {
         struct ring_buffer_event *event;
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        unsigned long flags;
 
-        event = ring_buffer_iter_peek(iter, ts);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_iter_peek(iter, ts);
         if (!event)
-                return NULL;
+                goto out;
 
         rb_advance_iter(iter);
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return event;
 }
@@ -1939,7 +2103,7 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
         cpu_buffer->head_page
                 = list_entry(cpu_buffer->pages.next, struct buffer_page, list);
         local_set(&cpu_buffer->head_page->write, 0);
-        local_set(&cpu_buffer->head_page->commit, 0);
+        local_set(&cpu_buffer->head_page->page->commit, 0);
 
         cpu_buffer->head_page->read = 0;
 
@@ -1948,7 +2112,7 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
 
         INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
         local_set(&cpu_buffer->reader_page->write, 0);
-        local_set(&cpu_buffer->reader_page->commit, 0);
+        local_set(&cpu_buffer->reader_page->page->commit, 0);
         cpu_buffer->reader_page->read = 0;
 
         cpu_buffer->overrun = 0;
@@ -1968,11 +2132,15 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         if (!cpu_isset(cpu, buffer->cpumask))
                 return;
 
-        spin_lock_irqsave(&cpu_buffer->lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+
+        __raw_spin_lock(&cpu_buffer->lock);
 
         rb_reset_cpu(cpu_buffer);
 
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        __raw_spin_unlock(&cpu_buffer->lock);
+
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 
 /**
@@ -2070,3 +2238,233 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         return 0;
 }
 
+static void rb_remove_entries(struct ring_buffer_per_cpu *cpu_buffer,
+                              struct buffer_data_page *bpage)
+{
+        struct ring_buffer_event *event;
+        unsigned long head;
+
+        __raw_spin_lock(&cpu_buffer->lock);
+        for (head = 0; head < local_read(&bpage->commit);
+             head += rb_event_length(event)) {
+
+                event = __rb_data_page_index(bpage, head);
+                if (RB_WARN_ON(cpu_buffer, rb_null_event(event)))
+                        return;
+                /* Only count data entries */
+                if (event->type != RINGBUF_TYPE_DATA)
+                        continue;
+                cpu_buffer->entries--;
+        }
+        __raw_spin_unlock(&cpu_buffer->lock);
+}
+
+/**
+ * ring_buffer_alloc_read_page - allocate a page to read from buffer
+ * @buffer: the buffer to allocate for.
+ *
+ * This function is used in conjunction with ring_buffer_read_page.
+ * When reading a full page from the ring buffer, these functions
+ * can be used to speed up the process. The calling function should
+ * allocate a few pages first with this function. Then when it
+ * needs to get pages from the ring buffer, it passes the result
+ * of this function into ring_buffer_read_page, which will swap
+ * the page that was allocated, with the read page of the buffer.
+ *
+ * Returns:
+ *  The page allocated, or NULL on error.
+ */
+void *ring_buffer_alloc_read_page(struct ring_buffer *buffer)
+{
+        unsigned long addr;
+        struct buffer_data_page *bpage;
+
+        addr = __get_free_page(GFP_KERNEL);
+        if (!addr)
+                return NULL;
+
+        bpage = (void *)addr;
+
+        return bpage;
+}
+
+/**
+ * ring_buffer_free_read_page - free an allocated read page
+ * @buffer: the buffer the page was allocate for
+ * @data: the page to free
+ *
+ * Free a page allocated from ring_buffer_alloc_read_page.
+ */
+void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data)
+{
+        free_page((unsigned long)data);
+}
+
+/**
+ * ring_buffer_read_page - extract a page from the ring buffer
+ * @buffer: buffer to extract from
+ * @data_page: the page to use allocated from ring_buffer_alloc_read_page
+ * @cpu: the cpu of the buffer to extract
+ * @full: should the extraction only happen when the page is full.
+ *
+ * This function will pull out a page from the ring buffer and consume it.
+ * @data_page must be the address of the variable that was returned
+ * from ring_buffer_alloc_read_page. This is because the page might be used
+ * to swap with a page in the ring buffer.
+ *
+ * for example:
+ *      rpage = ring_buffer_alloc_page(buffer);
+ *      if (!rpage)
+ *              return error;
+ *      ret = ring_buffer_read_page(buffer, &rpage, cpu, 0);
+ *      if (ret)
+ *              process_page(rpage);
+ *
+ * When @full is set, the function will not return true unless
+ * the writer is off the reader page.
+ *
+ * Note: it is up to the calling functions to handle sleeps and wakeups.
+ *  The ring buffer can be used anywhere in the kernel and can not
+ *  blindly call wake_up. The layer that uses the ring buffer must be
+ *  responsible for that.
+ *
+ * Returns:
+ *  1 if data has been transferred
+ *  0 if no data has been transferred.
+ */
+int ring_buffer_read_page(struct ring_buffer *buffer,
+                            void **data_page, int cpu, int full)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
+        struct ring_buffer_event *event;
+        struct buffer_data_page *bpage;
+        unsigned long flags;
+        int ret = 0;
+
+        if (!data_page)
+                return 0;
+
+        bpage = *data_page;
+        if (!bpage)
+                return 0;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+
+        /*
+         * rb_buffer_peek will get the next ring buffer if
+         * the current reader page is empty.
+         */
+        event = rb_buffer_peek(buffer, cpu, NULL);
+        if (!event)
+                goto out;
+
+        /* check for data */
+        if (!local_read(&cpu_buffer->reader_page->page->commit))
+                goto out;
+        /*
+         * If the writer is already off of the read page, then simply
+         * switch the read page with the given page. Otherwise
+         * we need to copy the data from the reader to the writer.
+         */
+        if (cpu_buffer->reader_page == cpu_buffer->commit_page) {
+                unsigned int read = cpu_buffer->reader_page->read;
+
+                if (full)
+                        goto out;
+                /* The writer is still on the reader page, we must copy */
+                bpage = cpu_buffer->reader_page->page;
+                memcpy(bpage->data,
+                       cpu_buffer->reader_page->page->data + read,
+                       local_read(&bpage->commit) - read);
+
+                /* consume what was read */
+                cpu_buffer->reader_page += read;
+
+        } else {
+                /* swap the pages */
+                rb_init_page(bpage);
+                bpage = cpu_buffer->reader_page->page;
+                cpu_buffer->reader_page->page = *data_page;
+                cpu_buffer->reader_page->read = 0;
+                *data_page = bpage;
+        }
+        ret = 1;
+
+        /* update the entry counter */
+        rb_remove_entries(cpu_buffer, bpage);
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+        return ret;
+}
+
+static ssize_t
+rb_simple_read(struct file *filp, char __user *ubuf,
+               size_t cnt, loff_t *ppos)
+{
+        long *p = filp->private_data;
+        char buf[64];
+        int r;
+
+        if (test_bit(RB_BUFFERS_DISABLED_BIT, p))
+                r = sprintf(buf, "permanently disabled\n");
+        else
+                r = sprintf(buf, "%d\n", test_bit(RB_BUFFERS_ON_BIT, p));
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static ssize_t
+rb_simple_write(struct file *filp, const char __user *ubuf,
+                size_t cnt, loff_t *ppos)
+{
+        long *p = filp->private_data;
+        char buf[64];
+        long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        if (val)
+                set_bit(RB_BUFFERS_ON_BIT, p);
+        else
+                clear_bit(RB_BUFFERS_ON_BIT, p);
+
+        (*ppos)++;
+
+        return cnt;
+}
+
+static struct file_operations rb_simple_fops = {
+        .open           = tracing_open_generic,
+        .read           = rb_simple_read,
+        .write          = rb_simple_write,
+};
+
+
+static __init int rb_init_debugfs(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+
+        entry = debugfs_create_file("tracing_on", 0644, d_tracer,
+                                    &ring_buffer_flags, &rb_simple_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'tracing_on' entry\n");
+
+        return 0;
+}
+
+fs_initcall(rb_init_debugfs);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 9f3b478f9171..8ebe0070c47a 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -30,6 +30,7 @@
 #include <linux/gfp.h>
 #include <linux/fs.h>
 #include <linux/kprobes.h>
+#include <linux/seq_file.h>
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
@@ -43,6 +44,38 @@
 unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
 unsigned long __read_mostly     tracing_thresh;
 
+/*
+ * We need to change this state when a selftest is running.
+ * A selftest will lurk into the ring-buffer to count the
+ * entries inserted during the selftest although some concurrent
+ * insertions into the ring-buffer such as ftrace_printk could occurred
+ * at the same time, giving false positive or negative results.
+ */
+static bool __read_mostly tracing_selftest_running;
+
+/* For tracers that don't implement custom flags */
+static struct tracer_opt dummy_tracer_opt[] = {
+        { }
+};
+
+static struct tracer_flags dummy_tracer_flags = {
+        .val = 0,
+        .opts = dummy_tracer_opt
+};
+
+static int dummy_set_flag(u32 old_flags, u32 bit, int set)
+{
+        return 0;
+}
+
+/*
+ * Kill all tracing for good (never come back).
+ * It is initialized to 1 but will turn to zero if the initialization
+ * of the tracer is successful. But that is the only place that sets
+ * this back to zero.
+ */
+int tracing_disabled = 1;
+
 static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
 
 static inline void ftrace_disable_cpu(void)
@@ -62,7 +95,36 @@ static cpumask_t __read_mostly		tracing_buffer_mask;
 #define for_each_tracing_cpu(cpu)       \
         for_each_cpu_mask(cpu, tracing_buffer_mask)
 
-static int tracing_disabled = 1;
+/*
+ * ftrace_dump_on_oops - variable to dump ftrace buffer on oops
+ *
+ * If there is an oops (or kernel panic) and the ftrace_dump_on_oops
+ * is set, then ftrace_dump is called. This will output the contents
+ * of the ftrace buffers to the console.  This is very useful for
+ * capturing traces that lead to crashes and outputing it to a
+ * serial console.
+ *
+ * It is default off, but you can enable it with either specifying
+ * "ftrace_dump_on_oops" in the kernel command line, or setting
+ * /proc/sys/kernel/ftrace_dump_on_oops to true.
+ */
+int ftrace_dump_on_oops;
+
+static int tracing_set_tracer(char *buf);
+
+static int __init set_ftrace(char *str)
+{
+        tracing_set_tracer(str);
+        return 1;
+}
+__setup("ftrace", set_ftrace);
+
+static int __init set_ftrace_dump_on_oops(char *str)
+{
+        ftrace_dump_on_oops = 1;
+        return 1;
+}
+__setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
 
 long
 ns2usecs(cycle_t nsec)
@@ -112,6 +174,19 @@ static DEFINE_PER_CPU(struct trace_array_cpu, max_data);
 /* tracer_enabled is used to toggle activation of a tracer */
 static int                      tracer_enabled = 1;
 
+/**
+ * tracing_is_enabled - return tracer_enabled status
+ *
+ * This function is used by other tracers to know the status
+ * of the tracer_enabled flag.  Tracers may use this function
+ * to know if it should enable their features when starting
+ * up. See irqsoff tracer for an example (start_irqsoff_tracer).
+ */
+int tracing_is_enabled(void)
+{
+        return tracer_enabled;
+}
+
 /* function tracing enabled */
 int                             ftrace_function_enabled;
 
@@ -153,8 +228,9 @@ static DEFINE_MUTEX(trace_types_lock);
 /* trace_wait is a waitqueue for tasks blocked on trace_poll */
 static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 
-/* trace_flags holds iter_ctrl options */
-unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
+/* trace_flags holds trace_options default values */
+unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
+        TRACE_ITER_ANNOTATE;
 
 /**
  * trace_wake_up - wake up tasks waiting for trace input
@@ -193,13 +269,6 @@ unsigned long nsecs_to_usecs(unsigned long nsecs)
         return nsecs / 1000;
 }
 
-/*
- * TRACE_ITER_SYM_MASK masks the options in trace_flags that
- * control the output of kernel symbols.
- */
-#define TRACE_ITER_SYM_MASK \
-        (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
-
 /* These must match the bit postions in trace_iterator_flags */
 static const char *trace_options[] = {
         "print-parent",
@@ -213,6 +282,11 @@ static const char *trace_options[] = {
         "stacktrace",
         "sched-tree",
         "ftrace_printk",
+        "ftrace_preempt",
+        "branch",
+        "annotate",
+        "userstacktrace",
+        "sym-userobj",
         NULL
 };
 
@@ -359,6 +433,28 @@ trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)
         return trace_seq_putmem(s, hex, j);
 }
 
+static int
+trace_seq_path(struct trace_seq *s, struct path *path)
+{
+        unsigned char *p;
+
+        if (s->len >= (PAGE_SIZE - 1))
+                return 0;
+        p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
+        if (!IS_ERR(p)) {
+                p = mangle_path(s->buffer + s->len, p, "\n");
+                if (p) {
+                        s->len = p - s->buffer;
+                        return 1;
+                }
+        } else {
+                s->buffer[s->len++] = '?';
+                return 1;
+        }
+
+        return 0;
+}
+
 static void
 trace_seq_reset(struct trace_seq *s)
 {
@@ -470,7 +566,17 @@ int register_tracer(struct tracer *type)
                 return -1;
         }
 
+        /*
+         * When this gets called we hold the BKL which means that
+         * preemption is disabled. Various trace selftests however
+         * need to disable and enable preemption for successful tests.
+         * So we drop the BKL here and grab it after the tests again.
+         */
+        unlock_kernel();
         mutex_lock(&trace_types_lock);
+
+        tracing_selftest_running = true;
+
         for (t = trace_types; t; t = t->next) {
                 if (strcmp(type->name, t->name) == 0) {
                         /* already found */
@@ -481,12 +587,20 @@ int register_tracer(struct tracer *type)
                 }
         }
 
+        if (!type->set_flag)
+                type->set_flag = &dummy_set_flag;
+        if (!type->flags)
+                type->flags = &dummy_tracer_flags;
+        else
+                if (!type->flags->opts)
+                        type->flags->opts = dummy_tracer_opt;
+
 #ifdef CONFIG_FTRACE_STARTUP_TEST
         if (type->selftest) {
                 struct tracer *saved_tracer = current_trace;
                 struct trace_array *tr = &global_trace;
-                int saved_ctrl = tr->ctrl;
                 int i;
+
                 /*
                  * Run a selftest on this tracer.
                  * Here we reset the trace buffer, and set the current
@@ -494,25 +608,23 @@ int register_tracer(struct tracer *type)
                  * internal tracing to verify that everything is in order.
                  * If we fail, we do not register this tracer.
                  */
-                for_each_tracing_cpu(i) {
+                for_each_tracing_cpu(i)
                         tracing_reset(tr, i);
-                }
+
                 current_trace = type;
-                tr->ctrl = 0;
                 /* the test is responsible for initializing and enabling */
                 pr_info("Testing tracer %s: ", type->name);
                 ret = type->selftest(type, tr);
                 /* the test is responsible for resetting too */
                 current_trace = saved_tracer;
-                tr->ctrl = saved_ctrl;
                 if (ret) {
                         printk(KERN_CONT "FAILED!\n");
                         goto out;
                 }
                 /* Only reset on passing, to avoid touching corrupted buffers */
-                for_each_tracing_cpu(i) {
+                for_each_tracing_cpu(i)
                         tracing_reset(tr, i);
-                }
+
                 printk(KERN_CONT "PASSED\n");
         }
 #endif
@@ -524,7 +636,9 @@ int register_tracer(struct tracer *type)
                 max_tracer_type_len = len;
 
  out:
+        tracing_selftest_running = false;
         mutex_unlock(&trace_types_lock);
+        lock_kernel();
 
         return ret;
 }
@@ -581,6 +695,91 @@ static void trace_init_cmdlines(void)
         cmdline_idx = 0;
 }
 
+static int trace_stop_count;
+static DEFINE_SPINLOCK(tracing_start_lock);
+
+/**
+ * ftrace_off_permanent - disable all ftrace code permanently
+ *
+ * This should only be called when a serious anomally has
+ * been detected.  This will turn off the function tracing,
+ * ring buffers, and other tracing utilites. It takes no
+ * locks and can be called from any context.
+ */
+void ftrace_off_permanent(void)
+{
+        tracing_disabled = 1;
+        ftrace_stop();
+        tracing_off_permanent();
+}
+
+/**
+ * tracing_start - quick start of the tracer
+ *
+ * If tracing is enabled but was stopped by tracing_stop,
+ * this will start the tracer back up.
+ */
+void tracing_start(void)
+{
+        struct ring_buffer *buffer;
+        unsigned long flags;
+
+        if (tracing_disabled)
+                return;
+
+        spin_lock_irqsave(&tracing_start_lock, flags);
+        if (--trace_stop_count)
+                goto out;
+
+        if (trace_stop_count < 0) {
+                /* Someone screwed up their debugging */
+                WARN_ON_ONCE(1);
+                trace_stop_count = 0;
+                goto out;
+        }
+
+
+        buffer = global_trace.buffer;
+        if (buffer)
+                ring_buffer_record_enable(buffer);
+
+        buffer = max_tr.buffer;
+        if (buffer)
+                ring_buffer_record_enable(buffer);
+
+        ftrace_start();
+ out:
+        spin_unlock_irqrestore(&tracing_start_lock, flags);
+}
+
+/**
+ * tracing_stop - quick stop of the tracer
+ *
+ * Light weight way to stop tracing. Use in conjunction with
+ * tracing_start.
+ */
+void tracing_stop(void)
+{
+        struct ring_buffer *buffer;
+        unsigned long flags;
+
+        ftrace_stop();
+        spin_lock_irqsave(&tracing_start_lock, flags);
+        if (trace_stop_count++)
+                goto out;
+
+        buffer = global_trace.buffer;
+        if (buffer)
+                ring_buffer_record_disable(buffer);
+
+        buffer = max_tr.buffer;
+        if (buffer)
+                ring_buffer_record_disable(buffer);
+
+ out:
+        spin_unlock_irqrestore(&tracing_start_lock, flags);
+}
+
 void trace_stop_cmdline_recording(void);
 
 static void trace_save_cmdline(struct task_struct *tsk)
@@ -618,7 +817,7 @@ static void trace_save_cmdline(struct task_struct *tsk)
         spin_unlock(&trace_cmdline_lock);
 }
 
-static char *trace_find_cmdline(int pid)
+char *trace_find_cmdline(int pid)
 {
         char *cmdline = "<...>";
         unsigned map;
@@ -655,6 +854,7 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
 
         entry->preempt_count            = pc & 0xff;
         entry->pid                      = (tsk) ? tsk->pid : 0;
+        entry->tgid                     = (tsk) ? tsk->tgid : 0;
         entry->flags =
 #ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
                 (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
@@ -691,6 +891,56 @@ trace_function(struct trace_array *tr, struct trace_array_cpu *data,
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 }
 
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+static void __trace_graph_entry(struct trace_array *tr,
+                                struct trace_array_cpu *data,
+                                struct ftrace_graph_ent *trace,
+                                unsigned long flags,
+                                int pc)
+{
+        struct ring_buffer_event *event;
+        struct ftrace_graph_ent_entry *entry;
+        unsigned long irq_flags;
+
+        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+                return;
+
+        event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_GRAPH_ENT;
+        entry->graph_ent                        = *trace;
+        ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
+}
+
+static void __trace_graph_return(struct trace_array *tr,
+                                struct trace_array_cpu *data,
+                                struct ftrace_graph_ret *trace,
+                                unsigned long flags,
+                                int pc)
+{
+        struct ring_buffer_event *event;
+        struct ftrace_graph_ret_entry *entry;
+        unsigned long irq_flags;
+
+        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+                return;
+
+        event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_GRAPH_RET;
+        entry->ret                              = *trace;
+        ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
+}
+#endif
+
 void
 ftrace(struct trace_array *tr, struct trace_array_cpu *data,
        unsigned long ip, unsigned long parent_ip, unsigned long flags,
@@ -742,6 +992,46 @@ void __trace_stack(struct trace_array *tr,
         ftrace_trace_stack(tr, data, flags, skip, preempt_count());
 }
 
+static void ftrace_trace_userstack(struct trace_array *tr,
+                   struct trace_array_cpu *data,
+                   unsigned long flags, int pc)
+{
+#ifdef CONFIG_STACKTRACE
+        struct ring_buffer_event *event;
+        struct userstack_entry *entry;
+        struct stack_trace trace;
+        unsigned long irq_flags;
+
+        if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
+                return;
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type         = TRACE_USER_STACK;
+
+        memset(&entry->caller, 0, sizeof(entry->caller));
+
+        trace.nr_entries        = 0;
+        trace.max_entries       = FTRACE_STACK_ENTRIES;
+        trace.skip              = 0;
+        trace.entries           = entry->caller;
+
+        save_stack_trace_user(&trace);
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+#endif
+}
+
+void __trace_userstack(struct trace_array *tr,
+                   struct trace_array_cpu *data,
+                   unsigned long flags)
+{
+        ftrace_trace_userstack(tr, data, flags, preempt_count());
+}
+
 static void
 ftrace_trace_special(void *__tr, void *__data,
                      unsigned long arg1, unsigned long arg2, unsigned long arg3,
@@ -765,6 +1055,7 @@ ftrace_trace_special(void *__tr, void *__data,
         entry->arg3                     = arg3;
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
         ftrace_trace_stack(tr, data, irq_flags, 4, pc);
+        ftrace_trace_userstack(tr, data, irq_flags, pc);
 
         trace_wake_up();
 }
@@ -803,6 +1094,7 @@ tracing_sched_switch_trace(struct trace_array *tr,
         entry->next_cpu = task_cpu(next);
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
         ftrace_trace_stack(tr, data, flags, 5, pc);
+        ftrace_trace_userstack(tr, data, flags, pc);
 }
 
 void
@@ -832,6 +1124,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
         entry->next_cpu                 = task_cpu(wakee);
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
         ftrace_trace_stack(tr, data, flags, 6, pc);
+        ftrace_trace_userstack(tr, data, flags, pc);
 
         trace_wake_up();
 }
@@ -841,26 +1134,28 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
 {
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
+        unsigned long flags;
         int cpu;
         int pc;
 
-        if (tracing_disabled || !tr->ctrl)
+        if (tracing_disabled)
                 return;
 
         pc = preempt_count();
-        preempt_disable_notrace();
+        local_irq_save(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
 
-        if (likely(!atomic_read(&data->disabled)))
+        if (likely(atomic_inc_return(&data->disabled) == 1))
                 ftrace_trace_special(tr, data, arg1, arg2, arg3, pc);
 
-        preempt_enable_notrace();
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
 
 #ifdef CONFIG_FUNCTION_TRACER
 static void
-function_trace_call(unsigned long ip, unsigned long parent_ip)
+function_trace_call_preempt_only(unsigned long ip, unsigned long parent_ip)
 {
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
@@ -873,8 +1168,7 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
                 return;
 
         pc = preempt_count();
-        resched = need_resched();
-        preempt_disable_notrace();
+        resched = ftrace_preempt_disable();
         local_save_flags(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
@@ -884,11 +1178,96 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
                 trace_function(tr, data, ip, parent_ip, flags, pc);
 
         atomic_dec(&data->disabled);
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
+        ftrace_preempt_enable(resched);
+}
+
+static void
+function_trace_call(unsigned long ip, unsigned long parent_ip)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        if (unlikely(!ftrace_function_enabled))
+                return;
+
+        /*
+         * Need to use raw, since this must be called before the
+         * recursive protection is performed.
+         */
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                trace_function(tr, data, ip, parent_ip, flags, pc);
+        }
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+}
+
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+int trace_graph_entry(struct ftrace_graph_ent *trace)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        if (!ftrace_trace_task(current))
+                return 0;
+
+        if (!ftrace_graph_addr(trace->func))
+                return 0;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                __trace_graph_entry(tr, data, trace, flags, pc);
+        }
+        /* Only do the atomic if it is not already set */
+        if (!test_tsk_trace_graph(current))
+                set_tsk_trace_graph(current);
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+
+        return 1;
+}
+
+void trace_graph_return(struct ftrace_graph_ret *trace)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                __trace_graph_return(tr, data, trace, flags, pc);
+        }
+        if (!trace->depth)
+                clear_tsk_trace_graph(current);
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 
 static struct ftrace_ops trace_ops __read_mostly =
 {
@@ -898,9 +1277,14 @@ static struct ftrace_ops trace_ops __read_mostly =
 void tracing_start_function_trace(void)
 {
         ftrace_function_enabled = 0;
+
+        if (trace_flags & TRACE_ITER_PREEMPTONLY)
+                trace_ops.func = function_trace_call_preempt_only;
+        else
+                trace_ops.func = function_trace_call;
+
         register_ftrace_function(&trace_ops);
-        if (tracer_enabled)
-                ftrace_function_enabled = 1;
+        ftrace_function_enabled = 1;
 }
 
 void tracing_stop_function_trace(void)
@@ -912,6 +1296,7 @@ void tracing_stop_function_trace(void)
 
 enum trace_file_type {
         TRACE_FILE_LAT_FMT      = 1,
+        TRACE_FILE_ANNOTATE     = 2,
 };
 
 static void trace_iterator_increment(struct trace_iterator *iter, int cpu)
@@ -1047,10 +1432,6 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 
         atomic_inc(&trace_record_cmdline_disabled);
 
-        /* let the tracer grab locks here if needed */
-        if (current_trace->start)
-                current_trace->start(iter);
-
         if (*pos != iter->pos) {
                 iter->ent = NULL;
                 iter->cpu = 0;
@@ -1077,14 +1458,7 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 
 static void s_stop(struct seq_file *m, void *p)
 {
-        struct trace_iterator *iter = m->private;
-
         atomic_dec(&trace_record_cmdline_disabled);
-
-        /* let the tracer release locks here if needed */
-        if (current_trace && current_trace == iter->trace && iter->trace->stop)
-                iter->trace->stop(iter);
-
         mutex_unlock(&trace_types_lock);
 }
 
@@ -1143,7 +1517,7 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 # define IP_FMT "%016lx"
 #endif
 
-static int
+int
 seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
 {
         int ret;
@@ -1164,6 +1538,78 @@ seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
         return ret;
 }
 
+static inline int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
+                                    unsigned long ip, unsigned long sym_flags)
+{
+        struct file *file = NULL;
+        unsigned long vmstart = 0;
+        int ret = 1;
+
+        if (mm) {
+                const struct vm_area_struct *vma;
+
+                down_read(&mm->mmap_sem);
+                vma = find_vma(mm, ip);
+                if (vma) {
+                        file = vma->vm_file;
+                        vmstart = vma->vm_start;
+                }
+                if (file) {
+                        ret = trace_seq_path(s, &file->f_path);
+                        if (ret)
+                                ret = trace_seq_printf(s, "[+0x%lx]", ip - vmstart);
+                }
+                up_read(&mm->mmap_sem);
+        }
+        if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
+                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
+        return ret;
+}
+
+static int
+seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
+                      unsigned long sym_flags)
+{
+        struct mm_struct *mm = NULL;
+        int ret = 1;
+        unsigned int i;
+
+        if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
+                struct task_struct *task;
+                /*
+                 * we do the lookup on the thread group leader,
+                 * since individual threads might have already quit!
+                 */
+                rcu_read_lock();
+                task = find_task_by_vpid(entry->ent.tgid);
+                if (task)
+                        mm = get_task_mm(task);
+                rcu_read_unlock();
+        }
+
+        for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
+                unsigned long ip = entry->caller[i];
+
+                if (ip == ULONG_MAX || !ret)
+                        break;
+                if (i && ret)
+                        ret = trace_seq_puts(s, " <- ");
+                if (!ip) {
+                        if (ret)
+                                ret = trace_seq_puts(s, "??");
+                        continue;
+                }
+                if (!ret)
+                        break;
+                if (ret)
+                        ret = seq_print_user_ip(s, mm, ip, sym_flags);
+        }
+
+        if (mm)
+                mmput(mm);
+        return ret;
+}
+
 static void print_lat_help_header(struct seq_file *m)
 {
         seq_puts(m, "#                  _------=> CPU#            \n");
@@ -1338,6 +1784,23 @@ void trace_seq_print_cont(struct trace_seq *s, struct trace_iterator *iter)
                 trace_seq_putc(s, '\n');
 }
 
+static void test_cpu_buff_start(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+
+        if (!(trace_flags & TRACE_ITER_ANNOTATE))
+                return;
+
+        if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
+                return;
+
+        if (cpu_isset(iter->cpu, iter->started))
+                return;
+
+        cpu_set(iter->cpu, iter->started);
+        trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu);
+}
+
 static enum print_line_t
 print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
 {
@@ -1357,6 +1820,8 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
         if (entry->type == TRACE_CONT)
                 return TRACE_TYPE_HANDLED;
 
+        test_cpu_buff_start(iter);
+
         next_entry = find_next_entry(iter, NULL, &next_ts);
         if (!next_entry)
                 next_ts = iter->ts;
@@ -1448,6 +1913,27 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
                         trace_seq_print_cont(s, iter);
                 break;
         }
+        case TRACE_BRANCH: {
+                struct trace_branch *field;
+
+                trace_assign_type(field, entry);
+
+                trace_seq_printf(s, "[%s] %s:%s:%d\n",
+                                 field->correct ? "  ok  " : " MISS ",
+                                 field->func,
+                                 field->file,
+                                 field->line);
+                break;
+        }
+        case TRACE_USER_STACK: {
+                struct userstack_entry *field;
+
+                trace_assign_type(field, entry);
+
+                seq_print_userip_objs(field, s, sym_flags);
+                trace_seq_putc(s, '\n');
+                break;
+        }
         default:
                 trace_seq_printf(s, "Unknown type %d\n", entry->type);
         }
@@ -1472,6 +1958,8 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
         if (entry->type == TRACE_CONT)
                 return TRACE_TYPE_HANDLED;
 
+        test_cpu_buff_start(iter);
+
         comm = trace_find_cmdline(iter->ent->pid);
 
         t = ns2usecs(iter->ts);
@@ -1581,6 +2069,37 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
                         trace_seq_print_cont(s, iter);
                 break;
         }
+        case TRACE_GRAPH_RET: {
+                return print_graph_function(iter);
+        }
+        case TRACE_GRAPH_ENT: {
+                return print_graph_function(iter);
+        }
+        case TRACE_BRANCH: {
+                struct trace_branch *field;
+
+                trace_assign_type(field, entry);
+
+                trace_seq_printf(s, "[%s] %s:%s:%d\n",
+                                 field->correct ? "  ok  " : " MISS ",
+                                 field->func,
+                                 field->file,
+                                 field->line);
+                break;
+        }
+        case TRACE_USER_STACK: {
+                struct userstack_entry *field;
+
+                trace_assign_type(field, entry);
+
+                ret = seq_print_userip_objs(field, s, sym_flags);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                ret = trace_seq_putc(s, '\n');
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                break;
+        }
         }
         return TRACE_TYPE_HANDLED;
 }
@@ -1640,6 +2159,7 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
                 break;
         }
         case TRACE_SPECIAL:
+        case TRACE_USER_STACK:
         case TRACE_STACK: {
                 struct special_entry *field;
 
@@ -1728,6 +2248,7 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
                 break;
         }
         case TRACE_SPECIAL:
+        case TRACE_USER_STACK:
         case TRACE_STACK: {
                 struct special_entry *field;
 
@@ -1755,7 +2276,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
                 return TRACE_TYPE_HANDLED;
 
         SEQ_PUT_FIELD_RET(s, entry->pid);
-        SEQ_PUT_FIELD_RET(s, iter->cpu);
+        SEQ_PUT_FIELD_RET(s, entry->cpu);
         SEQ_PUT_FIELD_RET(s, iter->ts);
 
         switch (entry->type) {
@@ -1782,6 +2303,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
                 break;
         }
         case TRACE_SPECIAL:
+        case TRACE_USER_STACK:
         case TRACE_STACK: {
                 struct special_entry *field;
 
@@ -1847,7 +2369,9 @@ static int s_show(struct seq_file *m, void *v)
                         seq_printf(m, "# tracer: %s\n", iter->trace->name);
                         seq_puts(m, "#\n");
                 }
-                if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
+                if (iter->trace && iter->trace->print_header)
+                        iter->trace->print_header(m);
+                else if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
                         /* print nothing if the buffers are empty */
                         if (trace_empty(iter))
                                 return 0;
@@ -1899,6 +2423,15 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
         iter->trace = current_trace;
         iter->pos = -1;
 
+        /* Notify the tracer early; before we stop tracing. */
+        if (iter->trace && iter->trace->open)
+                        iter->trace->open(iter);
+
+        /* Annotate start of buffers if we had overruns */
+        if (ring_buffer_overruns(iter->tr->buffer))
+                iter->iter_flags |= TRACE_FILE_ANNOTATE;
+
+
         for_each_tracing_cpu(cpu) {
 
                 iter->buffer_iter[cpu] =
@@ -1917,13 +2450,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
         m->private = iter;
 
         /* stop the trace while dumping */
-        if (iter->tr->ctrl) {
-                tracer_enabled = 0;
-                ftrace_function_enabled = 0;
-        }
-
-        if (iter->trace && iter->trace->open)
-                        iter->trace->open(iter);
+        tracing_stop();
 
         mutex_unlock(&trace_types_lock);
 
@@ -1936,6 +2463,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
         mutex_unlock(&trace_types_lock);
+        kfree(iter);
 
         return ERR_PTR(-ENOMEM);
 }
@@ -1965,14 +2493,7 @@ int tracing_release(struct inode *inode, struct file *file)
                 iter->trace->close(iter);
 
         /* reenable tracing if it was previously enabled */
-        if (iter->tr->ctrl) {
-                tracer_enabled = 1;
-                /*
-                 * It is safe to enable function tracing even if it
-                 * isn't used
-                 */
-                ftrace_function_enabled = 1;
-        }
+        tracing_start();
         mutex_unlock(&trace_types_lock);
 
         seq_release(inode, file);
@@ -2150,7 +2671,7 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
         if (err)
                 goto err_unlock;
 
-        raw_local_irq_disable();
+        local_irq_disable();
         __raw_spin_lock(&ftrace_max_lock);
         for_each_tracing_cpu(cpu) {
                 /*
@@ -2167,7 +2688,7 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                 }
         }
         __raw_spin_unlock(&ftrace_max_lock);
-        raw_local_irq_enable();
+        local_irq_enable();
 
         tracing_cpumask = tracing_cpumask_new;
 
@@ -2188,13 +2709,16 @@ static struct file_operations tracing_cpumask_fops = {
 };
 
 static ssize_t
-tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
+tracing_trace_options_read(struct file *filp, char __user *ubuf,
                        size_t cnt, loff_t *ppos)
 {
+        int i;
         char *buf;
         int r = 0;
         int len = 0;
-        int i;
+        u32 tracer_flags = current_trace->flags->val;
+        struct tracer_opt *trace_opts = current_trace->flags->opts;
+
 
         /* calulate max size */
         for (i = 0; trace_options[i]; i++) {
@@ -2202,6 +2726,15 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
                 len += 3; /* "no" and space */
         }
 
+        /*
+         * Increase the size with names of options specific
+         * of the current tracer.
+         */
+        for (i = 0; trace_opts[i].name; i++) {
+                len += strlen(trace_opts[i].name);
+                len += 3; /* "no" and space */
+        }
+
         /* +2 for \n and \0 */
         buf = kmalloc(len + 2, GFP_KERNEL);
         if (!buf)
@@ -2214,6 +2747,15 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
                         r += sprintf(buf + r, "no%s ", trace_options[i]);
         }
 
+        for (i = 0; trace_opts[i].name; i++) {
+                if (tracer_flags & trace_opts[i].bit)
+                        r += sprintf(buf + r, "%s ",
+                                trace_opts[i].name);
+                else
+                        r += sprintf(buf + r, "no%s ",
+                                trace_opts[i].name);
+        }
+
         r += sprintf(buf + r, "\n");
         WARN_ON(r >= len + 2);
 
@@ -2224,13 +2766,48 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
         return r;
 }
 
+/* Try to assign a tracer specific option */
+static int set_tracer_option(struct tracer *trace, char *cmp, int neg)
+{
+        struct tracer_flags *trace_flags = trace->flags;
+        struct tracer_opt *opts = NULL;
+        int ret = 0, i = 0;
+        int len;
+
+        for (i = 0; trace_flags->opts[i].name; i++) {
+                opts = &trace_flags->opts[i];
+                len = strlen(opts->name);
+
+                if (strncmp(cmp, opts->name, len) == 0) {
+                        ret = trace->set_flag(trace_flags->val,
+                                opts->bit, !neg);
+                        break;
+                }
+        }
+        /* Not found */
+        if (!trace_flags->opts[i].name)
+                return -EINVAL;
+
+        /* Refused to handle */
+        if (ret)
+                return ret;
+
+        if (neg)
+                trace_flags->val &= ~opts->bit;
+        else
+                trace_flags->val |= opts->bit;
+
+        return 0;
+}
+
 static ssize_t
-tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
+tracing_trace_options_write(struct file *filp, const char __user *ubuf,
                         size_t cnt, loff_t *ppos)
 {
         char buf[64];
         char *cmp = buf;
         int neg = 0;
+        int ret;
         int i;
 
         if (cnt >= sizeof(buf))
@@ -2257,11 +2834,13 @@ tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
                         break;
                 }
         }
-        /*
-         * If no option could be set, return an error:
-         */
-        if (!trace_options[i])
-                return -EINVAL;
+
+        /* If no option could be set, test the specific tracer options */
+        if (!trace_options[i]) {
+                ret = set_tracer_option(current_trace, cmp, neg);
+                if (ret)
+                        return ret;
+        }
 
         filp->f_pos += cnt;
 
@@ -2270,8 +2849,8 @@ tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
 
 static struct file_operations tracing_iter_fops = {
         .open           = tracing_open_generic,
-        .read           = tracing_iter_ctrl_read,
-        .write          = tracing_iter_ctrl_write,
+        .read           = tracing_trace_options_read,
+        .write          = tracing_trace_options_write,
 };
 
 static const char readme_msg[] =
@@ -2285,9 +2864,9 @@ static const char readme_msg[] =
         "# echo sched_switch > /debug/tracing/current_tracer\n"
         "# cat /debug/tracing/current_tracer\n"
         "sched_switch\n"
-        "# cat /debug/tracing/iter_ctrl\n"
+        "# cat /debug/tracing/trace_options\n"
         "noprint-parent nosym-offset nosym-addr noverbose\n"
-        "# echo print-parent > /debug/tracing/iter_ctrl\n"
+        "# echo print-parent > /debug/tracing/trace_options\n"
         "# echo 1 > /debug/tracing/tracing_enabled\n"
         "# cat /debug/tracing/trace > /tmp/trace.txt\n"
         "echo 0 > /debug/tracing/tracing_enabled\n"
@@ -2310,11 +2889,10 @@ static ssize_t
 tracing_ctrl_read(struct file *filp, char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
-        struct trace_array *tr = filp->private_data;
         char buf[64];
         int r;
 
-        r = sprintf(buf, "%ld\n", tr->ctrl);
+        r = sprintf(buf, "%u\n", tracer_enabled);
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
@@ -2342,16 +2920,18 @@ tracing_ctrl_write(struct file *filp, const char __user *ubuf,
         val = !!val;
 
         mutex_lock(&trace_types_lock);
-        if (tr->ctrl ^ val) {
-                if (val)
+        if (tracer_enabled ^ val) {
+                if (val) {
                         tracer_enabled = 1;
-                else
+                        if (current_trace->start)
+                                current_trace->start(tr);
+                        tracing_start();
+                } else {
                         tracer_enabled = 0;
-
-                tr->ctrl = val;
-
-                if (current_trace && current_trace->ctrl_update)
-                        current_trace->ctrl_update(tr);
+                        tracing_stop();
+                        if (current_trace->stop)
+                                current_trace->stop(tr);
+                }
         }
         mutex_unlock(&trace_types_lock);
 
@@ -2377,29 +2957,11 @@ tracing_set_trace_read(struct file *filp, char __user *ubuf,
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
-static ssize_t
-tracing_set_trace_write(struct file *filp, const char __user *ubuf,
-                        size_t cnt, loff_t *ppos)
+static int tracing_set_tracer(char *buf)
 {
         struct trace_array *tr = &global_trace;
         struct tracer *t;
-        char buf[max_tracer_type_len+1];
-        int i;
-        size_t ret;
-
-        ret = cnt;
-
-        if (cnt > max_tracer_type_len)
-                cnt = max_tracer_type_len;
-
-        if (copy_from_user(&buf, ubuf, cnt))
-                return -EFAULT;
-
-        buf[cnt] = 0;
-
-        /* strip ending whitespace. */
-        for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
-                buf[i] = 0;
+        int ret = 0;
 
         mutex_lock(&trace_types_lock);
         for (t = trace_types; t; t = t->next) {
@@ -2413,18 +2975,52 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
         if (t == current_trace)
                 goto out;
 
+        trace_branch_disable();
         if (current_trace && current_trace->reset)
                 current_trace->reset(tr);
 
         current_trace = t;
-        if (t->init)
-                t->init(tr);
+        if (t->init) {
+                ret = t->init(tr);
+                if (ret)
+                        goto out;
+        }
 
+        trace_branch_enable(tr);
  out:
         mutex_unlock(&trace_types_lock);
 
-        if (ret > 0)
-                filp->f_pos += ret;
+        return ret;
+}
+
+static ssize_t
+tracing_set_trace_write(struct file *filp, const char __user *ubuf,
+                        size_t cnt, loff_t *ppos)
+{
+        char buf[max_tracer_type_len+1];
+        int i;
+        size_t ret;
+        int err;
+
+        ret = cnt;
+
+        if (cnt > max_tracer_type_len)
+                cnt = max_tracer_type_len;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        /* strip ending whitespace. */
+        for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
+                buf[i] = 0;
+
+        err = tracing_set_tracer(buf);
+        if (err)
+                return err;
+
+        filp->f_pos += ret;
 
         return ret;
 }
@@ -2491,6 +3087,10 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
                 return -ENOMEM;
 
         mutex_lock(&trace_types_lock);
+
+        /* trace pipe does not show start of buffer */
+        cpus_setall(iter->started);
+
         iter->tr = &global_trace;
         iter->trace = current_trace;
         filp->private_data = iter;
@@ -2666,7 +3266,7 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
         char buf[64];
         int r;
 
-        r = sprintf(buf, "%lu\n", tr->entries);
+        r = sprintf(buf, "%lu\n", tr->entries >> 10);
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
@@ -2676,8 +3276,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 {
         unsigned long val;
         char buf[64];
-        int ret;
-        struct trace_array *tr = filp->private_data;
+        int ret, cpu;
 
         if (cnt >= sizeof(buf))
                 return -EINVAL;
@@ -2697,13 +3296,19 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 
         mutex_lock(&trace_types_lock);
 
-        if (tr->ctrl) {
-                cnt = -EBUSY;
-                pr_info("ftrace: please disable tracing"
-                        " before modifying buffer size\n");
-                goto out;
+        tracing_stop();
+
+        /* disable all cpu buffers */
+        for_each_tracing_cpu(cpu) {
+                if (global_trace.data[cpu])
+                        atomic_inc(&global_trace.data[cpu]->disabled);
+                if (max_tr.data[cpu])
+                        atomic_inc(&max_tr.data[cpu]->disabled);
         }
 
+        /* value is in KB */
+        val <<= 10;
+
         if (val != global_trace.entries) {
                 ret = ring_buffer_resize(global_trace.buffer, val);
                 if (ret < 0) {
@@ -2735,6 +3340,14 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
         if (tracing_disabled)
                 cnt = -ENOMEM;
  out:
+        for_each_tracing_cpu(cpu) {
+                if (global_trace.data[cpu])
+                        atomic_dec(&global_trace.data[cpu]->disabled);
+                if (max_tr.data[cpu])
+                        atomic_dec(&max_tr.data[cpu]->disabled);
+        }
+
+        tracing_start();
         max_tr.entries = global_trace.entries;
         mutex_unlock(&trace_types_lock);
 
@@ -2746,7 +3359,7 @@ static int mark_printk(const char *fmt, ...)
         int ret;
         va_list args;
         va_start(args, fmt);
-        ret = trace_vprintk(0, fmt, args);
+        ret = trace_vprintk(0, -1, fmt, args);
         va_end(args);
         return ret;
 }
@@ -2757,9 +3370,8 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 {
         char *buf;
         char *end;
-        struct trace_array *tr = &global_trace;
 
-        if (!tr->ctrl || tracing_disabled)
+        if (tracing_disabled)
                 return -EINVAL;
 
         if (cnt > TRACE_BUF_SIZE)
@@ -2825,22 +3437,38 @@ static struct file_operations tracing_mark_fops = {
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 
+int __weak ftrace_arch_read_dyn_info(char *buf, int size)
+{
+        return 0;
+}
+
 static ssize_t
-tracing_read_long(struct file *filp, char __user *ubuf,
+tracing_read_dyn_info(struct file *filp, char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
+        static char ftrace_dyn_info_buffer[1024];
+        static DEFINE_MUTEX(dyn_info_mutex);
         unsigned long *p = filp->private_data;
-        char buf[64];
+        char *buf = ftrace_dyn_info_buffer;
+        int size = ARRAY_SIZE(ftrace_dyn_info_buffer);
         int r;
 
-        r = sprintf(buf, "%ld\n", *p);
+        mutex_lock(&dyn_info_mutex);
+        r = sprintf(buf, "%ld ", *p);
 
-        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+        r += ftrace_arch_read_dyn_info(buf+r, (size-1)-r);
+        buf[r++] = '\n';
+
+        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+
+        mutex_unlock(&dyn_info_mutex);
+
+        return r;
 }
 
-static struct file_operations tracing_read_long_fops = {
+static struct file_operations tracing_dyn_info_fops = {
         .open           = tracing_open_generic,
-        .read           = tracing_read_long,
+        .read           = tracing_read_dyn_info,
 };
 #endif
 
@@ -2881,10 +3509,10 @@ static __init int tracer_init_debugfs(void)
         if (!entry)
                 pr_warning("Could not create debugfs 'tracing_enabled' entry\n");
 
-        entry = debugfs_create_file("iter_ctrl", 0644, d_tracer,
+        entry = debugfs_create_file("trace_options", 0644, d_tracer,
                                     NULL, &tracing_iter_fops);
         if (!entry)
-                pr_warning("Could not create debugfs 'iter_ctrl' entry\n");
+                pr_warning("Could not create debugfs 'trace_options' entry\n");
 
         entry = debugfs_create_file("tracing_cpumask", 0644, d_tracer,
                                     NULL, &tracing_cpumask_fops);
@@ -2934,11 +3562,11 @@ static __init int tracer_init_debugfs(void)
                 pr_warning("Could not create debugfs "
                            "'trace_pipe' entry\n");
 
-        entry = debugfs_create_file("trace_entries", 0644, d_tracer,
+        entry = debugfs_create_file("buffer_size_kb", 0644, d_tracer,
                                     &global_trace, &tracing_entries_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
-                           "'trace_entries' entry\n");
+                           "'buffer_size_kb' entry\n");
 
         entry = debugfs_create_file("trace_marker", 0220, d_tracer,
                                     NULL, &tracing_mark_fops);
@@ -2949,7 +3577,7 @@ static __init int tracer_init_debugfs(void)
 #ifdef CONFIG_DYNAMIC_FTRACE
         entry = debugfs_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                                     &ftrace_update_tot_cnt,
-                                    &tracing_read_long_fops);
+                                    &tracing_dyn_info_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
                            "'dyn_ftrace_total_info' entry\n");
@@ -2960,7 +3588,7 @@ static __init int tracer_init_debugfs(void)
         return 0;
 }
 
-int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
+int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
 {
         static DEFINE_SPINLOCK(trace_buf_lock);
         static char trace_buf[TRACE_BUF_SIZE];
@@ -2968,11 +3596,11 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         struct ring_buffer_event *event;
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
-        struct print_entry *entry;
-        unsigned long flags, irq_flags;
         int cpu, len = 0, size, pc;
+        struct print_entry *entry;
+        unsigned long irq_flags;
 
-        if (!tr->ctrl || tracing_disabled)
+        if (tracing_disabled || tracing_selftest_running)
                 return 0;
 
         pc = preempt_count();
@@ -2983,7 +3611,8 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         if (unlikely(atomic_read(&data->disabled)))
                 goto out;
 
-        spin_lock_irqsave(&trace_buf_lock, flags);
+        pause_graph_tracing();
+        spin_lock_irqsave(&trace_buf_lock, irq_flags);
         len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
 
         len = min(len, TRACE_BUF_SIZE-1);
@@ -2994,17 +3623,18 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         if (!event)
                 goto out_unlock;
         entry = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
+        tracing_generic_entry_update(&entry->ent, irq_flags, pc);
         entry->ent.type                 = TRACE_PRINT;
         entry->ip                       = ip;
+        entry->depth                    = depth;
 
         memcpy(&entry->buf, trace_buf, len);
         entry->buf[len] = 0;
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 
  out_unlock:
-        spin_unlock_irqrestore(&trace_buf_lock, flags);
-
+        spin_unlock_irqrestore(&trace_buf_lock, irq_flags);
+        unpause_graph_tracing();
  out:
         preempt_enable_notrace();
 
@@ -3021,7 +3651,7 @@ int __ftrace_printk(unsigned long ip, const char *fmt, ...)
                 return 0;
 
         va_start(ap, fmt);
-        ret = trace_vprintk(ip, fmt, ap);
+        ret = trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
         va_end(ap);
         return ret;
 }
@@ -3030,7 +3660,8 @@ EXPORT_SYMBOL_GPL(__ftrace_printk);
 static int trace_panic_handler(struct notifier_block *this,
                                unsigned long event, void *unused)
 {
-        ftrace_dump();
+        if (ftrace_dump_on_oops)
+                ftrace_dump();
         return NOTIFY_OK;
 }
 
@@ -3046,7 +3677,8 @@ static int trace_die_handler(struct notifier_block *self,
 {
         switch (val) {
         case DIE_OOPS:
-                ftrace_dump();
+                if (ftrace_dump_on_oops)
+                        ftrace_dump();
                 break;
         default:
                 break;
@@ -3087,7 +3719,6 @@ trace_printk_seq(struct trace_seq *s)
         trace_seq_reset(s);
 }
 
-
 void ftrace_dump(void)
 {
         static DEFINE_SPINLOCK(ftrace_dump_lock);
@@ -3112,6 +3743,9 @@ void ftrace_dump(void)
                 atomic_inc(&global_trace.data[cpu]->disabled);
         }
 
+        /* don't look at user memory in panic mode */
+        trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
+
         printk(KERN_TRACE "Dumping ftrace buffer:\n");
 
         iter.tr = &global_trace;
@@ -3205,7 +3839,6 @@ __init static int tracer_alloc_buffers(void)
 #endif
 
         /* All seems OK, enable tracing */
-        global_trace.ctrl = tracer_enabled;
         tracing_disabled = 0;
 
         atomic_notifier_chain_register(&panic_notifier_list,
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 8465ad052707..5ac697065a48 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -8,6 +8,7 @@
 #include <linux/ring_buffer.h>
 #include <linux/mmiotrace.h>
 #include <linux/ftrace.h>
+#include <trace/boot.h>
 
 enum trace_type {
         __TRACE_FIRST_TYPE = 0,
@@ -21,7 +22,14 @@ enum trace_type {
         TRACE_SPECIAL,
         TRACE_MMIO_RW,
         TRACE_MMIO_MAP,
-        TRACE_BOOT,
+        TRACE_BRANCH,
+        TRACE_BOOT_CALL,
+        TRACE_BOOT_RET,
+        TRACE_GRAPH_RET,
+        TRACE_GRAPH_ENT,
+        TRACE_USER_STACK,
+        TRACE_BTS,
+        TRACE_POWER,
 
         __TRACE_LAST_TYPE
 };
@@ -38,6 +46,7 @@ struct trace_entry {
         unsigned char           flags;
         unsigned char           preempt_count;
         int                     pid;
+        int                     tgid;
 };
 
 /*
@@ -48,6 +57,18 @@ struct ftrace_entry {
         unsigned long           ip;
         unsigned long           parent_ip;
 };
+
+/* Function call entry */
+struct ftrace_graph_ent_entry {
+        struct trace_entry                      ent;
+        struct ftrace_graph_ent         graph_ent;
+};
+
+/* Function return entry */
+struct ftrace_graph_ret_entry {
+        struct trace_entry                      ent;
+        struct ftrace_graph_ret         ret;
+};
 extern struct tracer boot_tracer;
 
 /*
@@ -85,12 +106,18 @@ struct stack_entry {
         unsigned long           caller[FTRACE_STACK_ENTRIES];
 };
 
+struct userstack_entry {
+        struct trace_entry      ent;
+        unsigned long           caller[FTRACE_STACK_ENTRIES];
+};
+
 /*
  * ftrace_printk entry:
  */
 struct print_entry {
         struct trace_entry      ent;
         unsigned long           ip;
+        int                     depth;
         char                    buf[];
 };
 
@@ -112,9 +139,35 @@ struct trace_mmiotrace_map {
         struct mmiotrace_map    map;
 };
 
-struct trace_boot {
+struct trace_boot_call {
         struct trace_entry      ent;
-        struct boot_trace       initcall;
+        struct boot_trace_call boot_call;
+};
+
+struct trace_boot_ret {
+        struct trace_entry      ent;
+        struct boot_trace_ret boot_ret;
+};
+
+#define TRACE_FUNC_SIZE 30
+#define TRACE_FILE_SIZE 20
+struct trace_branch {
+        struct trace_entry      ent;
+        unsigned                line;
+        char                    func[TRACE_FUNC_SIZE+1];
+        char                    file[TRACE_FILE_SIZE+1];
+        char                    correct;
+};
+
+struct bts_entry {
+        struct trace_entry      ent;
+        unsigned long           from;
+        unsigned long           to;
+};
+
+struct trace_power {
+        struct trace_entry      ent;
+        struct power_trace      state_data;
 };
 
 /*
@@ -172,7 +225,6 @@ struct trace_iterator;
 struct trace_array {
         struct ring_buffer      *buffer;
         unsigned long           entries;
-        long                    ctrl;
         int                     cpu;
         cycle_t                 time_start;
         struct task_struct      *waiter;
@@ -212,13 +264,22 @@ extern void __ftrace_bad_type(void);
                 IF_ASSIGN(var, ent, struct ctx_switch_entry, 0);        \
                 IF_ASSIGN(var, ent, struct trace_field_cont, TRACE_CONT); \
                 IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK);   \
+                IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
                 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);   \
                 IF_ASSIGN(var, ent, struct special_entry, 0);           \
                 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw,          \
                           TRACE_MMIO_RW);                               \
                 IF_ASSIGN(var, ent, struct trace_mmiotrace_map,         \
                           TRACE_MMIO_MAP);                              \
-                IF_ASSIGN(var, ent, struct trace_boot, TRACE_BOOT);     \
+                IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
+                IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
+                IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
+                IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,      \
+                          TRACE_GRAPH_ENT);             \
+                IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,      \
+                          TRACE_GRAPH_RET);             \
+                IF_ASSIGN(var, ent, struct bts_entry, TRACE_BTS);\
+                IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
                 __ftrace_bad_type();                                    \
         } while (0)
 
@@ -229,29 +290,56 @@ enum print_line_t {
         TRACE_TYPE_UNHANDLED    = 2     /* Relay to other output functions */
 };
 
+
+/*
+ * An option specific to a tracer. This is a boolean value.
+ * The bit is the bit index that sets its value on the
+ * flags value in struct tracer_flags.
+ */
+struct tracer_opt {
+        const char      *name; /* Will appear on the trace_options file */
+        u32             bit; /* Mask assigned in val field in tracer_flags */
+};
+
+/*
+ * The set of specific options for a tracer. Your tracer
+ * have to set the initial value of the flags val.
+ */
+struct tracer_flags {
+        u32                     val;
+        struct tracer_opt       *opts;
+};
+
+/* Makes more easy to define a tracer opt */
+#define TRACER_OPT(s, b)        .name = #s, .bit = b
+
 /*
  * A specific tracer, represented by methods that operate on a trace array:
  */
 struct tracer {
         const char              *name;
-        void                    (*init)(struct trace_array *tr);
+        /* Your tracer should raise a warning if init fails */
+        int                     (*init)(struct trace_array *tr);
         void                    (*reset)(struct trace_array *tr);
+        void                    (*start)(struct trace_array *tr);
+        void                    (*stop)(struct trace_array *tr);
         void                    (*open)(struct trace_iterator *iter);
         void                    (*pipe_open)(struct trace_iterator *iter);
         void                    (*close)(struct trace_iterator *iter);
-        void                    (*start)(struct trace_iterator *iter);
-        void                    (*stop)(struct trace_iterator *iter);
         ssize_t                 (*read)(struct trace_iterator *iter,
                                         struct file *filp, char __user *ubuf,
                                         size_t cnt, loff_t *ppos);
-        void                    (*ctrl_update)(struct trace_array *tr);
 #ifdef CONFIG_FTRACE_STARTUP_TEST
         int                     (*selftest)(struct tracer *trace,
                                             struct trace_array *tr);
 #endif
+        void                    (*print_header)(struct seq_file *m);
         enum print_line_t       (*print_line)(struct trace_iterator *iter);
+        /* If you handled the flag setting, return 0 */
+        int                     (*set_flag)(u32 old_flags, u32 bit, int set);
         struct tracer           *next;
         int                     print_max;
+        struct tracer_flags     *flags;
 };
 
 struct trace_seq {
@@ -279,8 +367,11 @@ struct trace_iterator {
         unsigned long           iter_flags;
         loff_t                  pos;
         long                    idx;
+
+        cpumask_t               started;
 };
 
+int tracing_is_enabled(void);
 void trace_wake_up(void);
 void tracing_reset(struct trace_array *tr, int cpu);
 int tracing_open_generic(struct inode *inode, struct file *filp);
@@ -321,8 +412,17 @@ void trace_function(struct trace_array *tr,
                     unsigned long parent_ip,
                     unsigned long flags, int pc);
 
+void trace_graph_return(struct ftrace_graph_ret *trace);
+int trace_graph_entry(struct ftrace_graph_ent *trace);
+void trace_bts(struct trace_array *tr,
+               unsigned long from,
+               unsigned long to);
+
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
+void tracing_sched_switch_assign_trace(struct trace_array *tr);
+void tracing_stop_sched_switch_record(void);
+void tracing_start_sched_switch_record(void);
 int register_tracer(struct tracer *type);
 void unregister_tracer(struct tracer *type);
 
@@ -358,6 +458,7 @@ struct tracer_switch_ops {
         struct tracer_switch_ops        *next;
 };
 
+char *trace_find_cmdline(int pid);
 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -383,19 +484,79 @@ extern int trace_selftest_startup_sched_switch(struct tracer *trace,
                                                struct trace_array *tr);
 extern int trace_selftest_startup_sysprof(struct tracer *trace,
                                                struct trace_array *tr);
+extern int trace_selftest_startup_branch(struct tracer *trace,
+                                         struct trace_array *tr);
 #endif /* CONFIG_FTRACE_STARTUP_TEST */
 
 extern void *head_page(struct trace_array_cpu *data);
 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
 extern void trace_seq_print_cont(struct trace_seq *s,
                                  struct trace_iterator *iter);
+
+extern int
+seq_print_ip_sym(struct trace_seq *s, unsigned long ip,
+                unsigned long sym_flags);
 extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
                                  size_t cnt);
 extern long ns2usecs(cycle_t nsec);
-extern int trace_vprintk(unsigned long ip, const char *fmt, va_list args);
+extern int
+trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args);
 
 extern unsigned long trace_flags;
 
+/* Standard output formatting function used for function return traces */
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+extern enum print_line_t print_graph_function(struct trace_iterator *iter);
+
+#ifdef CONFIG_DYNAMIC_FTRACE
+/* TODO: make this variable */
+#define FTRACE_GRAPH_MAX_FUNCS          32
+extern int ftrace_graph_count;
+extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
+
+static inline int ftrace_graph_addr(unsigned long addr)
+{
+        int i;
+
+        if (!ftrace_graph_count || test_tsk_trace_graph(current))
+                return 1;
+
+        for (i = 0; i < ftrace_graph_count; i++) {
+                if (addr == ftrace_graph_funcs[i])
+                        return 1;
+        }
+
+        return 0;
+}
+#else
+static inline int ftrace_trace_addr(unsigned long addr)
+{
+        return 1;
+}
+static inline int ftrace_graph_addr(unsigned long addr)
+{
+        return 1;
+}
+#endif /* CONFIG_DYNAMIC_FTRACE */
+
+#else /* CONFIG_FUNCTION_GRAPH_TRACER */
+static inline enum print_line_t
+print_graph_function(struct trace_iterator *iter)
+{
+        return TRACE_TYPE_UNHANDLED;
+}
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+
+extern struct pid *ftrace_pid_trace;
+
+static inline int ftrace_trace_task(struct task_struct *task)
+{
+        if (!ftrace_pid_trace)
+                return 1;
+
+        return test_tsk_trace_trace(task);
+}
+
 /*
  * trace_iterator_flags is an enumeration that defines bit
  * positions into trace_flags that controls the output.
@@ -415,8 +576,92 @@ enum trace_iterator_flags {
         TRACE_ITER_STACKTRACE           = 0x100,
         TRACE_ITER_SCHED_TREE           = 0x200,
         TRACE_ITER_PRINTK               = 0x400,
+        TRACE_ITER_PREEMPTONLY          = 0x800,
+        TRACE_ITER_BRANCH               = 0x1000,
+        TRACE_ITER_ANNOTATE             = 0x2000,
+        TRACE_ITER_USERSTACKTRACE       = 0x4000,
+        TRACE_ITER_SYM_USEROBJ          = 0x8000
 };
 
+/*
+ * TRACE_ITER_SYM_MASK masks the options in trace_flags that
+ * control the output of kernel symbols.
+ */
+#define TRACE_ITER_SYM_MASK \
+        (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
+
 extern struct tracer nop_trace;
 
+/**
+ * ftrace_preempt_disable - disable preemption scheduler safe
+ *
+ * When tracing can happen inside the scheduler, there exists
+ * cases that the tracing might happen before the need_resched
+ * flag is checked. If this happens and the tracer calls
+ * preempt_enable (after a disable), a schedule might take place
+ * causing an infinite recursion.
+ *
+ * To prevent this, we read the need_recshed flag before
+ * disabling preemption. When we want to enable preemption we
+ * check the flag, if it is set, then we call preempt_enable_no_resched.
+ * Otherwise, we call preempt_enable.
+ *
+ * The rational for doing the above is that if need resched is set
+ * and we have yet to reschedule, we are either in an atomic location
+ * (where we do not need to check for scheduling) or we are inside
+ * the scheduler and do not want to resched.
+ */
+static inline int ftrace_preempt_disable(void)
+{
+        int resched;
+
+        resched = need_resched();
+        preempt_disable_notrace();
+
+        return resched;
+}
+
+/**
+ * ftrace_preempt_enable - enable preemption scheduler safe
+ * @resched: the return value from ftrace_preempt_disable
+ *
+ * This is a scheduler safe way to enable preemption and not miss
+ * any preemption checks. The disabled saved the state of preemption.
+ * If resched is set, then we were either inside an atomic or
+ * are inside the scheduler (we would have already scheduled
+ * otherwise). In this case, we do not want to call normal
+ * preempt_enable, but preempt_enable_no_resched instead.
+ */
+static inline void ftrace_preempt_enable(int resched)
+{
+        if (resched)
+                preempt_enable_no_resched_notrace();
+        else
+                preempt_enable_notrace();
+}
+
+#ifdef CONFIG_BRANCH_TRACER
+extern int enable_branch_tracing(struct trace_array *tr);
+extern void disable_branch_tracing(void);
+static inline int trace_branch_enable(struct trace_array *tr)
+{
+        if (trace_flags & TRACE_ITER_BRANCH)
+                return enable_branch_tracing(tr);
+        return 0;
+}
+static inline void trace_branch_disable(void)
+{
+        /* due to races, always disable */
+        disable_branch_tracing();
+}
+#else
+static inline int trace_branch_enable(struct trace_array *tr)
+{
+        return 0;
+}
+static inline void trace_branch_disable(void)
+{
+}
+#endif /* CONFIG_BRANCH_TRACER */
+
 #endif /* _LINUX_KERNEL_TRACE_H */
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
index d0a5e50eeff2..a4fa2c57e34e 100644
--- a/kernel/trace/trace_boot.c
+++ b/kernel/trace/trace_boot.c
@@ -13,73 +13,117 @@
 #include "trace.h"
 
 static struct trace_array *boot_trace;
-static int trace_boot_enabled;
+static bool pre_initcalls_finished;
 
-
-/* Should be started after do_pre_smp_initcalls() in init/main.c */
+/* Tells the boot tracer that the pre_smp_initcalls are finished.
+ * So we are ready .
+ * It doesn't enable sched events tracing however.
+ * You have to call enable_boot_trace to do so.
+ */
 void start_boot_trace(void)
 {
-        trace_boot_enabled = 1;
+        pre_initcalls_finished = true;
 }
 
-void stop_boot_trace(void)
+void enable_boot_trace(void)
 {
-        trace_boot_enabled = 0;
+        if (pre_initcalls_finished)
+                tracing_start_sched_switch_record();
 }
 
-void reset_boot_trace(struct trace_array *tr)
+void disable_boot_trace(void)
 {
-        stop_boot_trace();
+        if (pre_initcalls_finished)
+                tracing_stop_sched_switch_record();
 }
 
-static void boot_trace_init(struct trace_array *tr)
+static void reset_boot_trace(struct trace_array *tr)
 {
         int cpu;
-        boot_trace = tr;
 
-        trace_boot_enabled = 0;
+        tr->time_start = ftrace_now(tr->cpu);
+
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+}
+
+static int boot_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        boot_trace = tr;
 
         for_each_cpu_mask(cpu, cpu_possible_map)
                 tracing_reset(tr, cpu);
+
+        tracing_sched_switch_assign_trace(tr);
+        return 0;
 }
 
-static void boot_trace_ctrl_update(struct trace_array *tr)
+static enum print_line_t
+initcall_call_print_line(struct trace_iterator *iter)
 {
-        if (tr->ctrl)
-                start_boot_trace();
+        struct trace_entry *entry = iter->ent;
+        struct trace_seq *s = &iter->seq;
+        struct trace_boot_call *field;
+        struct boot_trace_call *call;
+        u64 ts;
+        unsigned long nsec_rem;
+        int ret;
+
+        trace_assign_type(field, entry);
+        call = &field->boot_call;
+        ts = iter->ts;
+        nsec_rem = do_div(ts, 1000000000);
+
+        ret = trace_seq_printf(s, "[%5ld.%09ld] calling  %s @ %i\n",
+                        (unsigned long)ts, nsec_rem, call->func, call->caller);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
         else
-                stop_boot_trace();
+                return TRACE_TYPE_HANDLED;
 }
 
-static enum print_line_t initcall_print_line(struct trace_iterator *iter)
+static enum print_line_t
+initcall_ret_print_line(struct trace_iterator *iter)
 {
-        int ret;
         struct trace_entry *entry = iter->ent;
-        struct trace_boot *field = (struct trace_boot *)entry;
-        struct boot_trace *it = &field->initcall;
         struct trace_seq *s = &iter->seq;
-        struct timespec calltime = ktime_to_timespec(it->calltime);
-        struct timespec rettime = ktime_to_timespec(it->rettime);
-
-        if (entry->type == TRACE_BOOT) {
-                ret = trace_seq_printf(s, "[%5ld.%09ld] calling  %s @ %i\n",
-                                          calltime.tv_sec,
-                                          calltime.tv_nsec,
-                                          it->func, it->caller);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-
-                ret = trace_seq_printf(s, "[%5ld.%09ld] initcall %s "
-                                          "returned %d after %lld msecs\n",
-                                          rettime.tv_sec,
-                                          rettime.tv_nsec,
-                                          it->func, it->result, it->duration);
-
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
+        struct trace_boot_ret *field;
+        struct boot_trace_ret *init_ret;
+        u64 ts;
+        unsigned long nsec_rem;
+        int ret;
+
+        trace_assign_type(field, entry);
+        init_ret = &field->boot_ret;
+        ts = iter->ts;
+        nsec_rem = do_div(ts, 1000000000);
+
+        ret = trace_seq_printf(s, "[%5ld.%09ld] initcall %s "
+                        "returned %d after %llu msecs\n",
+                        (unsigned long) ts,
+                        nsec_rem,
+                        init_ret->func, init_ret->result, init_ret->duration);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+        else
                 return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t initcall_print_line(struct trace_iterator *iter)
+{
+        struct trace_entry *entry = iter->ent;
+
+        switch (entry->type) {
+        case TRACE_BOOT_CALL:
+                return initcall_call_print_line(iter);
+        case TRACE_BOOT_RET:
+                return initcall_ret_print_line(iter);
+        default:
+                return TRACE_TYPE_UNHANDLED;
         }
-        return TRACE_TYPE_UNHANDLED;
 }
 
 struct tracer boot_tracer __read_mostly =
@@ -87,27 +131,53 @@ struct tracer boot_tracer __read_mostly =
         .name           = "initcall",
         .init           = boot_trace_init,
         .reset          = reset_boot_trace,
-        .ctrl_update    = boot_trace_ctrl_update,
         .print_line     = initcall_print_line,
 };
 
-void trace_boot(struct boot_trace *it, initcall_t fn)
+void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
 {
         struct ring_buffer_event *event;
-        struct trace_boot *entry;
-        struct trace_array_cpu *data;
+        struct trace_boot_call *entry;
         unsigned long irq_flags;
         struct trace_array *tr = boot_trace;
 
-        if (!trace_boot_enabled)
+        if (!pre_initcalls_finished)
                 return;
 
         /* Get its name now since this function could
          * disappear because it is in the .init section.
          */
-        sprint_symbol(it->func, (unsigned long)fn);
+        sprint_symbol(bt->func, (unsigned long)fn);
+        preempt_disable();
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type = TRACE_BOOT_CALL;
+        entry->boot_call = *bt;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+
+ out:
+        preempt_enable();
+}
+
+void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn)
+{
+        struct ring_buffer_event *event;
+        struct trace_boot_ret *entry;
+        unsigned long irq_flags;
+        struct trace_array *tr = boot_trace;
+
+        if (!pre_initcalls_finished)
+                return;
+
+        sprint_symbol(bt->func, (unsigned long)fn);
         preempt_disable();
-        data = tr->data[smp_processor_id()];
 
         event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
                                          &irq_flags);
@@ -115,8 +185,8 @@ void trace_boot(struct boot_trace *it, initcall_t fn)
                 goto out;
         entry   = ring_buffer_event_data(event);
         tracing_generic_entry_update(&entry->ent, 0, 0);
-        entry->ent.type = TRACE_BOOT;
-        entry->initcall = *it;
+        entry->ent.type = TRACE_BOOT_RET;
+        entry->boot_ret = *bt;
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 
         trace_wake_up();
diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
new file mode 100644
index 000000000000..6c00feb3bac7
--- /dev/null
+++ b/kernel/trace/trace_branch.c
@@ -0,0 +1,342 @@
+/*
+ * unlikely profiler
+ *
+ * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
+ */
+#include <linux/kallsyms.h>
+#include <linux/seq_file.h>
+#include <linux/spinlock.h>
+#include <linux/irqflags.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/ftrace.h>
+#include <linux/hash.h>
+#include <linux/fs.h>
+#include <asm/local.h>
+#include "trace.h"
+
+#ifdef CONFIG_BRANCH_TRACER
+
+static int branch_tracing_enabled __read_mostly;
+static DEFINE_MUTEX(branch_tracing_mutex);
+static struct trace_array *branch_tracer;
+
+static void
+probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
+{
+        struct trace_array *tr = branch_tracer;
+        struct ring_buffer_event *event;
+        struct trace_branch *entry;
+        unsigned long flags, irq_flags;
+        int cpu, pc;
+        const char *p;
+
+        /*
+         * I would love to save just the ftrace_likely_data pointer, but
+         * this code can also be used by modules. Ugly things can happen
+         * if the module is unloaded, and then we go and read the
+         * pointer.  This is slower, but much safer.
+         */
+
+        if (unlikely(!tr))
+                return;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
+                goto out;
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+
+        pc = preempt_count();
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type         = TRACE_BRANCH;
+
+        /* Strip off the path, only save the file */
+        p = f->file + strlen(f->file);
+        while (p >= f->file && *p != '/')
+                p--;
+        p++;
+
+        strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
+        strncpy(entry->file, p, TRACE_FILE_SIZE);
+        entry->func[TRACE_FUNC_SIZE] = 0;
+        entry->file[TRACE_FILE_SIZE] = 0;
+        entry->line = f->line;
+        entry->correct = val == expect;
+
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+ out:
+        atomic_dec(&tr->data[cpu]->disabled);
+        local_irq_restore(flags);
+}
+
+static inline
+void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
+{
+        if (!branch_tracing_enabled)
+                return;
+
+        probe_likely_condition(f, val, expect);
+}
+
+int enable_branch_tracing(struct trace_array *tr)
+{
+        int ret = 0;
+
+        mutex_lock(&branch_tracing_mutex);
+        branch_tracer = tr;
+        /*
+         * Must be seen before enabling. The reader is a condition
+         * where we do not need a matching rmb()
+         */
+        smp_wmb();
+        branch_tracing_enabled++;
+        mutex_unlock(&branch_tracing_mutex);
+
+        return ret;
+}
+
+void disable_branch_tracing(void)
+{
+        mutex_lock(&branch_tracing_mutex);
+
+        if (!branch_tracing_enabled)
+                goto out_unlock;
+
+        branch_tracing_enabled--;
+
+ out_unlock:
+        mutex_unlock(&branch_tracing_mutex);
+}
+
+static void start_branch_trace(struct trace_array *tr)
+{
+        enable_branch_tracing(tr);
+}
+
+static void stop_branch_trace(struct trace_array *tr)
+{
+        disable_branch_tracing();
+}
+
+static int branch_trace_init(struct trace_array *tr)
+{
+        int cpu;
+
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+
+        start_branch_trace(tr);
+        return 0;
+}
+
+static void branch_trace_reset(struct trace_array *tr)
+{
+        stop_branch_trace(tr);
+}
+
+struct tracer branch_trace __read_mostly =
+{
+        .name           = "branch",
+        .init           = branch_trace_init,
+        .reset          = branch_trace_reset,
+#ifdef CONFIG_FTRACE_SELFTEST
+        .selftest       = trace_selftest_startup_branch,
+#endif
+};
+
+__init static int init_branch_trace(void)
+{
+        return register_tracer(&branch_trace);
+}
+
+device_initcall(init_branch_trace);
+#else
+static inline
+void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
+{
+}
+#endif /* CONFIG_BRANCH_TRACER */
+
+void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
+{
+        /*
+         * I would love to have a trace point here instead, but the
+         * trace point code is so inundated with unlikely and likely
+         * conditions that the recursive nightmare that exists is too
+         * much to try to get working. At least for now.
+         */
+        trace_likely_condition(f, val, expect);
+
+        /* FIXME: Make this atomic! */
+        if (val == expect)
+                f->correct++;
+        else
+                f->incorrect++;
+}
+EXPORT_SYMBOL(ftrace_likely_update);
+
+struct ftrace_pointer {
+        void            *start;
+        void            *stop;
+        int             hit;
+};
+
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        const struct ftrace_pointer *f = m->private;
+        struct ftrace_branch_data *p = v;
+
+        (*pos)++;
+
+        if (v == (void *)1)
+                return f->start;
+
+        ++p;
+
+        if ((void *)p >= (void *)f->stop)
+                return NULL;
+
+        return p;
+}
+
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
+        void *t = (void *)1;
+        loff_t l = 0;
+
+        for (; t && l < *pos; t = t_next(m, t, &l))
+                ;
+
+        return t;
+}
+
+static void t_stop(struct seq_file *m, void *p)
+{
+}
+
+static int t_show(struct seq_file *m, void *v)
+{
+        const struct ftrace_pointer *fp = m->private;
+        struct ftrace_branch_data *p = v;
+        const char *f;
+        long percent;
+
+        if (v == (void *)1) {
+                if (fp->hit)
+                        seq_printf(m, "   miss      hit    %% ");
+                else
+                        seq_printf(m, " correct incorrect  %% ");
+                seq_printf(m, "       Function                "
+                              "  File              Line\n"
+                              " ------- ---------  - "
+                              "       --------                "
+                              "  ----              ----\n");
+                return 0;
+        }
+
+        /* Only print the file, not the path */
+        f = p->file + strlen(p->file);
+        while (f >= p->file && *f != '/')
+                f--;
+        f++;
+
+        /*
+         * The miss is overlayed on correct, and hit on incorrect.
+         */
+        if (p->correct) {
+                percent = p->incorrect * 100;
+                percent /= p->correct + p->incorrect;
+        } else
+                percent = p->incorrect ? 100 : -1;
+
+        seq_printf(m, "%8lu %8lu ",  p->correct, p->incorrect);
+        if (percent < 0)
+                seq_printf(m, "  X ");
+        else
+                seq_printf(m, "%3ld ", percent);
+        seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
+        return 0;
+}
+
+static struct seq_operations tracing_likely_seq_ops = {
+        .start          = t_start,
+        .next           = t_next,
+        .stop           = t_stop,
+        .show           = t_show,
+};
+
+static int tracing_branch_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        ret = seq_open(file, &tracing_likely_seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+                m->private = (void *)inode->i_private;
+        }
+
+        return ret;
+}
+
+static const struct file_operations tracing_branch_fops = {
+        .open           = tracing_branch_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+};
+
+#ifdef CONFIG_PROFILE_ALL_BRANCHES
+extern unsigned long __start_branch_profile[];
+extern unsigned long __stop_branch_profile[];
+
+static const struct ftrace_pointer ftrace_branch_pos = {
+        .start                  = __start_branch_profile,
+        .stop                   = __stop_branch_profile,
+        .hit                    = 1,
+};
+
+#endif /* CONFIG_PROFILE_ALL_BRANCHES */
+
+extern unsigned long __start_annotated_branch_profile[];
+extern unsigned long __stop_annotated_branch_profile[];
+
+static const struct ftrace_pointer ftrace_annotated_branch_pos = {
+        .start                  = __start_annotated_branch_profile,
+        .stop                   = __stop_annotated_branch_profile,
+};
+
+static __init int ftrace_branch_init(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+
+        entry = debugfs_create_file("profile_annotated_branch", 0444, d_tracer,
+                                    (void *)&ftrace_annotated_branch_pos,
+                                    &tracing_branch_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'profile_annotatet_branch' entry\n");
+
+#ifdef CONFIG_PROFILE_ALL_BRANCHES
+        entry = debugfs_create_file("profile_branch", 0444, d_tracer,
+                                    (void *)&ftrace_branch_pos,
+                                    &tracing_branch_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs"
+                           " 'profile_branch' entry\n");
+#endif
+
+        return 0;
+}
+
+device_initcall(ftrace_branch_init);
diff --git a/kernel/trace/trace_bts.c b/kernel/trace/trace_bts.c
new file mode 100644
index 000000000000..23b76e4690ef
--- /dev/null
+++ b/kernel/trace/trace_bts.c
@@ -0,0 +1,276 @@
+/*
+ * BTS tracer
+ *
+ * Copyright (C) 2008 Markus Metzger <markus.t.metzger@gmail.com>
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/debugfs.h>
+#include <linux/ftrace.h>
+#include <linux/kallsyms.h>
+
+#include <asm/ds.h>
+
+#include "trace.h"
+
+
+#define SIZEOF_BTS (1 << 13)
+
+static DEFINE_PER_CPU(struct bts_tracer *, tracer);
+static DEFINE_PER_CPU(unsigned char[SIZEOF_BTS], buffer);
+
+#define this_tracer per_cpu(tracer, smp_processor_id())
+#define this_buffer per_cpu(buffer, smp_processor_id())
+
+
+/*
+ * Information to interpret a BTS record.
+ * This will go into an in-kernel BTS interface.
+ */
+static unsigned char sizeof_field;
+static unsigned long debugctl_mask;
+
+#define sizeof_bts (3 * sizeof_field)
+
+static void bts_trace_cpuinit(struct cpuinfo_x86 *c)
+{
+        switch (c->x86) {
+        case 0x6:
+                switch (c->x86_model) {
+                case 0x0 ... 0xC:
+                        break;
+                case 0xD:
+                case 0xE: /* Pentium M */
+                        sizeof_field = sizeof(long);
+                        debugctl_mask = (1<<6)|(1<<7);
+                        break;
+                default:
+                        sizeof_field = 8;
+                        debugctl_mask = (1<<6)|(1<<7);
+                        break;
+                }
+                break;
+        case 0xF:
+                switch (c->x86_model) {
+                case 0x0:
+                case 0x1:
+                case 0x2: /* Netburst */
+                        sizeof_field = sizeof(long);
+                        debugctl_mask = (1<<2)|(1<<3);
+                        break;
+                default:
+                        /* sorry, don't know about them */
+                        break;
+                }
+                break;
+        default:
+                /* sorry, don't know about them */
+                break;
+        }
+}
+
+static inline void bts_enable(void)
+{
+        unsigned long debugctl;
+
+        rdmsrl(MSR_IA32_DEBUGCTLMSR, debugctl);
+        wrmsrl(MSR_IA32_DEBUGCTLMSR, debugctl | debugctl_mask);
+}
+
+static inline void bts_disable(void)
+{
+        unsigned long debugctl;
+
+        rdmsrl(MSR_IA32_DEBUGCTLMSR, debugctl);
+        wrmsrl(MSR_IA32_DEBUGCTLMSR, debugctl & ~debugctl_mask);
+}
+
+static void bts_trace_reset(struct trace_array *tr)
+{
+        int cpu;
+
+        tr->time_start = ftrace_now(tr->cpu);
+
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+}
+
+static void bts_trace_start_cpu(void *arg)
+{
+        this_tracer =
+                ds_request_bts(/* task = */ NULL, this_buffer, SIZEOF_BTS,
+                               /* ovfl = */ NULL, /* th = */ (size_t)-1);
+        if (IS_ERR(this_tracer)) {
+                this_tracer = NULL;
+                return;
+        }
+
+        bts_enable();
+}
+
+static void bts_trace_start(struct trace_array *tr)
+{
+        int cpu;
+
+        bts_trace_reset(tr);
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                smp_call_function_single(cpu, bts_trace_start_cpu, NULL, 1);
+}
+
+static void bts_trace_stop_cpu(void *arg)
+{
+        if (this_tracer) {
+                bts_disable();
+
+                ds_release_bts(this_tracer);
+                this_tracer = NULL;
+        }
+}
+
+static void bts_trace_stop(struct trace_array *tr)
+{
+        int cpu;
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                smp_call_function_single(cpu, bts_trace_stop_cpu, NULL, 1);
+}
+
+static int bts_trace_init(struct trace_array *tr)
+{
+        bts_trace_cpuinit(&boot_cpu_data);
+        bts_trace_reset(tr);
+        bts_trace_start(tr);
+
+        return 0;
+}
+
+static void bts_trace_print_header(struct seq_file *m)
+{
+#ifdef __i386__
+        seq_puts(m, "# CPU#    FROM           TO     FUNCTION\n");
+        seq_puts(m, "#  |       |             |         |\n");
+#else
+        seq_puts(m,
+                 "# CPU#        FROM                   TO         FUNCTION\n");
+        seq_puts(m,
+                 "#  |           |                     |             |\n");
+#endif
+}
+
+static enum print_line_t bts_trace_print_line(struct trace_iterator *iter)
+{
+        struct trace_entry *entry = iter->ent;
+        struct trace_seq *seq = &iter->seq;
+        struct bts_entry *it;
+
+        trace_assign_type(it, entry);
+
+        if (entry->type == TRACE_BTS) {
+                int ret;
+#ifdef CONFIG_KALLSYMS
+                char function[KSYM_SYMBOL_LEN];
+                sprint_symbol(function, it->from);
+#else
+                char *function = "<unknown>";
+#endif
+
+                ret = trace_seq_printf(seq, "%4d  0x%lx -> 0x%lx [%s]\n",
+                                       entry->cpu, it->from, it->to, function);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;;
+                return TRACE_TYPE_HANDLED;
+        }
+        return TRACE_TYPE_UNHANDLED;
+}
+
+void trace_bts(struct trace_array *tr, unsigned long from, unsigned long to)
+{
+        struct ring_buffer_event *event;
+        struct bts_entry *entry;
+        unsigned long irq;
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry), &irq);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, from);
+        entry->ent.type = TRACE_BTS;
+        entry->ent.cpu = smp_processor_id();
+        entry->from = from;
+        entry->to   = to;
+        ring_buffer_unlock_commit(tr->buffer, event, irq);
+}
+
+static void trace_bts_at(struct trace_array *tr, size_t index)
+{
+        const void *raw = NULL;
+        unsigned long from, to;
+        int err;
+
+        err = ds_access_bts(this_tracer, index, &raw);
+        if (err < 0)
+                return;
+
+        from = *(const unsigned long *)raw;
+        to = *(const unsigned long *)((const char *)raw + sizeof_field);
+
+        trace_bts(tr, from, to);
+}
+
+static void trace_bts_cpu(void *arg)
+{
+        struct trace_array *tr = (struct trace_array *) arg;
+        size_t index = 0, end = 0, i;
+        int err;
+
+        if (!this_tracer)
+                return;
+
+        bts_disable();
+
+        err = ds_get_bts_index(this_tracer, &index);
+        if (err < 0)
+                goto out;
+
+        err = ds_get_bts_end(this_tracer, &end);
+        if (err < 0)
+                goto out;
+
+        for (i = index; i < end; i++)
+                trace_bts_at(tr, i);
+
+        for (i = 0; i < index; i++)
+                trace_bts_at(tr, i);
+
+out:
+        bts_enable();
+}
+
+static void trace_bts_prepare(struct trace_iterator *iter)
+{
+        int cpu;
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                smp_call_function_single(cpu, trace_bts_cpu, iter->tr, 1);
+}
+
+struct tracer bts_tracer __read_mostly =
+{
+        .name           = "bts",
+        .init           = bts_trace_init,
+        .reset          = bts_trace_stop,
+        .print_header   = bts_trace_print_header,
+        .print_line     = bts_trace_print_line,
+        .start          = bts_trace_start,
+        .stop           = bts_trace_stop,
+        .open           = trace_bts_prepare
+};
+
+__init static int init_bts_trace(void)
+{
+        return register_tracer(&bts_tracer);
+}
+device_initcall(init_bts_trace);
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 0f85a64003d3..e74f6d0a3216 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -42,24 +42,20 @@ static void stop_function_trace(struct trace_array *tr)
         tracing_stop_cmdline_record();
 }
 
-static void function_trace_init(struct trace_array *tr)
+static int function_trace_init(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                start_function_trace(tr);
+        start_function_trace(tr);
+        return 0;
 }
 
 static void function_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                stop_function_trace(tr);
+        stop_function_trace(tr);
 }
 
-static void function_trace_ctrl_update(struct trace_array *tr)
+static void function_trace_start(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                start_function_trace(tr);
-        else
-                stop_function_trace(tr);
+        function_reset(tr);
 }
 
 static struct tracer function_trace __read_mostly =
@@ -67,7 +63,7 @@ static struct tracer function_trace __read_mostly =
         .name        = "function",
         .init        = function_trace_init,
         .reset       = function_trace_reset,
-        .ctrl_update = function_trace_ctrl_update,
+        .start       = function_trace_start,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_function,
 #endif
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
new file mode 100644
index 000000000000..af60eef4cbcc
--- /dev/null
+++ b/kernel/trace/trace_functions_graph.c
@@ -0,0 +1,611 @@
+/*
+ *
+ * Function graph tracer.
+ * Copyright (c) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ * Mostly borrowed from function tracer which
+ * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/ftrace.h>
+#include <linux/fs.h>
+
+#include "trace.h"
+
+#define TRACE_GRAPH_INDENT      2
+
+/* Flag options */
+#define TRACE_GRAPH_PRINT_OVERRUN       0x1
+#define TRACE_GRAPH_PRINT_CPU           0x2
+#define TRACE_GRAPH_PRINT_OVERHEAD      0x4
+#define TRACE_GRAPH_PRINT_PROC          0x8
+
+static struct tracer_opt trace_opts[] = {
+        /* Display overruns ? */
+        { TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
+        /* Display CPU ? */
+        { TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
+        /* Display Overhead ? */
+        { TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
+        /* Display proc name/pid */
+        { TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
+        { } /* Empty entry */
+};
+
+static struct tracer_flags tracer_flags = {
+        /* Don't display overruns and proc by default */
+        .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD,
+        .opts = trace_opts
+};
+
+/* pid on the last trace processed */
+static pid_t last_pid[NR_CPUS] = { [0 ... NR_CPUS-1] = -1 };
+
+static int graph_trace_init(struct trace_array *tr)
+{
+        int cpu, ret;
+
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+
+        ret = register_ftrace_graph(&trace_graph_return,
+                                        &trace_graph_entry);
+        if (ret)
+                return ret;
+        tracing_start_cmdline_record();
+
+        return 0;
+}
+
+static void graph_trace_reset(struct trace_array *tr)
+{
+        tracing_stop_cmdline_record();
+        unregister_ftrace_graph();
+}
+
+static inline int log10_cpu(int nb)
+{
+        if (nb / 100)
+                return 3;
+        if (nb / 10)
+                return 2;
+        return 1;
+}
+
+static enum print_line_t
+print_graph_cpu(struct trace_seq *s, int cpu)
+{
+        int i;
+        int ret;
+        int log10_this = log10_cpu(cpu);
+        int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));
+
+
+        /*
+         * Start with a space character - to make it stand out
+         * to the right a bit when trace output is pasted into
+         * email:
+         */
+        ret = trace_seq_printf(s, " ");
+
+        /*
+         * Tricky - we space the CPU field according to the max
+         * number of online CPUs. On a 2-cpu system it would take
+         * a maximum of 1 digit - on a 128 cpu system it would
+         * take up to 3 digits:
+         */
+        for (i = 0; i < log10_all - log10_this; i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+        ret = trace_seq_printf(s, "%d) ", cpu);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+#define TRACE_GRAPH_PROCINFO_LENGTH     14
+
+static enum print_line_t
+print_graph_proc(struct trace_seq *s, pid_t pid)
+{
+        int i;
+        int ret;
+        int len;
+        char comm[8];
+        int spaces = 0;
+        /* sign + log10(MAX_INT) + '\0' */
+        char pid_str[11];
+
+        strncpy(comm, trace_find_cmdline(pid), 7);
+        comm[7] = '\0';
+        sprintf(pid_str, "%d", pid);
+
+        /* 1 stands for the "-" character */
+        len = strlen(comm) + strlen(pid_str) + 1;
+
+        if (len < TRACE_GRAPH_PROCINFO_LENGTH)
+                spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
+
+        /* First spaces to align center */
+        for (i = 0; i < spaces / 2; i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Last spaces to align center */
+        for (i = 0; i < spaces - (spaces / 2); i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+        return TRACE_TYPE_HANDLED;
+}
+
+
+/* If the pid changed since the last trace, output this event */
+static enum print_line_t
+verif_pid(struct trace_seq *s, pid_t pid, int cpu)
+{
+        pid_t prev_pid;
+        int ret;
+
+        if (last_pid[cpu] != -1 && last_pid[cpu] == pid)
+                return TRACE_TYPE_HANDLED;
+
+        prev_pid = last_pid[cpu];
+        last_pid[cpu] = pid;
+
+/*
+ * Context-switch trace line:
+
+ ------------------------------------------
+ | 1)  migration/0--1  =>  sshd-1755
+ ------------------------------------------
+
+ */
+        ret = trace_seq_printf(s,
+                " ------------------------------------------\n");
+        if (!ret)
+                TRACE_TYPE_PARTIAL_LINE;
+
+        ret = print_graph_cpu(s, cpu);
+        if (ret == TRACE_TYPE_PARTIAL_LINE)
+                TRACE_TYPE_PARTIAL_LINE;
+
+        ret = print_graph_proc(s, prev_pid);
+        if (ret == TRACE_TYPE_PARTIAL_LINE)
+                TRACE_TYPE_PARTIAL_LINE;
+
+        ret = trace_seq_printf(s, " => ");
+        if (!ret)
+                TRACE_TYPE_PARTIAL_LINE;
+
+        ret = print_graph_proc(s, pid);
+        if (ret == TRACE_TYPE_PARTIAL_LINE)
+                TRACE_TYPE_PARTIAL_LINE;
+
+        ret = trace_seq_printf(s,
+                "\n ------------------------------------------\n\n");
+        if (!ret)
+                TRACE_TYPE_PARTIAL_LINE;
+
+        return ret;
+}
+
+static bool
+trace_branch_is_leaf(struct trace_iterator *iter,
+                struct ftrace_graph_ent_entry *curr)
+{
+        struct ring_buffer_iter *ring_iter;
+        struct ring_buffer_event *event;
+        struct ftrace_graph_ret_entry *next;
+
+        ring_iter = iter->buffer_iter[iter->cpu];
+
+        if (!ring_iter)
+                return false;
+
+        event = ring_buffer_iter_peek(ring_iter, NULL);
+
+        if (!event)
+                return false;
+
+        next = ring_buffer_event_data(event);
+
+        if (next->ent.type != TRACE_GRAPH_RET)
+                return false;
+
+        if (curr->ent.pid != next->ent.pid ||
+                        curr->graph_ent.func != next->ret.func)
+                return false;
+
+        return true;
+}
+
+
+static enum print_line_t
+print_graph_duration(unsigned long long duration, struct trace_seq *s)
+{
+        unsigned long nsecs_rem = do_div(duration, 1000);
+        /* log10(ULONG_MAX) + '\0' */
+        char msecs_str[21];
+        char nsecs_str[5];
+        int ret, len;
+        int i;
+
+        sprintf(msecs_str, "%lu", (unsigned long) duration);
+
+        /* Print msecs */
+        ret = trace_seq_printf(s, msecs_str);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        len = strlen(msecs_str);
+
+        /* Print nsecs (we don't want to exceed 7 numbers) */
+        if (len < 7) {
+                snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
+                ret = trace_seq_printf(s, ".%s", nsecs_str);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                len += strlen(nsecs_str);
+        }
+
+        ret = trace_seq_printf(s, " us ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Print remaining spaces to fit the row's width */
+        for (i = len; i < 7; i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        ret = trace_seq_printf(s, "|  ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+        return TRACE_TYPE_HANDLED;
+
+}
+
+/* Signal a overhead of time execution to the output */
+static int
+print_graph_overhead(unsigned long long duration, struct trace_seq *s)
+{
+        /* Duration exceeded 100 msecs */
+        if (duration > 100000ULL)
+                return trace_seq_printf(s, "! ");
+
+        /* Duration exceeded 10 msecs */
+        if (duration > 10000ULL)
+                return trace_seq_printf(s, "+ ");
+
+        return trace_seq_printf(s, "  ");
+}
+
+/* Case of a leaf function on its call entry */
+static enum print_line_t
+print_graph_entry_leaf(struct trace_iterator *iter,
+                struct ftrace_graph_ent_entry *entry, struct trace_seq *s)
+{
+        struct ftrace_graph_ret_entry *ret_entry;
+        struct ftrace_graph_ret *graph_ret;
+        struct ring_buffer_event *event;
+        struct ftrace_graph_ent *call;
+        unsigned long long duration;
+        int ret;
+        int i;
+
+        event = ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
+        ret_entry = ring_buffer_event_data(event);
+        graph_ret = &ret_entry->ret;
+        call = &entry->graph_ent;
+        duration = graph_ret->rettime - graph_ret->calltime;
+
+        /* Overhead */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                ret = print_graph_overhead(duration, s);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* Duration */
+        ret = print_graph_duration(duration, s);
+        if (ret == TRACE_TYPE_PARTIAL_LINE)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Function */
+        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        ret = seq_print_ip_sym(s, call->func, 0);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        ret = trace_seq_printf(s, "();\n");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
+                        struct trace_seq *s)
+{
+        int i;
+        int ret;
+        struct ftrace_graph_ent *call = &entry->graph_ent;
+
+        /* No overhead */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                ret = trace_seq_printf(s, "  ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* No time */
+        ret = trace_seq_printf(s, "            |  ");
+
+        /* Function */
+        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        ret = seq_print_ip_sym(s, call->func, 0);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        ret = trace_seq_printf(s, "() {\n");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
+                        struct trace_iterator *iter, int cpu)
+{
+        int ret;
+        struct trace_entry *ent = iter->ent;
+
+        /* Pid */
+        if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Cpu */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
+                ret = print_graph_cpu(s, cpu);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* Proc */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
+                ret = print_graph_proc(s, ent->pid);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+
+                ret = trace_seq_printf(s, " | ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        if (trace_branch_is_leaf(iter, field))
+                return print_graph_entry_leaf(iter, field, s);
+        else
+                return print_graph_entry_nested(field, s);
+
+}
+
+static enum print_line_t
+print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
+                   struct trace_entry *ent, int cpu)
+{
+        int i;
+        int ret;
+        unsigned long long duration = trace->rettime - trace->calltime;
+
+        /* Pid */
+        if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Cpu */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
+                ret = print_graph_cpu(s, cpu);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* Proc */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
+                ret = print_graph_proc(s, ent->pid);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+
+                ret = trace_seq_printf(s, " | ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* Overhead */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                ret = print_graph_overhead(duration, s);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* Duration */
+        ret = print_graph_duration(duration, s);
+        if (ret == TRACE_TYPE_PARTIAL_LINE)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Closing brace */
+        for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
+                ret = trace_seq_printf(s, " ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        ret = trace_seq_printf(s, "}\n");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Overrun */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {
+                ret = trace_seq_printf(s, " (Overruns: %lu)\n",
+                                        trace->overrun);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+print_graph_comment(struct print_entry *trace, struct trace_seq *s,
+                   struct trace_entry *ent, struct trace_iterator *iter)
+{
+        int i;
+        int ret;
+
+        /* Pid */
+        if (verif_pid(s, ent->pid, iter->cpu) == TRACE_TYPE_PARTIAL_LINE)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Cpu */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
+                ret = print_graph_cpu(s, iter->cpu);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* Proc */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
+                ret = print_graph_proc(s, ent->pid);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+
+                ret = trace_seq_printf(s, " | ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* No overhead */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                ret = trace_seq_printf(s, "  ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+        /* No time */
+        ret = trace_seq_printf(s, "            |  ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Indentation */
+        if (trace->depth > 0)
+                for (i = 0; i < (trace->depth + 1) * TRACE_GRAPH_INDENT; i++) {
+                        ret = trace_seq_printf(s, " ");
+                        if (!ret)
+                                return TRACE_TYPE_PARTIAL_LINE;
+                }
+
+        /* The comment */
+        ret = trace_seq_printf(s, "/* %s", trace->buf);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (ent->flags & TRACE_FLAG_CONT)
+                trace_seq_print_cont(s, iter);
+
+        ret = trace_seq_printf(s, " */\n");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+
+enum print_line_t
+print_graph_function(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *entry = iter->ent;
+
+        switch (entry->type) {
+        case TRACE_GRAPH_ENT: {
+                struct ftrace_graph_ent_entry *field;
+                trace_assign_type(field, entry);
+                return print_graph_entry(field, s, iter,
+                                         iter->cpu);
+        }
+        case TRACE_GRAPH_RET: {
+                struct ftrace_graph_ret_entry *field;
+                trace_assign_type(field, entry);
+                return print_graph_return(&field->ret, s, entry, iter->cpu);
+        }
+        case TRACE_PRINT: {
+                struct print_entry *field;
+                trace_assign_type(field, entry);
+                return print_graph_comment(field, s, entry, iter);
+        }
+        default:
+                return TRACE_TYPE_UNHANDLED;
+        }
+}
+
+static void print_graph_headers(struct seq_file *s)
+{
+        /* 1st line */
+        seq_printf(s, "# ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
+                seq_printf(s, "CPU ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
+                seq_printf(s, "TASK/PID     ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD)
+                seq_printf(s, "OVERHEAD/");
+        seq_printf(s, "DURATION            FUNCTION CALLS\n");
+
+        /* 2nd line */
+        seq_printf(s, "# ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
+                seq_printf(s, "|   ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
+                seq_printf(s, "|      |     ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                seq_printf(s, "|        ");
+                seq_printf(s, "|                   |   |   |   |\n");
+        } else
+                seq_printf(s, "    |               |   |   |   |\n");
+}
+static struct tracer graph_trace __read_mostly = {
+        .name           = "function_graph",
+        .init           = graph_trace_init,
+        .reset          = graph_trace_reset,
+        .print_line     = print_graph_function,
+        .print_header   = print_graph_headers,
+        .flags          = &tracer_flags,
+};
+
+static __init int init_graph_trace(void)
+{
+        return register_tracer(&graph_trace);
+}
+
+device_initcall(init_graph_trace);
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 9c74071c10e0..7c2e326bbc8b 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -353,15 +353,28 @@ void trace_preempt_off(unsigned long a0, unsigned long a1)
 }
 #endif /* CONFIG_PREEMPT_TRACER */
 
+/*
+ * save_tracer_enabled is used to save the state of the tracer_enabled
+ * variable when we disable it when we open a trace output file.
+ */
+static int save_tracer_enabled;
+
 static void start_irqsoff_tracer(struct trace_array *tr)
 {
         register_ftrace_function(&trace_ops);
-        tracer_enabled = 1;
+        if (tracing_is_enabled()) {
+                tracer_enabled = 1;
+                save_tracer_enabled = 1;
+        } else {
+                tracer_enabled = 0;
+                save_tracer_enabled = 0;
+        }
 }
 
 static void stop_irqsoff_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
+        save_tracer_enabled = 0;
         unregister_ftrace_function(&trace_ops);
 }
 
@@ -370,53 +383,55 @@ static void __irqsoff_tracer_init(struct trace_array *tr)
         irqsoff_trace = tr;
         /* make sure that the tracer is visible */
         smp_wmb();
-
-        if (tr->ctrl)
-                start_irqsoff_tracer(tr);
+        start_irqsoff_tracer(tr);
 }
 
 static void irqsoff_tracer_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                stop_irqsoff_tracer(tr);
+        stop_irqsoff_tracer(tr);
 }
 
-static void irqsoff_tracer_ctrl_update(struct trace_array *tr)
+static void irqsoff_tracer_start(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                start_irqsoff_tracer(tr);
-        else
-                stop_irqsoff_tracer(tr);
+        tracer_enabled = 1;
+        save_tracer_enabled = 1;
+}
+
+static void irqsoff_tracer_stop(struct trace_array *tr)
+{
+        tracer_enabled = 0;
+        save_tracer_enabled = 0;
 }
 
 static void irqsoff_tracer_open(struct trace_iterator *iter)
 {
         /* stop the trace while dumping */
-        if (iter->tr->ctrl)
-                stop_irqsoff_tracer(iter->tr);
+        tracer_enabled = 0;
 }
 
 static void irqsoff_tracer_close(struct trace_iterator *iter)
 {
-        if (iter->tr->ctrl)
-                start_irqsoff_tracer(iter->tr);
+        /* restart tracing */
+        tracer_enabled = save_tracer_enabled;
 }
 
 #ifdef CONFIG_IRQSOFF_TRACER
-static void irqsoff_tracer_init(struct trace_array *tr)
+static int irqsoff_tracer_init(struct trace_array *tr)
 {
         trace_type = TRACER_IRQS_OFF;
 
         __irqsoff_tracer_init(tr);
+        return 0;
 }
 static struct tracer irqsoff_tracer __read_mostly =
 {
         .name           = "irqsoff",
         .init           = irqsoff_tracer_init,
         .reset          = irqsoff_tracer_reset,
+        .start          = irqsoff_tracer_start,
+        .stop           = irqsoff_tracer_stop,
         .open           = irqsoff_tracer_open,
         .close          = irqsoff_tracer_close,
-        .ctrl_update    = irqsoff_tracer_ctrl_update,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_irqsoff,
@@ -428,11 +443,12 @@ static struct tracer irqsoff_tracer __read_mostly =
 #endif
 
 #ifdef CONFIG_PREEMPT_TRACER
-static void preemptoff_tracer_init(struct trace_array *tr)
+static int preemptoff_tracer_init(struct trace_array *tr)
 {
         trace_type = TRACER_PREEMPT_OFF;
 
         __irqsoff_tracer_init(tr);
+        return 0;
 }
 
 static struct tracer preemptoff_tracer __read_mostly =
@@ -440,9 +456,10 @@ static struct tracer preemptoff_tracer __read_mostly =
         .name           = "preemptoff",
         .init           = preemptoff_tracer_init,
         .reset          = irqsoff_tracer_reset,
+        .start          = irqsoff_tracer_start,
+        .stop           = irqsoff_tracer_stop,
         .open           = irqsoff_tracer_open,
         .close          = irqsoff_tracer_close,
-        .ctrl_update    = irqsoff_tracer_ctrl_update,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_preemptoff,
@@ -456,11 +473,12 @@ static struct tracer preemptoff_tracer __read_mostly =
 #if defined(CONFIG_IRQSOFF_TRACER) && \
         defined(CONFIG_PREEMPT_TRACER)
 
-static void preemptirqsoff_tracer_init(struct trace_array *tr)
+static int preemptirqsoff_tracer_init(struct trace_array *tr)
 {
         trace_type = TRACER_IRQS_OFF | TRACER_PREEMPT_OFF;
 
         __irqsoff_tracer_init(tr);
+        return 0;
 }
 
 static struct tracer preemptirqsoff_tracer __read_mostly =
@@ -468,9 +486,10 @@ static struct tracer preemptirqsoff_tracer __read_mostly =
         .name           = "preemptirqsoff",
         .init           = preemptirqsoff_tracer_init,
         .reset          = irqsoff_tracer_reset,
+        .start          = irqsoff_tracer_start,
+        .stop           = irqsoff_tracer_stop,
         .open           = irqsoff_tracer_open,
         .close          = irqsoff_tracer_close,
-        .ctrl_update    = irqsoff_tracer_ctrl_update,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_preemptirqsoff,
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index f28484618ff0..2fb6da6523b3 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -18,46 +18,43 @@ struct header_iter {
 
 static struct trace_array *mmio_trace_array;
 static bool overrun_detected;
+static unsigned long prev_overruns;
 
 static void mmio_reset_data(struct trace_array *tr)
 {
         int cpu;
 
         overrun_detected = false;
+        prev_overruns = 0;
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
                 tracing_reset(tr, cpu);
 }
 
-static void mmio_trace_init(struct trace_array *tr)
+static int mmio_trace_init(struct trace_array *tr)
 {
         pr_debug("in %s\n", __func__);
         mmio_trace_array = tr;
-        if (tr->ctrl) {
-                mmio_reset_data(tr);
-                enable_mmiotrace();
-        }
+
+        mmio_reset_data(tr);
+        enable_mmiotrace();
+        return 0;
 }
 
 static void mmio_trace_reset(struct trace_array *tr)
 {
         pr_debug("in %s\n", __func__);
-        if (tr->ctrl)
-                disable_mmiotrace();
+
+        disable_mmiotrace();
         mmio_reset_data(tr);
         mmio_trace_array = NULL;
 }
 
-static void mmio_trace_ctrl_update(struct trace_array *tr)
+static void mmio_trace_start(struct trace_array *tr)
 {
         pr_debug("in %s\n", __func__);
-        if (tr->ctrl) {
-                mmio_reset_data(tr);
-                enable_mmiotrace();
-        } else {
-                disable_mmiotrace();
-        }
+        mmio_reset_data(tr);
 }
 
 static int mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
@@ -128,16 +125,12 @@ static void mmio_close(struct trace_iterator *iter)
 
 static unsigned long count_overruns(struct trace_iterator *iter)
 {
-        int cpu;
         unsigned long cnt = 0;
-/* FIXME: */
-#if 0
-        for_each_online_cpu(cpu) {
-                cnt += iter->overrun[cpu];
-                iter->overrun[cpu] = 0;
-        }
-#endif
-        (void)cpu;
+        unsigned long over = ring_buffer_overruns(iter->tr->buffer);
+
+        if (over > prev_overruns)
+                cnt = over - prev_overruns;
+        prev_overruns = over;
         return cnt;
 }
 
@@ -298,10 +291,10 @@ static struct tracer mmio_tracer __read_mostly =
         .name           = "mmiotrace",
         .init           = mmio_trace_init,
         .reset          = mmio_trace_reset,
+        .start          = mmio_trace_start,
         .pipe_open      = mmio_pipe_open,
         .close          = mmio_close,
         .read           = mmio_read,
-        .ctrl_update    = mmio_trace_ctrl_update,
         .print_line     = mmio_print_line,
 };
 
@@ -373,5 +366,5 @@ void mmio_trace_mapping(struct mmiotrace_map *map)
 
 int mmio_trace_printk(const char *fmt, va_list args)
 {
-        return trace_vprintk(0, fmt, args);
+        return trace_vprintk(0, -1, fmt, args);
 }
diff --git a/kernel/trace/trace_nop.c b/kernel/trace/trace_nop.c
index 4592b4862515..b9767acd30ac 100644
--- a/kernel/trace/trace_nop.c
+++ b/kernel/trace/trace_nop.c
@@ -12,6 +12,27 @@
 
 #include "trace.h"
 
+/* Our two options */
+enum {
+        TRACE_NOP_OPT_ACCEPT = 0x1,
+        TRACE_NOP_OPT_REFUSE = 0x2
+};
+
+/* Options for the tracer (see trace_options file) */
+static struct tracer_opt nop_opts[] = {
+        /* Option that will be accepted by set_flag callback */
+        { TRACER_OPT(test_nop_accept, TRACE_NOP_OPT_ACCEPT) },
+        /* Option that will be refused by set_flag callback */
+        { TRACER_OPT(test_nop_refuse, TRACE_NOP_OPT_REFUSE) },
+        { } /* Always set a last empty entry */
+};
+
+static struct tracer_flags nop_flags = {
+        /* You can check your flags value here when you want. */
+        .val = 0, /* By default: all flags disabled */
+        .opts = nop_opts
+};
+
 static struct trace_array       *ctx_trace;
 
 static void start_nop_trace(struct trace_array *tr)
@@ -24,7 +45,7 @@ static void stop_nop_trace(struct trace_array *tr)
         /* Nothing to do! */
 }
 
-static void nop_trace_init(struct trace_array *tr)
+static int nop_trace_init(struct trace_array *tr)
 {
         int cpu;
         ctx_trace = tr;
@@ -32,33 +53,53 @@ static void nop_trace_init(struct trace_array *tr)
         for_each_online_cpu(cpu)
                 tracing_reset(tr, cpu);
 
-        if (tr->ctrl)
-                start_nop_trace(tr);
+        start_nop_trace(tr);
+        return 0;
 }
 
 static void nop_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                stop_nop_trace(tr);
+        stop_nop_trace(tr);
 }
 
-static void nop_trace_ctrl_update(struct trace_array *tr)
+/* It only serves as a signal handler and a callback to
+ * accept or refuse tthe setting of a flag.
+ * If you don't implement it, then the flag setting will be
+ * automatically accepted.
+ */
+static int nop_set_flag(u32 old_flags, u32 bit, int set)
 {
-        /* When starting a new trace, reset the buffers */
-        if (tr->ctrl)
-                start_nop_trace(tr);
-        else
-                stop_nop_trace(tr);
+        /*
+         * Note that you don't need to update nop_flags.val yourself.
+         * The tracing Api will do it automatically if you return 0
+         */
+        if (bit == TRACE_NOP_OPT_ACCEPT) {
+                printk(KERN_DEBUG "nop_test_accept flag set to %d: we accept."
+                        " Now cat trace_options to see the result\n",
+                        set);
+                return 0;
+        }
+
+        if (bit == TRACE_NOP_OPT_REFUSE) {
+                printk(KERN_DEBUG "nop_test_refuse flag set to %d: we refuse."
+                        "Now cat trace_options to see the result\n",
+                        set);
+                return -EINVAL;
+        }
+
+        return 0;
 }
 
+
 struct tracer nop_trace __read_mostly =
 {
         .name           = "nop",
         .init           = nop_trace_init,
         .reset          = nop_trace_reset,
-        .ctrl_update    = nop_trace_ctrl_update,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest       = trace_selftest_startup_nop,
 #endif
+        .flags          = &nop_flags,
+        .set_flag       = nop_set_flag
 };
 
diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
new file mode 100644
index 000000000000..a7172a352f62
--- /dev/null
+++ b/kernel/trace/trace_power.c
@@ -0,0 +1,179 @@
+/*
+ * ring buffer based C-state tracer
+ *
+ * Arjan van de Ven <arjan@linux.intel.com>
+ * Copyright (C) 2008 Intel Corporation
+ *
+ * Much is borrowed from trace_boot.c which is
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/debugfs.h>
+#include <linux/ftrace.h>
+#include <linux/kallsyms.h>
+#include <linux/module.h>
+
+#include "trace.h"
+
+static struct trace_array *power_trace;
+static int __read_mostly trace_power_enabled;
+
+
+static void start_power_trace(struct trace_array *tr)
+{
+        trace_power_enabled = 1;
+}
+
+static void stop_power_trace(struct trace_array *tr)
+{
+        trace_power_enabled = 0;
+}
+
+
+static int power_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        power_trace = tr;
+
+        trace_power_enabled = 1;
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                tracing_reset(tr, cpu);
+        return 0;
+}
+
+static enum print_line_t power_print_line(struct trace_iterator *iter)
+{
+        int ret = 0;
+        struct trace_entry *entry = iter->ent;
+        struct trace_power *field ;
+        struct power_trace *it;
+        struct trace_seq *s = &iter->seq;
+        struct timespec stamp;
+        struct timespec duration;
+
+        trace_assign_type(field, entry);
+        it = &field->state_data;
+        stamp = ktime_to_timespec(it->stamp);
+        duration = ktime_to_timespec(ktime_sub(it->end, it->stamp));
+
+        if (entry->type == TRACE_POWER) {
+                if (it->type == POWER_CSTATE)
+                        ret = trace_seq_printf(s, "[%5ld.%09ld] CSTATE: Going to C%i on cpu %i for %ld.%09ld\n",
+                                          stamp.tv_sec,
+                                          stamp.tv_nsec,
+                                          it->state, iter->cpu,
+                                          duration.tv_sec,
+                                          duration.tv_nsec);
+                if (it->type == POWER_PSTATE)
+                        ret = trace_seq_printf(s, "[%5ld.%09ld] PSTATE: Going to P%i on cpu %i\n",
+                                          stamp.tv_sec,
+                                          stamp.tv_nsec,
+                                          it->state, iter->cpu);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_HANDLED;
+        }
+        return TRACE_TYPE_UNHANDLED;
+}
+
+static struct tracer power_tracer __read_mostly =
+{
+        .name           = "power",
+        .init           = power_trace_init,
+        .start          = start_power_trace,
+        .stop           = stop_power_trace,
+        .reset          = stop_power_trace,
+        .print_line     = power_print_line,
+};
+
+static int init_power_trace(void)
+{
+        return register_tracer(&power_tracer);
+}
+device_initcall(init_power_trace);
+
+void trace_power_start(struct power_trace *it, unsigned int type,
+                         unsigned int level)
+{
+        if (!trace_power_enabled)
+                return;
+
+        memset(it, 0, sizeof(struct power_trace));
+        it->state = level;
+        it->type = type;
+        it->stamp = ktime_get();
+}
+EXPORT_SYMBOL_GPL(trace_power_start);
+
+
+void trace_power_end(struct power_trace *it)
+{
+        struct ring_buffer_event *event;
+        struct trace_power *entry;
+        struct trace_array_cpu *data;
+        unsigned long irq_flags;
+        struct trace_array *tr = power_trace;
+
+        if (!trace_power_enabled)
+                return;
+
+        preempt_disable();
+        it->end = ktime_get();
+        data = tr->data[smp_processor_id()];
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type = TRACE_POWER;
+        entry->state_data = *it;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+
+ out:
+        preempt_enable();
+}
+EXPORT_SYMBOL_GPL(trace_power_end);
+
+void trace_power_mark(struct power_trace *it, unsigned int type,
+                         unsigned int level)
+{
+        struct ring_buffer_event *event;
+        struct trace_power *entry;
+        struct trace_array_cpu *data;
+        unsigned long irq_flags;
+        struct trace_array *tr = power_trace;
+
+        if (!trace_power_enabled)
+                return;
+
+        memset(it, 0, sizeof(struct power_trace));
+        it->state = level;
+        it->type = type;
+        it->stamp = ktime_get();
+        preempt_disable();
+        it->end = it->stamp;
+        data = tr->data[smp_processor_id()];
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type = TRACE_POWER;
+        entry->state_data = *it;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+
+ out:
+        preempt_enable();
+}
+EXPORT_SYMBOL_GPL(trace_power_mark);
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index b8f56beb1a62..863390557b44 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -16,7 +16,8 @@
 
 static struct trace_array       *ctx_trace;
 static int __read_mostly        tracer_enabled;
-static atomic_t                 sched_ref;
+static int                      sched_ref;
+static DEFINE_MUTEX(sched_register_mutex);
 
 static void
 probe_sched_switch(struct rq *__rq, struct task_struct *prev,
@@ -27,7 +28,7 @@ probe_sched_switch(struct rq *__rq, struct task_struct *prev,
         int cpu;
         int pc;
 
-        if (!atomic_read(&sched_ref))
+        if (!sched_ref)
                 return;
 
         tracing_record_cmdline(prev);
@@ -123,20 +124,18 @@ static void tracing_sched_unregister(void)
 
 static void tracing_start_sched_switch(void)
 {
-        long ref;
-
-        ref = atomic_inc_return(&sched_ref);
-        if (ref == 1)
+        mutex_lock(&sched_register_mutex);
+        if (!(sched_ref++))
                 tracing_sched_register();
+        mutex_unlock(&sched_register_mutex);
 }
 
 static void tracing_stop_sched_switch(void)
 {
-        long ref;
-
-        ref = atomic_dec_and_test(&sched_ref);
-        if (ref)
+        mutex_lock(&sched_register_mutex);
+        if (!(--sched_ref))
                 tracing_sched_unregister();
+        mutex_unlock(&sched_register_mutex);
 }
 
 void tracing_start_cmdline_record(void)
@@ -149,40 +148,86 @@ void tracing_stop_cmdline_record(void)
         tracing_stop_sched_switch();
 }
 
+/**
+ * tracing_start_sched_switch_record - start tracing context switches
+ *
+ * Turns on context switch tracing for a tracer.
+ */
+void tracing_start_sched_switch_record(void)
+{
+        if (unlikely(!ctx_trace)) {
+                WARN_ON(1);
+                return;
+        }
+
+        tracing_start_sched_switch();
+
+        mutex_lock(&sched_register_mutex);
+        tracer_enabled++;
+        mutex_unlock(&sched_register_mutex);
+}
+
+/**
+ * tracing_stop_sched_switch_record - start tracing context switches
+ *
+ * Turns off context switch tracing for a tracer.
+ */
+void tracing_stop_sched_switch_record(void)
+{
+        mutex_lock(&sched_register_mutex);
+        tracer_enabled--;
+        WARN_ON(tracer_enabled < 0);
+        mutex_unlock(&sched_register_mutex);
+
+        tracing_stop_sched_switch();
+}
+
+/**
+ * tracing_sched_switch_assign_trace - assign a trace array for ctx switch
+ * @tr: trace array pointer to assign
+ *
+ * Some tracers might want to record the context switches in their
+ * trace. This function lets those tracers assign the trace array
+ * to use.
+ */
+void tracing_sched_switch_assign_trace(struct trace_array *tr)
+{
+        ctx_trace = tr;
+}
+
 static void start_sched_trace(struct trace_array *tr)
 {
         sched_switch_reset(tr);
-        tracing_start_cmdline_record();
-        tracer_enabled = 1;
+        tracing_start_sched_switch_record();
 }
 
 static void stop_sched_trace(struct trace_array *tr)
 {
-        tracer_enabled = 0;
-        tracing_stop_cmdline_record();
+        tracing_stop_sched_switch_record();
 }
 
-static void sched_switch_trace_init(struct trace_array *tr)
+static int sched_switch_trace_init(struct trace_array *tr)
 {
         ctx_trace = tr;
-
-        if (tr->ctrl)
-                start_sched_trace(tr);
+        start_sched_trace(tr);
+        return 0;
 }
 
 static void sched_switch_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        if (sched_ref)
                 stop_sched_trace(tr);
 }
 
-static void sched_switch_trace_ctrl_update(struct trace_array *tr)
+static void sched_switch_trace_start(struct trace_array *tr)
 {
-        /* When starting a new trace, reset the buffers */
-        if (tr->ctrl)
-                start_sched_trace(tr);
-        else
-                stop_sched_trace(tr);
+        sched_switch_reset(tr);
+        tracing_start_sched_switch();
+}
+
+static void sched_switch_trace_stop(struct trace_array *tr)
+{
+        tracing_stop_sched_switch();
 }
 
 static struct tracer sched_switch_trace __read_mostly =
@@ -190,7 +235,8 @@ static struct tracer sched_switch_trace __read_mostly =
         .name           = "sched_switch",
         .init           = sched_switch_trace_init,
         .reset          = sched_switch_trace_reset,
-        .ctrl_update    = sched_switch_trace_ctrl_update,
+        .start          = sched_switch_trace_start,
+        .stop           = sched_switch_trace_stop,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_sched_switch,
 #endif
@@ -198,14 +244,6 @@ static struct tracer sched_switch_trace __read_mostly =
 
 __init static int init_sched_switch_trace(void)
 {
-        int ret = 0;
-
-        if (atomic_read(&sched_ref))
-                ret = tracing_sched_register();
-        if (ret) {
-                pr_info("error registering scheduler trace\n");
-                return ret;
-        }
         return register_tracer(&sched_switch_trace);
 }
 device_initcall(init_sched_switch_trace);
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 3ae93f16b565..0067b49746c1 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -50,8 +50,7 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
                 return;
 
         pc = preempt_count();
-        resched = need_resched();
-        preempt_disable_notrace();
+        resched = ftrace_preempt_disable();
 
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
@@ -81,15 +80,7 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
  out:
         atomic_dec(&data->disabled);
 
-        /*
-         * To prevent recursion from the scheduler, if the
-         * resched flag was set before we entered, then
-         * don't reschedule.
-         */
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
+        ftrace_preempt_enable(resched);
 }
 
 static struct ftrace_ops trace_ops __read_mostly =
@@ -271,6 +262,12 @@ out:
         atomic_dec(&wakeup_trace->data[cpu]->disabled);
 }
 
+/*
+ * save_tracer_enabled is used to save the state of the tracer_enabled
+ * variable when we disable it when we open a trace output file.
+ */
+static int save_tracer_enabled;
+
 static void start_wakeup_tracer(struct trace_array *tr)
 {
         int ret;
@@ -309,7 +306,13 @@ static void start_wakeup_tracer(struct trace_array *tr)
 
         register_ftrace_function(&trace_ops);
 
-        tracer_enabled = 1;
+        if (tracing_is_enabled()) {
+                tracer_enabled = 1;
+                save_tracer_enabled = 1;
+        } else {
+                tracer_enabled = 0;
+                save_tracer_enabled = 0;
+        }
 
         return;
 fail_deprobe_wake_new:
@@ -321,49 +324,53 @@ fail_deprobe:
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
+        save_tracer_enabled = 0;
         unregister_ftrace_function(&trace_ops);
         unregister_trace_sched_switch(probe_wakeup_sched_switch);
         unregister_trace_sched_wakeup_new(probe_wakeup);
         unregister_trace_sched_wakeup(probe_wakeup);
 }
 
-static void wakeup_tracer_init(struct trace_array *tr)
+static int wakeup_tracer_init(struct trace_array *tr)
 {
         wakeup_trace = tr;
-
-        if (tr->ctrl)
-                start_wakeup_tracer(tr);
+        start_wakeup_tracer(tr);
+        return 0;
 }
 
 static void wakeup_tracer_reset(struct trace_array *tr)
 {
-        if (tr->ctrl) {
-                stop_wakeup_tracer(tr);
-                /* make sure we put back any tasks we are tracing */
-                wakeup_reset(tr);
-        }
+        stop_wakeup_tracer(tr);
+        /* make sure we put back any tasks we are tracing */
+        wakeup_reset(tr);
+}
+
+static void wakeup_tracer_start(struct trace_array *tr)
+{
+        wakeup_reset(tr);
+        tracer_enabled = 1;
+        save_tracer_enabled = 1;
 }
 
-static void wakeup_tracer_ctrl_update(struct trace_array *tr)
+static void wakeup_tracer_stop(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                start_wakeup_tracer(tr);
-        else
-                stop_wakeup_tracer(tr);
+        tracer_enabled = 0;
+        save_tracer_enabled = 0;
 }
 
 static void wakeup_tracer_open(struct trace_iterator *iter)
 {
         /* stop the trace while dumping */
-        if (iter->tr->ctrl)
-                stop_wakeup_tracer(iter->tr);
+        tracer_enabled = 0;
 }
 
 static void wakeup_tracer_close(struct trace_iterator *iter)
 {
         /* forget about any processes we were recording */
-        if (iter->tr->ctrl)
-                start_wakeup_tracer(iter->tr);
+        if (save_tracer_enabled) {
+                wakeup_reset(iter->tr);
+                tracer_enabled = 1;
+        }
 }
 
 static struct tracer wakeup_tracer __read_mostly =
@@ -371,9 +378,10 @@ static struct tracer wakeup_tracer __read_mostly =
         .name           = "wakeup",
         .init           = wakeup_tracer_init,
         .reset          = wakeup_tracer_reset,
+        .start          = wakeup_tracer_start,
+        .stop           = wakeup_tracer_stop,
         .open           = wakeup_tracer_open,
         .close          = wakeup_tracer_close,
-        .ctrl_update    = wakeup_tracer_ctrl_update,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_wakeup,
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 90bc752a7580..88c8eb70f54a 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -13,6 +13,7 @@ static inline int trace_valid_entry(struct trace_entry *entry)
         case TRACE_STACK:
         case TRACE_PRINT:
         case TRACE_SPECIAL:
+        case TRACE_BRANCH:
                 return 1;
         }
         return 0;
@@ -51,7 +52,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
         int cpu, ret = 0;
 
         /* Don't allow flipping of max traces now */
-        raw_local_irq_save(flags);
+        local_irq_save(flags);
         __raw_spin_lock(&ftrace_max_lock);
 
         cnt = ring_buffer_entries(tr->buffer);
@@ -62,7 +63,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
                         break;
         }
         __raw_spin_unlock(&ftrace_max_lock);
-        raw_local_irq_restore(flags);
+        local_irq_restore(flags);
 
         if (count)
                 *count = cnt;
@@ -70,6 +71,11 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
         return ret;
 }
 
+static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
+{
+        printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
+                trace->name, init_ret);
+}
 #ifdef CONFIG_FUNCTION_TRACER
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -110,8 +116,11 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         ftrace_set_filter(func_name, strlen(func_name), 1);
 
         /* enable tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
 
         /* Sleep for a 1/10 of a second */
         msleep(100);
@@ -134,13 +143,13 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         msleep(100);
 
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         ftrace_enabled = 0;
 
         /* check the trace buffer */
         ret = trace_test_buffer(tr, &count);
         trace->reset(tr);
+        tracing_start();
 
         /* we should only have one item */
         if (!ret && count != 1) {
@@ -148,6 +157,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
                 ret = -1;
                 goto out;
         }
+
  out:
         ftrace_enabled = save_ftrace_enabled;
         tracer_enabled = save_tracer_enabled;
@@ -180,18 +190,22 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
         ftrace_enabled = 1;
         tracer_enabled = 1;
 
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
+
         /* Sleep for a 1/10 of a second */
         msleep(100);
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         ftrace_enabled = 0;
 
         /* check the trace buffer */
         ret = trace_test_buffer(tr, &count);
         trace->reset(tr);
+        tracing_start();
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
@@ -223,8 +237,12 @@ trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
         int ret;
 
         /* start the tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
+
         /* reset the max latency */
         tracing_max_latency = 0;
         /* disable interrupts for a bit */
@@ -232,13 +250,13 @@ trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
         udelay(100);
         local_irq_enable();
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(tr, NULL);
         if (!ret)
                 ret = trace_test_buffer(&max_tr, &count);
         trace->reset(tr);
+        tracing_start();
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
@@ -259,9 +277,26 @@ trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
         unsigned long count;
         int ret;
 
+        /*
+         * Now that the big kernel lock is no longer preemptable,
+         * and this is called with the BKL held, it will always
+         * fail. If preemption is already disabled, simply
+         * pass the test. When the BKL is removed, or becomes
+         * preemptible again, we will once again test this,
+         * so keep it in.
+         */
+        if (preempt_count()) {
+                printk(KERN_CONT "can not test ... force ");
+                return 0;
+        }
+
         /* start the tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
+
         /* reset the max latency */
         tracing_max_latency = 0;
         /* disable preemption for a bit */
@@ -269,13 +304,13 @@ trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
         udelay(100);
         preempt_enable();
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(tr, NULL);
         if (!ret)
                 ret = trace_test_buffer(&max_tr, &count);
         trace->reset(tr);
+        tracing_start();
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
@@ -296,9 +331,25 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         unsigned long count;
         int ret;
 
+        /*
+         * Now that the big kernel lock is no longer preemptable,
+         * and this is called with the BKL held, it will always
+         * fail. If preemption is already disabled, simply
+         * pass the test. When the BKL is removed, or becomes
+         * preemptible again, we will once again test this,
+         * so keep it in.
+         */
+        if (preempt_count()) {
+                printk(KERN_CONT "can not test ... force ");
+                return 0;
+        }
+
         /* start the tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
 
         /* reset the max latency */
         tracing_max_latency = 0;
@@ -312,27 +363,30 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         local_irq_enable();
 
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(tr, NULL);
-        if (ret)
+        if (ret) {
+                tracing_start();
                 goto out;
+        }
 
         ret = trace_test_buffer(&max_tr, &count);
-        if (ret)
+        if (ret) {
+                tracing_start();
                 goto out;
+        }
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
                 ret = -1;
+                tracing_start();
                 goto out;
         }
 
         /* do the test by disabling interrupts first this time */
         tracing_max_latency = 0;
-        tr->ctrl = 1;
-        trace->ctrl_update(tr);
+        tracing_start();
         preempt_disable();
         local_irq_disable();
         udelay(100);
@@ -341,8 +395,7 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         local_irq_enable();
 
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(tr, NULL);
         if (ret)
@@ -358,6 +411,7 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
 
  out:
         trace->reset(tr);
+        tracing_start();
         tracing_max_latency = save_max;
 
         return ret;
@@ -423,8 +477,12 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
         wait_for_completion(&isrt);
 
         /* start the tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
+
         /* reset the max latency */
         tracing_max_latency = 0;
 
@@ -448,8 +506,7 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
         msleep(100);
 
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(tr, NULL);
         if (!ret)
@@ -457,6 +514,7 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
 
 
         trace->reset(tr);
+        tracing_start();
 
         tracing_max_latency = save_max;
 
@@ -480,16 +538,20 @@ trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr
         int ret;
 
         /* start the tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
+
         /* Sleep for a 1/10 of a second */
         msleep(100);
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check the trace buffer */
         ret = trace_test_buffer(tr, &count);
         trace->reset(tr);
+        tracing_start();
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
@@ -508,17 +570,48 @@ trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr)
         int ret;
 
         /* start the tracing */
-        tr->ctrl = 1;
-        trace->init(tr);
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return 0;
+        }
+
         /* Sleep for a 1/10 of a second */
         msleep(100);
         /* stop the tracing. */
-        tr->ctrl = 0;
-        trace->ctrl_update(tr);
+        tracing_stop();
         /* check the trace buffer */
         ret = trace_test_buffer(tr, &count);
         trace->reset(tr);
+        tracing_start();
 
         return ret;
 }
 #endif /* CONFIG_SYSPROF_TRACER */
+
+#ifdef CONFIG_BRANCH_TRACER
+int
+trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
+{
+        unsigned long count;
+        int ret;
+
+        /* start the tracing */
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
+
+        /* Sleep for a 1/10 of a second */
+        msleep(100);
+        /* stop the tracing. */
+        tracing_stop();
+        /* check the trace buffer */
+        ret = trace_test_buffer(tr, &count);
+        trace->reset(tr);
+        tracing_start();
+
+        return ret;
+}
+#endif /* CONFIG_BRANCH_TRACER */
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index be682b62fe58..0b863f2cbc8e 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -48,7 +48,7 @@ static inline void check_stack(void)
         if (!object_is_on_stack(&this_size))
                 return;
 
-        raw_local_irq_save(flags);
+        local_irq_save(flags);
         __raw_spin_lock(&max_stack_lock);
 
         /* a race could have already updated it */
@@ -78,6 +78,7 @@ static inline void check_stack(void)
          * on a new max, so it is far from a fast path.
          */
         while (i < max_stack_trace.nr_entries) {
+                int found = 0;
 
                 stack_dump_index[i] = this_size;
                 p = start;
@@ -86,17 +87,19 @@ static inline void check_stack(void)
                         if (*p == stack_dump_trace[i]) {
                                 this_size = stack_dump_index[i++] =
                                         (top - p) * sizeof(unsigned long);
+                                found = 1;
                                 /* Start the search from here */
                                 start = p + 1;
                         }
                 }
 
-                i++;
+                if (!found)
+                        i++;
         }
 
  out:
         __raw_spin_unlock(&max_stack_lock);
-        raw_local_irq_restore(flags);
+        local_irq_restore(flags);
 }
 
 static void
@@ -107,8 +110,7 @@ stack_trace_call(unsigned long ip, unsigned long parent_ip)
         if (unlikely(!ftrace_enabled || stack_trace_disabled))
                 return;
 
-        resched = need_resched();
-        preempt_disable_notrace();
+        resched = ftrace_preempt_disable();
 
         cpu = raw_smp_processor_id();
         /* no atomic needed, we only modify this variable by this cpu */
@@ -120,10 +122,7 @@ stack_trace_call(unsigned long ip, unsigned long parent_ip)
  out:
         per_cpu(trace_active, cpu)--;
         /* prevent recursion in schedule */
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
+        ftrace_preempt_enable(resched);
 }
 
 static struct ftrace_ops trace_ops __read_mostly =
@@ -166,11 +165,11 @@ stack_max_size_write(struct file *filp, const char __user *ubuf,
         if (ret < 0)
                 return ret;
 
-        raw_local_irq_save(flags);
+        local_irq_save(flags);
         __raw_spin_lock(&max_stack_lock);
         *ptr = val;
         __raw_spin_unlock(&max_stack_lock);
-        raw_local_irq_restore(flags);
+        local_irq_restore(flags);
 
         return count;
 }
@@ -184,11 +183,16 @@ static struct file_operations stack_max_size_fops = {
 static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        long i = (long)m->private;
+        long i;
 
         (*pos)++;
 
-        i++;
+        if (v == SEQ_START_TOKEN)
+                i = 0;
+        else {
+                i = *(long *)v;
+                i++;
+        }
 
         if (i >= max_stack_trace.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
@@ -201,12 +205,15 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
 
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
-        void *t = &m->private;
+        void *t = SEQ_START_TOKEN;
         loff_t l = 0;
 
         local_irq_disable();
         __raw_spin_lock(&max_stack_lock);
 
+        if (*pos == 0)
+                return SEQ_START_TOKEN;
+
         for (; t && l < *pos; t = t_next(m, t, &l))
                 ;
 
@@ -235,10 +242,10 @@ static int trace_lookup_stack(struct seq_file *m, long i)
 
 static int t_show(struct seq_file *m, void *v)
 {
-        long i = *(long *)v;
+        long i;
         int size;
 
-        if (i < 0) {
+        if (v == SEQ_START_TOKEN) {
                 seq_printf(m, "        Depth   Size      Location"
                            "    (%d entries)\n"
                            "        -----   ----      --------\n",
@@ -246,6 +253,8 @@ static int t_show(struct seq_file *m, void *v)
                 return 0;
         }
 
+        i = *(long *)v;
+
         if (i >= max_stack_trace.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
                 return 0;
@@ -275,10 +284,6 @@ static int stack_trace_open(struct inode *inode, struct file *file)
         int ret;
 
         ret = seq_open(file, &stack_trace_seq_ops);
-        if (!ret) {
-                struct seq_file *m = file->private_data;
-                m->private = (void *)-1;
-        }
 
         return ret;
 }
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index 9587d3bcba55..54960edb96d0 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -261,27 +261,17 @@ static void stop_stack_trace(struct trace_array *tr)
         mutex_unlock(&sample_timer_lock);
 }
 
-static void stack_trace_init(struct trace_array *tr)
+static int stack_trace_init(struct trace_array *tr)
 {
         sysprof_trace = tr;
 
-        if (tr->ctrl)
-                start_stack_trace(tr);
+        start_stack_trace(tr);
+        return 0;
 }
 
 static void stack_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
-                stop_stack_trace(tr);
-}
-
-static void stack_trace_ctrl_update(struct trace_array *tr)
-{
-        /* When starting a new trace, reset the buffers */
-        if (tr->ctrl)
-                start_stack_trace(tr);
-        else
-                stop_stack_trace(tr);
+        stop_stack_trace(tr);
 }
 
 static struct tracer stack_trace __read_mostly =
@@ -289,7 +279,6 @@ static struct tracer stack_trace __read_mostly =
         .name           = "sysprof",
         .init           = stack_trace_init,
         .reset          = stack_trace_reset,
-        .ctrl_update    = stack_trace_ctrl_update,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_sysprof,
 #endif
diff --git a/kernel/tracepoint.c b/kernel/tracepoint.c
index af8c85664882..79602740bbb5 100644
--- a/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@ -43,6 +43,7 @@ static DEFINE_MUTEX(tracepoints_mutex);
  */
 #define TRACEPOINT_HASH_BITS 6
 #define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
+static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
 
 /*
  * Note about RCU :
@@ -54,40 +55,43 @@ struct tracepoint_entry {
         struct hlist_node hlist;
         void **funcs;
         int refcount;   /* Number of times armed. 0 if disarmed. */
-        struct rcu_head rcu;
-        void *oldptr;
-        unsigned char rcu_pending:1;
         char name[0];
 };
 
-static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
+struct tp_probes {
+        union {
+                struct rcu_head rcu;
+                struct list_head list;
+        } u;
+        void *probes[0];
+};
 
-static void free_old_closure(struct rcu_head *head)
+static inline void *allocate_probes(int count)
 {
-        struct tracepoint_entry *entry = container_of(head,
-                struct tracepoint_entry, rcu);
-        kfree(entry->oldptr);
-        /* Make sure we free the data before setting the pending flag to 0 */
-        smp_wmb();
-        entry->rcu_pending = 0;
+        struct tp_probes *p  = kmalloc(count * sizeof(void *)
+                        + sizeof(struct tp_probes), GFP_KERNEL);
+        return p == NULL ? NULL : p->probes;
 }
 
-static void tracepoint_entry_free_old(struct tracepoint_entry *entry, void *old)
+static void rcu_free_old_probes(struct rcu_head *head)
 {
-        if (!old)
-                return;
-        entry->oldptr = old;
-        entry->rcu_pending = 1;
-        /* write rcu_pending before calling the RCU callback */
-        smp_wmb();
-        call_rcu_sched(&entry->rcu, free_old_closure);
+        kfree(container_of(head, struct tp_probes, u.rcu));
+}
+
+static inline void release_probes(void *old)
+{
+        if (old) {
+                struct tp_probes *tp_probes = container_of(old,
+                        struct tp_probes, probes[0]);
+                call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
+        }
 }
 
 static void debug_print_probes(struct tracepoint_entry *entry)
 {
         int i;
 
-        if (!tracepoint_debug)
+        if (!tracepoint_debug || !entry->funcs)
                 return;
 
         for (i = 0; entry->funcs[i]; i++)
@@ -111,12 +115,13 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
                                 return ERR_PTR(-EEXIST);
         }
         /* + 2 : one for new probe, one for NULL func */
-        new = kzalloc((nr_probes + 2) * sizeof(void *), GFP_KERNEL);
+        new = allocate_probes(nr_probes + 2);
         if (new == NULL)
                 return ERR_PTR(-ENOMEM);
         if (old)
                 memcpy(new, old, nr_probes * sizeof(void *));
         new[nr_probes] = probe;
+        new[nr_probes + 1] = NULL;
         entry->refcount = nr_probes + 1;
         entry->funcs = new;
         debug_print_probes(entry);
@@ -132,7 +137,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
         old = entry->funcs;
 
         if (!old)
-                return NULL;
+                return ERR_PTR(-ENOENT);
 
         debug_print_probes(entry);
         /* (N -> M), (N > 1, M >= 0) probes */
@@ -151,13 +156,13 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
                 int j = 0;
                 /* N -> M, (N > 1, M > 0) */
                 /* + 1 for NULL */
-                new = kzalloc((nr_probes - nr_del + 1)
-                        * sizeof(void *), GFP_KERNEL);
+                new = allocate_probes(nr_probes - nr_del + 1);
                 if (new == NULL)
                         return ERR_PTR(-ENOMEM);
                 for (i = 0; old[i]; i++)
                         if ((probe && old[i] != probe))
                                 new[j++] = old[i];
+                new[nr_probes - nr_del] = NULL;
                 entry->refcount = nr_probes - nr_del;
                 entry->funcs = new;
         }
@@ -215,7 +220,6 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
         memcpy(&e->name[0], name, name_len);
         e->funcs = NULL;
         e->refcount = 0;
-        e->rcu_pending = 0;
         hlist_add_head(&e->hlist, head);
         return e;
 }
@@ -224,32 +228,10 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
  * Remove the tracepoint from the tracepoint hash table. Must be called with
  * mutex_lock held.
  */
-static int remove_tracepoint(const char *name)
+static inline void remove_tracepoint(struct tracepoint_entry *e)
 {
-        struct hlist_head *head;
-        struct hlist_node *node;
-        struct tracepoint_entry *e;
-        int found = 0;
-        size_t len = strlen(name) + 1;
-        u32 hash = jhash(name, len-1, 0);
-
-        head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
-        hlist_for_each_entry(e, node, head, hlist) {
-                if (!strcmp(name, e->name)) {
-                        found = 1;
-                        break;
-                }
-        }
-        if (!found)
-                return -ENOENT;
-        if (e->refcount)
-                return -EBUSY;
         hlist_del(&e->hlist);
-        /* Make sure the call_rcu_sched has been executed */
-        if (e->rcu_pending)
-                rcu_barrier_sched();
         kfree(e);
-        return 0;
 }
 
 /*
@@ -280,6 +262,7 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 static void disable_tracepoint(struct tracepoint *elem)
 {
         elem->state = 0;
+        rcu_assign_pointer(elem->funcs, NULL);
 }
 
 /**
@@ -320,6 +303,23 @@ static void tracepoint_update_probes(void)
         module_update_tracepoints();
 }
 
+static void *tracepoint_add_probe(const char *name, void *probe)
+{
+        struct tracepoint_entry *entry;
+        void *old;
+
+        entry = get_tracepoint(name);
+        if (!entry) {
+                entry = add_tracepoint(name);
+                if (IS_ERR(entry))
+                        return entry;
+        }
+        old = tracepoint_entry_add_probe(entry, probe);
+        if (IS_ERR(old) && !entry->refcount)
+                remove_tracepoint(entry);
+        return old;
+}
+
 /**
  * tracepoint_probe_register -  Connect a probe to a tracepoint
  * @name: tracepoint name
@@ -330,44 +330,36 @@ static void tracepoint_update_probes(void)
  */
 int tracepoint_probe_register(const char *name, void *probe)
 {
-        struct tracepoint_entry *entry;
-        int ret = 0;
         void *old;
 
         mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
-        if (!entry) {
-                entry = add_tracepoint(name);
-                if (IS_ERR(entry)) {
-                        ret = PTR_ERR(entry);
-                        goto end;
-                }
-        }
-        /*
-         * If we detect that a call_rcu_sched is pending for this tracepoint,
-         * make sure it's executed now.
-         */
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        old = tracepoint_entry_add_probe(entry, probe);
-        if (IS_ERR(old)) {
-                ret = PTR_ERR(old);
-                goto end;
-        }
+        old = tracepoint_add_probe(name, probe);
         mutex_unlock(&tracepoints_mutex);
+        if (IS_ERR(old))
+                return PTR_ERR(old);
+
         tracepoint_update_probes();             /* may update entry */
-        mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
-        WARN_ON(!entry);
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        tracepoint_entry_free_old(entry, old);
-end:
-        mutex_unlock(&tracepoints_mutex);
-        return ret;
+        release_probes(old);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 
+static void *tracepoint_remove_probe(const char *name, void *probe)
+{
+        struct tracepoint_entry *entry;
+        void *old;
+
+        entry = get_tracepoint(name);
+        if (!entry)
+                return ERR_PTR(-ENOENT);
+        old = tracepoint_entry_remove_probe(entry, probe);
+        if (IS_ERR(old))
+                return old;
+        if (!entry->refcount)
+                remove_tracepoint(entry);
+        return old;
+}
+
 /**
  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
  * @name: tracepoint name
@@ -380,38 +372,104 @@ EXPORT_SYMBOL_GPL(tracepoint_probe_register);
  */
 int tracepoint_probe_unregister(const char *name, void *probe)
 {
-        struct tracepoint_entry *entry;
         void *old;
-        int ret = -ENOENT;
 
         mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
-        if (!entry)
-                goto end;
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        old = tracepoint_entry_remove_probe(entry, probe);
-        if (!old) {
-                printk(KERN_WARNING "Warning: Trying to unregister a probe"
-                                    "that doesn't exist\n");
-                goto end;
-        }
+        old = tracepoint_remove_probe(name, probe);
         mutex_unlock(&tracepoints_mutex);
+        if (IS_ERR(old))
+                return PTR_ERR(old);
+
         tracepoint_update_probes();             /* may update entry */
+        release_probes(old);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+
+static LIST_HEAD(old_probes);
+static int need_update;
+
+static void tracepoint_add_old_probes(void *old)
+{
+        need_update = 1;
+        if (old) {
+                struct tp_probes *tp_probes = container_of(old,
+                        struct tp_probes, probes[0]);
+                list_add(&tp_probes->u.list, &old_probes);
+        }
+}
+
+/**
+ * tracepoint_probe_register_noupdate -  register a probe but not connect
+ * @name: tracepoint name
+ * @probe: probe handler
+ *
+ * caller must call tracepoint_probe_update_all()
+ */
+int tracepoint_probe_register_noupdate(const char *name, void *probe)
+{
+        void *old;
+
         mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
-        if (!entry)
-                goto end;
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        tracepoint_entry_free_old(entry, old);
-        remove_tracepoint(name);        /* Ignore busy error message */
-        ret = 0;
-end:
+        old = tracepoint_add_probe(name, probe);
+        if (IS_ERR(old)) {
+                mutex_unlock(&tracepoints_mutex);
+                return PTR_ERR(old);
+        }
+        tracepoint_add_old_probes(old);
         mutex_unlock(&tracepoints_mutex);
-        return ret;
+        return 0;
 }
-EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
+
+/**
+ * tracepoint_probe_unregister_noupdate -  remove a probe but not disconnect
+ * @name: tracepoint name
+ * @probe: probe function pointer
+ *
+ * caller must call tracepoint_probe_update_all()
+ */
+int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
+{
+        void *old;
+
+        mutex_lock(&tracepoints_mutex);
+        old = tracepoint_remove_probe(name, probe);
+        if (IS_ERR(old)) {
+                mutex_unlock(&tracepoints_mutex);
+                return PTR_ERR(old);
+        }
+        tracepoint_add_old_probes(old);
+        mutex_unlock(&tracepoints_mutex);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
+
+/**
+ * tracepoint_probe_update_all -  update tracepoints
+ */
+void tracepoint_probe_update_all(void)
+{
+        LIST_HEAD(release_probes);
+        struct tp_probes *pos, *next;
+
+        mutex_lock(&tracepoints_mutex);
+        if (!need_update) {
+                mutex_unlock(&tracepoints_mutex);
+                return;
+        }
+        if (!list_empty(&old_probes))
+                list_replace_init(&old_probes, &release_probes);
+        need_update = 0;
+        mutex_unlock(&tracepoints_mutex);
+
+        tracepoint_update_probes();
+        list_for_each_entry_safe(pos, next, &release_probes, u.list) {
+                list_del(&pos->u.list);
+                call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
+        }
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
 
 /**
  * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
@@ -483,3 +541,36 @@ void tracepoint_iter_reset(struct tracepoint_iter *iter)
         iter->tracepoint = NULL;
 }
 EXPORT_SYMBOL_GPL(tracepoint_iter_reset);
+
+#ifdef CONFIG_MODULES
+
+int tracepoint_module_notify(struct notifier_block *self,
+                             unsigned long val, void *data)
+{
+        struct module *mod = data;
+
+        switch (val) {
+        case MODULE_STATE_COMING:
+                tracepoint_update_probe_range(mod->tracepoints,
+                        mod->tracepoints + mod->num_tracepoints);
+                break;
+        case MODULE_STATE_GOING:
+                tracepoint_update_probe_range(mod->tracepoints,
+                        mod->tracepoints + mod->num_tracepoints);
+                break;
+        }
+        return 0;
+}
+
+struct notifier_block tracepoint_module_nb = {
+        .notifier_call = tracepoint_module_notify,
+        .priority = 0,
+};
+
+static int init_tracepoints(void)
+{
+        return register_module_notifier(&tracepoint_module_nb);
+}
+__initcall(init_tracepoints);
+
+#endif /* CONFIG_MODULES */
diff --git a/kernel/user.c b/kernel/user.c
index 39d6159fae43..cec2224bc9f5 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -101,6 +101,8 @@ static int sched_create_user(struct user_struct *up)
         if (IS_ERR(up->tg))
                 rc = -ENOMEM;
 
+        set_tg_uid(up);
+
         return rc;
 }