56 files changed, 1208 insertions, 1083 deletions
diff --git a/kernel/Makefile b/kernel/Makefile
index 305f11dbef21..19fad003b19d 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -11,9 +11,7 @@ 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
-ifdef CONFIG_FTRACE
 # Do not trace debug files and internal ftrace files
 CFLAGS_REMOVE_lockdep.o = -pg
 CFLAGS_REMOVE_lockdep_proc.o = -pg
@@ -21,7 +19,7 @@ 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
+CFLAGS_REMOVE_sched.o = -pg
 endif
 obj-$(CONFIG_FREEZER) += freezer.o
@@ -88,7 +86,7 @@ obj-$(CONFIG_MARKERS) += marker.o
 obj-$(CONFIG_TRACEPOINTS) += tracepoint.o
 obj-$(CONFIG_LATENCYTOP) += latencytop.o
 obj-$(CONFIG_HAVE_GENERIC_DMA_COHERENT) += dma-coherent.o
-obj-$(CONFIG_FTRACE) += trace/
+obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
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);
+                untag_chunk(p);
-                spin_lock(&hash_lock);
        }
        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);
+                untag_chunk(node);
-                get_inotify_watch(&chunk->watch);
-                spin_unlock(&hash_lock);
-                untag_chunk(chunk, node);
-                put_inotify_watch(&chunk->watch);
-                spin_lock(&hash_lock);
        }
        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() */
+                /* the unpin matching the pin in audit_do_del_rule() */
-                put_inotify_watch(&p->wdata);
+                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(). */
+                                 * audit_inotify_unregister().
-                                list_add(&parent->ilist, &inotify_list);
+                                 * If filesystem is going away, just leave
-                                get_inotify_watch(&parent->wdata);
+                                 * 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/cgroup.c b/kernel/cgroup.c
index 35eebd5510c2..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;
        }
+        mutex_unlock(&cgroup_mutex);
-        parent = cgrp->parent;
-        root = cgrp->root;
-        sb = root->sb;
        /*
         * 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;
        }
@@ -2497,7 +2504,6 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
        list_del(&cgrp->sibling);
        spin_lock(&cgrp->dentry->d_lock);
        d = dget(cgrp->dentry);
-        cgrp->dentry = NULL;
        spin_unlock(&d->d_lock);
        cgroup_d_remove_dir(d);
diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c
index e95056954498..fb249e2bcada 100644
--- a/kernel/cgroup_freezer.c
+++ b/kernel/cgroup_freezer.c
@@ -162,9 +162,13 @@ static int freezer_can_attach(struct cgroup_subsys *ss,
                              struct task_struct *task)
 {
        struct freezer *freezer;
-        int retval;
-        /* Anything frozen can't move or be moved to/from */
+        /*
+         * Anything frozen can't move or be moved to/from.
+         *
+         * Since orig_freezer->state == FROZEN means that @task has been
+         * frozen, so it's sufficient to check the latter condition.
+         */
        if (is_task_frozen_enough(task))
                return -EBUSY;
@@ -173,25 +177,31 @@ static int freezer_can_attach(struct cgroup_subsys *ss,
        if (freezer->state == CGROUP_FROZEN)
                return -EBUSY;
-        retval = 0;
+        return 0;
-        task_lock(task);
-        freezer = task_freezer(task);
-        if (freezer->state == CGROUP_FROZEN)
-                retval = -EBUSY;
-        task_unlock(task);
-        return retval;
 }
 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);
-        BUG_ON(freezer->state == CGROUP_FROZEN);
+        /*
+         * 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);
        /* Locking avoids race with FREEZING -> THAWED transitions. */
        if (freezer->state == CGROUP_FREEZING)
                freeze_task(task, true);
@@ -276,25 +286,18 @@ static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
        return num_cant_freeze_now ? -EBUSY : 0;
 }
-static int unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
+static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
 {
        struct cgroup_iter it;
        struct task_struct *task;
        cgroup_iter_start(cgroup, &it);
        while ((task = cgroup_iter_next(cgroup, &it))) {
-                int do_wake;
+                thaw_process(task);
-                task_lock(task);
-                do_wake = __thaw_process(task);
-                task_unlock(task);
-                if (do_wake)
-                        wake_up_process(task);
        }
        cgroup_iter_end(cgroup, &it);
-        freezer->state = CGROUP_THAWED;
-        return 0;
+        freezer->state = CGROUP_THAWED;
 }
 static int freezer_change_state(struct cgroup *cgroup,
@@ -304,27 +307,22 @@ static int freezer_change_state(struct cgroup *cgroup,
        int retval = 0;
        freezer = cgroup_freezer(cgroup);
        spin_lock_irq(&freezer->lock);
        update_freezer_state(cgroup, freezer);
        if (goal_state == freezer->state)
                goto out;
-        switch (freezer->state) {
+        switch (goal_state) {
        case CGROUP_THAWED:
-                retval = try_to_freeze_cgroup(cgroup, freezer);
+                unfreeze_cgroup(cgroup, freezer);
                break;
-        case CGROUP_FREEZING:
-                if (goal_state == CGROUP_FROZEN) {
-                        /* Userspace is retrying after
-                         * "/bin/echo FROZEN > freezer.state" returned -EBUSY */
-                        retval = try_to_freeze_cgroup(cgroup, freezer);
-                        break;
-                }
-                /* state == FREEZING and goal_state == THAWED, so unfreeze */
        case CGROUP_FROZEN:
-                retval = unfreeze_cgroup(cgroup, freezer);
+                retval = try_to_freeze_cgroup(cgroup, freezer);
                break;
        default:
-                break;
+                BUG();
        }
 out:
        spin_unlock_irq(&freezer->lock);
@@ -344,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;
@@ -363,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 86d49045daed..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;
@@ -499,3 +499,6 @@ const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
 #endif
 };
 EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
+const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
+EXPORT_SYMBOL(cpu_all_bits);
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) {
+        if (!doms)
-                ndoms = 0;
                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];
+        switch (action) {
-        scan_for_empty_cpusets(&top_cpuset);
+        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..2d8be7ebb0f7 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>
@@ -141,6 +140,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 +1058,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))
diff --git a/kernel/fork.c b/kernel/fork.c
index f6083561dfe0..2a372a0e206f 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -40,6 +40,7 @@
 #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>
@@ -519,6 +520,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);
diff --git a/kernel/freezer.c b/kernel/freezer.c
index ba6248b323ef..2f4936cf7083 100644
--- a/kernel/freezer.c
+++ b/kernel/freezer.c
@@ -121,16 +121,7 @@ void cancel_freezing(struct task_struct *p)
        }
 }
-/*
+static int __thaw_process(struct task_struct *p)
- * Wake up a frozen process
- *
- * task_lock() is needed to prevent the race with refrigerator() which may
- * occur if the freezing of tasks fails.  Namely, without the lock, if the
- * freezing of tasks failed, thaw_tasks() might have run before a task in
- * refrigerator() could call frozen_process(), in which case the task would be
- * frozen and no one would thaw it.
- */
-int __thaw_process(struct task_struct *p)
 {
        if (frozen(p)) {
                p->flags &= ~PF_FROZEN;
@@ -140,6 +131,15 @@ int __thaw_process(struct task_struct *p)
        return 0;
 }
+/*
+ * Wake up a frozen process
+ *
+ * task_lock() is needed to prevent the race with refrigerator() which may
+ * occur if the freezing of tasks fails.  Namely, without the lock, if the
+ * freezing of tasks failed, thaw_tasks() might have run before a task in
+ * refrigerator() could call frozen_process(), in which case the task would be
+ * frozen and no one would thaw it.
+ */
 int thaw_process(struct task_struct *p)
 {
        task_lock(p);
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/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 {
-        } else
+                desc->status |= IRQ_MOVE_PENDING;
-                set_pending_irq(irq, cpumask);
+                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 fac014a81b24..d257e7d6a8a4 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);
@@ -220,7 +220,7 @@ void unregister_handler_proc(unsigned int irq, struct irqaction *action)
        }
 }
-void register_default_affinity_proc(void)
+static void register_default_affinity_proc(void)
 {
 #ifdef CONFIG_SMP
        proc_create("irq/default_smp_affinity", 0600, NULL,
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,
+                len += sprintf(buffer, "+%#lx/%#lx [%s]",
-                                size, modname);
+                                                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) ||
+        preempt_disable();
-            in_kprobes_functions((unsigned long) p->addr))
+        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/lockdep.c b/kernel/lockdep.c
index dbda475b13bd..46a404173db2 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -2169,12 +2169,11 @@ void early_boot_irqs_on(void)
 /*
 * Hardirqs will be enabled:
 */
-void trace_hardirqs_on_caller(unsigned long a0)
+void trace_hardirqs_on_caller(unsigned long ip)
 {
        struct task_struct *curr = current;
-        unsigned long ip;
-        time_hardirqs_on(CALLER_ADDR0, a0);
+        time_hardirqs_on(CALLER_ADDR0, ip);
        if (unlikely(!debug_locks || current->lockdep_recursion))
                return;
@@ -2188,7 +2187,6 @@ void trace_hardirqs_on_caller(unsigned long a0)
        }
        /* we'll do an OFF -> ON transition: */
        curr->hardirqs_enabled = 1;
-        ip = (unsigned long) __builtin_return_address(0);
        if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
                return;
@@ -2224,11 +2222,11 @@ EXPORT_SYMBOL(trace_hardirqs_on);
 /*
 * Hardirqs were disabled:
 */
-void trace_hardirqs_off_caller(unsigned long a0)
+void trace_hardirqs_off_caller(unsigned long ip)
 {
        struct task_struct *curr = current;
-        time_hardirqs_off(CALLER_ADDR0, a0);
+        time_hardirqs_off(CALLER_ADDR0, ip);
        if (unlikely(!debug_locks || current->lockdep_recursion))
                return;
@@ -2241,7 +2239,7 @@ void trace_hardirqs_off_caller(unsigned long a0)
                 * We have done an ON -> OFF transition:
                 */
                curr->hardirqs_enabled = 0;
-                curr->hardirq_disable_ip = _RET_IP_;
+                curr->hardirq_disable_ip = ip;
                curr->hardirq_disable_event = ++curr->irq_events;
                debug_atomic_inc(&hardirqs_off_events);
        } else
@@ -3278,10 +3276,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);
@@ -3417,9 +3415,10 @@ retry:
                }
                printk(" ignoring it.\n");
                unlock = 0;
+        } else {
+                if (count != 10)
+                        printk(KERN_CONT " locked it.\n");
        }
-        if (count != 10)
-                printk(" locked it.\n");
        do_each_thread(g, p) {
                /*
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..895337b16a24 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -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/Kconfig b/kernel/power/Kconfig
index dcd165f92a88..23bd4daeb96b 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -96,7 +96,7 @@ config SUSPEND
 config PM_TEST_SUSPEND
        bool "Test suspend/resume and wakealarm during bootup"
-        depends on SUSPEND && PM_DEBUG && RTC_LIB=y
+        depends on SUSPEND && PM_DEBUG && RTC_CLASS=y
        ---help---
        This option will let you suspend your machine during bootup, and
        make it wake up a few seconds later using an RTC wakeup alarm.
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 19122cf6d827..b8f7ce9473e8 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -174,7 +174,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
diff --git a/kernel/printk.c b/kernel/printk.c
index 6341af77eb65..f492f1583d77 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -233,45 +233,6 @@ static inline void boot_delay_msec(void)
 #endif
 /*
- * Return the number of unread characters in the log buffer.
- */
-static int log_buf_get_len(void)
-{
-        return logged_chars;
-}
-/*
- * Copy a range of characters from the log buffer.
- */
-int log_buf_copy(char *dest, int idx, int len)
-{
-        int ret, max;
-        bool took_lock = false;
-        if (!oops_in_progress) {
-                spin_lock_irq(&logbuf_lock);
-                took_lock = true;
-        }
-        max = log_buf_get_len();
-        if (idx < 0 || idx >= max) {
-                ret = -1;
-        } else {
-                if (len > max)
-                        len = max;
-                ret = len;
-                idx += (log_end - max);
-                while (len-- > 0)
-                        dest[len] = LOG_BUF(idx + len);
-        }
-        if (took_lock)
-                spin_unlock_irq(&logbuf_lock);
-        return ret;
-}
-/*
 * Commands to do_syslog:
 *
 *      0 -- Close the log.  Currently a NOP.
diff --git a/kernel/profile.c b/kernel/profile.c
index a9e422df6bf6..dc41827fbfee 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -102,7 +102,7 @@ int profile_setup(char *str)
 __setup("profile=", profile_setup);
-int profile_init(void)
+int __ref profile_init(void)
 {
        int buffer_bytes;
        if (!prof_on)
@@ -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 inline 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/relay.c b/kernel/relay.c
index 8d13a7855c08..32b0befdcb6a 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) {
+        for_each_possible_cpu(i) {
-                if (!chan->buf[i])
+                if (chan->buf[i])
-                        break;
+                        relay_close_buf(chan->buf[i]);
-                relay_close_buf(chan->buf[i]);
        }
        kref_put(&chan->kref, relay_destroy_channel);
diff --git a/kernel/resource.c b/kernel/resource.c
index 4089d12af6e0..4337063663ef 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -17,6 +17,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/device.h>
+#include <linux/pfn.h>
 #include <asm/io.h>
@@ -522,7 +523,7 @@ static void __init __reserve_region_with_split(struct resource *root,
 {
        struct resource *parent = root;
        struct resource *conflict;
-        struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
+        struct resource *res = kzalloc(sizeof(*res), GFP_ATOMIC);
        if (!res)
                return;
@@ -571,7 +572,7 @@ static void __init __reserve_region_with_split(struct resource *root,
 }
-void reserve_region_with_split(struct resource *root,
+void __init reserve_region_with_split(struct resource *root,
                resource_size_t start, resource_size_t end,
                const char *name)
 {
@@ -849,7 +850,8 @@ int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
                        continue;
                if (p->end < addr)
                        continue;
-                if (p->start <= addr && (p->end >= addr + size - 1))
+                if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
+                    PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
                        continue;
                printk(KERN_WARNING "resource map sanity check conflict: "
                       "0x%llx 0x%llx 0x%llx 0x%llx %s\n",
diff --git a/kernel/sched.c b/kernel/sched.c
index 6625c3c4b10d..b7480fb5c3dc 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -386,7 +386,6 @@ struct cfs_rq {
        u64 exec_clock;
        u64 min_vruntime;
-        u64 pair_start;
        struct rb_root tasks_timeline;
        struct rb_node *rb_leftmost;
@@ -398,9 +397,9 @@ struct cfs_rq {
         * 'curr' points to currently running entity on this cfs_rq.
         * It is set to NULL otherwise (i.e when none are currently running).
         */
-        struct sched_entity *curr, *next;
+        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 */
@@ -970,6 +969,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)
 {
@@ -1446,9 +1453,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)
+        if (nr_running)
-                rq->avg_load_per_task = rq->load.weight / rq->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;
 }
@@ -1806,7 +1816,9 @@ task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
        /*
         * Buddy candidates are cache hot:
         */
-        if (sched_feat(CACHE_HOT_BUDDY) && (&p->se == cfs_rq_of(&p->se)->next))
+        if (sched_feat(CACHE_HOT_BUDDY) &&
+                        (&p->se == cfs_rq_of(&p->se)->next ||
+                         &p->se == cfs_rq_of(&p->se)->last))
                return 1;
        if (p->sched_class != &fair_sched_class)
@@ -3344,7 +3356,7 @@ small_imbalance:
                } else
                        this_load_per_task = cpu_avg_load_per_task(this_cpu);
-                if (max_load - this_load + 2*busiest_load_per_task >=
+                if (max_load - this_load + busiest_load_per_task >=
                                        busiest_load_per_task * imbn) {
                        *imbalance = busiest_load_per_task;
                        return busiest;
@@ -5859,6 +5871,8 @@ 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();
@@ -5866,7 +5880,6 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
        idle->cpus_allowed = cpumask_of_cpu(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;
@@ -6876,15 +6889,17 @@ cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
        struct sched_domain *tmp;
        /* Remove the sched domains which do not contribute to scheduling. */
-        for (tmp = sd; tmp; tmp = tmp->parent) {
+        for (tmp = sd; tmp; ) {
                struct sched_domain *parent = tmp->parent;
                if (!parent)
                        break;
                if (sd_parent_degenerate(tmp, parent)) {
                        tmp->parent = parent->parent;
                        if (parent->parent)
                                parent->parent->child = tmp;
-                }
+                } else
+                        tmp = tmp->parent;
        }
        if (sd && sd_degenerate(sd)) {
@@ -7673,6 +7688,7 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 error:
        free_sched_groups(cpu_map, tmpmask);
        SCHED_CPUMASK_FREE((void *)allmasks);
+        kfree(rd);
        return -ENOMEM;
 #endif
 }
@@ -7774,13 +7790,14 @@ 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,
+ * failed the kmalloc call, then it can pass in doms_new == NULL &&
- * and partition_sched_domains() will fallback to the single partition
+ * ndoms_new == 1, and partition_sched_domains() will fallback to
- * 'fallback_doms', it also forces the domains to be rebuilt.
+ * 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.
+ * If doms_new == NULL it will be replaced with cpu_online_map.
- * ndoms_new==0 is a special case for destroying existing domains.
+ * ndoms_new == 0 is a special case for destroying existing domains,
- * It will not create the default domain.
+ * and it will not create the default domain.
 *
 * Call with hotplug lock held
 */
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index ad958c1ec708..26ed8e3d1c15 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -144,7 +144,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,26 +161,8 @@ 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);
+        SEQ_printf(m, "  .%-30s: %d\n", "nr_spread_over",
-        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",
                        cfs_rq->nr_spread_over);
 #ifdef CONFIG_FAIR_GROUP_SCHED
 #ifdef CONFIG_SMP
@@ -260,6 +242,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);
@@ -319,7 +320,7 @@ static int __init init_sched_debug_procfs(void)
 {
        struct proc_dir_entry *pe;
-        pe = proc_create("sched_debug", 0644, NULL, &sched_debug_fops);
+        pe = proc_create("sched_debug", 0444, NULL, &sched_debug_fops);
        if (!pe)
                return -ENOMEM;
        return 0;
@@ -422,10 +423,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();
+                t0 = cpu_clock(this_cpu);
-                t1 = sched_clock();
+                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 9573c33688b8..98345e45b059 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -143,6 +143,49 @@ static inline struct sched_entity *parent_entity(struct sched_entity *se)
        return se->parent;
 }
+/* return depth at which a sched entity is present in the hierarchy */
+static inline int depth_se(struct sched_entity *se)
+{
+        int depth = 0;
+        for_each_sched_entity(se)
+                depth++;
+        return depth;
+}
+static void
+find_matching_se(struct sched_entity **se, struct sched_entity **pse)
+{
+        int se_depth, pse_depth;
+        /*
+         * preemption test can be made between sibling entities who are in the
+         * same cfs_rq i.e who have a common parent. Walk up the hierarchy of
+         * both tasks until we find their ancestors who are siblings of common
+         * parent.
+         */
+        /* First walk up until both entities are at same depth */
+        se_depth = depth_se(*se);
+        pse_depth = depth_se(*pse);
+        while (se_depth > pse_depth) {
+                se_depth--;
+                *se = parent_entity(*se);
+        }
+        while (pse_depth > se_depth) {
+                pse_depth--;
+                *pse = parent_entity(*pse);
+        }
+        while (!is_same_group(*se, *pse)) {
+                *se = parent_entity(*se);
+                *pse = parent_entity(*pse);
+        }
+}
 #else   /* CONFIG_FAIR_GROUP_SCHED */
 static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
@@ -193,6 +236,11 @@ static inline struct sched_entity *parent_entity(struct sched_entity *se)
        return NULL;
 }
+static inline void
+find_matching_se(struct sched_entity **se, struct sched_entity **pse)
+{
+}
 #endif  /* CONFIG_FAIR_GROUP_SCHED */
@@ -223,6 +271,27 @@ static inline s64 entity_key(struct cfs_rq *cfs_rq, struct sched_entity *se)
        return se->vruntime - cfs_rq->min_vruntime;
 }
+static void update_min_vruntime(struct cfs_rq *cfs_rq)
+{
+        u64 vruntime = cfs_rq->min_vruntime;
+        if (cfs_rq->curr)
+                vruntime = cfs_rq->curr->vruntime;
+        if (cfs_rq->rb_leftmost) {
+                struct sched_entity *se = rb_entry(cfs_rq->rb_leftmost,
+                                                   struct sched_entity,
+                                                   run_node);
+                if (vruntime == cfs_rq->min_vruntime)
+                        vruntime = se->vruntime;
+                else
+                        vruntime = min_vruntime(vruntime, se->vruntime);
+        }
+        cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
+}
 /*
 * Enqueue an entity into the rb-tree:
 */
@@ -256,15 +325,8 @@ static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
         * Maintain a cache of leftmost tree entries (it is frequently
         * used):
         */
-        if (leftmost) {
+        if (leftmost)
                cfs_rq->rb_leftmost = &se->run_node;
-                /*
-                 * maintain cfs_rq->min_vruntime to be a monotonic increasing
-                 * value tracking the leftmost vruntime in the tree.
-                 */
-                cfs_rq->min_vruntime =
-                        max_vruntime(cfs_rq->min_vruntime, se->vruntime);
-        }
        rb_link_node(&se->run_node, parent, link);
        rb_insert_color(&se->run_node, &cfs_rq->tasks_timeline);
@@ -274,37 +336,25 @@ static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
        if (cfs_rq->rb_leftmost == &se->run_node) {
                struct rb_node *next_node;
-                struct sched_entity *next;
                next_node = rb_next(&se->run_node);
                cfs_rq->rb_leftmost = next_node;
-                if (next_node) {
-                        next = rb_entry(next_node,
-                                        struct sched_entity, run_node);
-                        cfs_rq->min_vruntime =
-                                max_vruntime(cfs_rq->min_vruntime,
-                                             next->vruntime);
-                }
        }
-        if (cfs_rq->next == se)
-                cfs_rq->next = NULL;
        rb_erase(&se->run_node, &cfs_rq->tasks_timeline);
 }
-static inline struct rb_node *first_fair(struct cfs_rq *cfs_rq)
-{
-        return cfs_rq->rb_leftmost;
-}
 static struct sched_entity *__pick_next_entity(struct cfs_rq *cfs_rq)
 {
-        return rb_entry(first_fair(cfs_rq), struct sched_entity, run_node);
+        struct rb_node *left = cfs_rq->rb_leftmost;
+        if (!left)
+                return NULL;
+        return rb_entry(left, struct sched_entity, run_node);
 }
-static inline struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
+static struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
 {
        struct rb_node *last = rb_last(&cfs_rq->tasks_timeline);
@@ -424,6 +474,7 @@ __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
        schedstat_add(cfs_rq, exec_clock, delta_exec);
        delta_exec_weighted = calc_delta_fair(delta_exec, curr);
        curr->vruntime += delta_exec_weighted;
+        update_min_vruntime(cfs_rq);
 }
 static void update_curr(struct cfs_rq *cfs_rq)
@@ -613,13 +664,7 @@ static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se)
 static void
 place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
 {
-        u64 vruntime;
+        u64 vruntime = cfs_rq->min_vruntime;
-        if (first_fair(cfs_rq)) {
-                vruntime = min_vruntime(cfs_rq->min_vruntime,
-                                __pick_next_entity(cfs_rq)->vruntime);
-        } else
-                vruntime = cfs_rq->min_vruntime;
        /*
         * The 'current' period is already promised to the current tasks,
@@ -671,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)
 {
@@ -693,9 +747,12 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
 #endif
        }
+        clear_buddies(cfs_rq, se);
        if (se != cfs_rq->curr)
                __dequeue_entity(cfs_rq, se);
        account_entity_dequeue(cfs_rq, se);
+        update_min_vruntime(cfs_rq);
 }
 /*
@@ -742,29 +799,18 @@ set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
        se->prev_sum_exec_runtime = se->sum_exec_runtime;
 }
-static struct sched_entity *
+static int
-pick_next(struct cfs_rq *cfs_rq, struct sched_entity *se)
+wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se);
-{
-        struct rq *rq = rq_of(cfs_rq);
-        u64 pair_slice = rq->clock - cfs_rq->pair_start;
-        if (!cfs_rq->next || pair_slice > sysctl_sched_min_granularity) {
-                cfs_rq->pair_start = rq->clock;
-                return se;
-        }
-        return cfs_rq->next;
-}
 static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq)
 {
-        struct sched_entity *se = NULL;
+        struct sched_entity *se = __pick_next_entity(cfs_rq);
-        if (first_fair(cfs_rq)) {
+        if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, se) < 1)
-                se = __pick_next_entity(cfs_rq);
+                return cfs_rq->next;
-                se = pick_next(cfs_rq, se);
-                set_next_entity(cfs_rq, se);
+        if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, se) < 1)
-        }
+                return cfs_rq->last;
        return se;
 }
@@ -936,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);
                /*
@@ -1122,10 +1170,9 @@ wake_affine(struct sched_domain *this_sd, struct rq *this_rq,
        if (!(this_sd->flags & SD_WAKE_AFFINE) || !sched_feat(AFFINE_WAKEUPS))
                return 0;
-        if (!sync && sched_feat(SYNC_WAKEUPS) &&
+        if (sync && (curr->se.avg_overlap > sysctl_sched_migration_cost ||
-            curr->se.avg_overlap < sysctl_sched_migration_cost &&
+                        p->se.avg_overlap > sysctl_sched_migration_cost))
-            p->se.avg_overlap < sysctl_sched_migration_cost)
+                sync = 0;
-                sync = 1;
        /*
         * If sync wakeup then subtract the (maximum possible)
@@ -1244,33 +1291,88 @@ static unsigned long wakeup_gran(struct sched_entity *se)
         * More easily preempt - nice tasks, while not making it harder for
         * + nice tasks.
         */
-        if (sched_feat(ASYM_GRAN))
+        if (!sched_feat(ASYM_GRAN) || se->load.weight > NICE_0_LOAD)
-                gran = calc_delta_mine(gran, NICE_0_LOAD, &se->load);
+                gran = calc_delta_fair(sysctl_sched_wakeup_granularity, se);
        return gran;
 }
 /*
+ * Should 'se' preempt 'curr'.
+ *
+ *             |s1
+ *        |s2
+ *   |s3
+ *         g
+ *      |<--->|c
+ *
+ *  w(c, s1) = -1
+ *  w(c, s2) =  0
+ *  w(c, s3) =  1
+ *
+ */
+static int
+wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
+{
+        s64 gran, vdiff = curr->vruntime - se->vruntime;
+        if (vdiff <= 0)
+                return -1;
+        gran = wakeup_gran(curr);
+        if (vdiff > gran)
+                return 1;
+        return 0;
+}
+static void set_last_buddy(struct sched_entity *se)
+{
+        for_each_sched_entity(se)
+                cfs_rq_of(se)->last = se;
+}
+static void set_next_buddy(struct sched_entity *se)
+{
+        for_each_sched_entity(se)
+                cfs_rq_of(se)->next = se;
+}
+/*
 * Preempt the current task with a newly woken task if needed:
 */
 static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int sync)
 {
        struct task_struct *curr = rq->curr;
-        struct cfs_rq *cfs_rq = task_cfs_rq(curr);
        struct sched_entity *se = &curr->se, *pse = &p->se;
-        s64 delta_exec;
        if (unlikely(rt_prio(p->prio))) {
+                struct cfs_rq *cfs_rq = task_cfs_rq(curr);
                update_rq_clock(rq);
                update_curr(cfs_rq);
                resched_task(curr);
                return;
        }
+        if (unlikely(p->sched_class != &fair_sched_class))
+                return;
        if (unlikely(se == pse))
                return;
-        cfs_rq_of(pse)->next = pse;
+        /*
+         * Only set the backward buddy when the current task is still on the
+         * rq. This can happen when a wakeup gets interleaved with schedule on
+         * the ->pre_schedule() or idle_balance() point, either of which can
+         * drop the rq lock.
+         *
+         * Also, during early boot the idle thread is in the fair class, for
+         * obvious reasons its a bad idea to schedule back to the idle thread.
+         */
+        if (sched_feat(LAST_BUDDY) && likely(se->on_rq && curr != rq->idle))
+                set_last_buddy(se);
+        set_next_buddy(pse);
        /*
         * We can come here with TIF_NEED_RESCHED already set from new task
@@ -1296,9 +1398,19 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int sync)
                return;
        }
-        delta_exec = se->sum_exec_runtime - se->prev_sum_exec_runtime;
+        find_matching_se(&se, &pse);
-        if (delta_exec > wakeup_gran(pse))
-                resched_task(curr);
+        while (se) {
+                BUG_ON(!pse);
+                if (wakeup_preempt_entity(se, pse) == 1) {
+                        resched_task(curr);
+                        break;
+                }
+                se = parent_entity(se);
+                pse = parent_entity(pse);
+        }
 }
 static struct task_struct *pick_next_task_fair(struct rq *rq)
@@ -1312,6 +1424,7 @@ static struct task_struct *pick_next_task_fair(struct rq *rq)
        do {
                se = pick_next_entity(cfs_rq);
+                set_next_entity(cfs_rq, se);
                cfs_rq = group_cfs_rq(se);
        } while (cfs_rq);
@@ -1594,9 +1707,6 @@ static const struct sched_class fair_sched_class = {
        .enqueue_task           = enqueue_task_fair,
        .dequeue_task           = dequeue_task_fair,
        .yield_task             = yield_task_fair,
-#ifdef CONFIG_SMP
-        .select_task_rq         = select_task_rq_fair,
-#endif /* CONFIG_SMP */
        .check_preempt_curr     = check_preempt_wakeup,
@@ -1604,6 +1714,8 @@ static const struct sched_class fair_sched_class = {
        .put_prev_task          = put_prev_task_fair,
 #ifdef CONFIG_SMP
+        .select_task_rq         = select_task_rq_fair,
        .load_balance           = load_balance_fair,
        .move_one_task          = move_one_task_fair,
 #endif
diff --git a/kernel/sched_features.h b/kernel/sched_features.h
index fda016218296..da5d93b5d2c6 100644
--- a/kernel/sched_features.h
+++ b/kernel/sched_features.h
@@ -12,3 +12,4 @@ SCHED_FEAT(LB_BIAS, 1)
 SCHED_FEAT(LB_WAKEUP_UPDATE, 1)
 SCHED_FEAT(ASYM_EFF_LOAD, 1)
 SCHED_FEAT(WAKEUP_OVERLAP, 0)
+SCHED_FEAT(LAST_BUDDY, 1)
diff --git a/kernel/sched_idletask.c b/kernel/sched_idletask.c
index dec4ccabe2f5..8a21a2e28c13 100644
--- a/kernel/sched_idletask.c
+++ b/kernel/sched_idletask.c
@@ -105,9 +105,6 @@ static const struct sched_class idle_sched_class = {
        /* dequeue is not valid, we print a debug message there: */
        .dequeue_task           = dequeue_task_idle,
-#ifdef CONFIG_SMP
-        .select_task_rq         = select_task_rq_idle,
-#endif /* CONFIG_SMP */
        .check_preempt_curr     = check_preempt_curr_idle,
@@ -115,6 +112,8 @@ static const struct sched_class idle_sched_class = {
        .put_prev_task          = put_prev_task_idle,
 #ifdef CONFIG_SMP
+        .select_task_rq         = select_task_rq_idle,
        .load_balance           = load_balance_idle,
        .move_one_task          = move_one_task_idle,
 #endif
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index b446dc87494f..d9ba9d5f99d6 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -1504,9 +1504,6 @@ static const struct sched_class rt_sched_class = {
        .enqueue_task           = enqueue_task_rt,
        .dequeue_task           = dequeue_task_rt,
        .yield_task             = yield_task_rt,
-#ifdef CONFIG_SMP
-        .select_task_rq         = select_task_rq_rt,
-#endif /* CONFIG_SMP */
        .check_preempt_curr     = check_preempt_curr_rt,
@@ -1514,6 +1511,8 @@ static const struct sched_class rt_sched_class = {
        .put_prev_task          = put_prev_task_rt,
 #ifdef CONFIG_SMP
+        .select_task_rq         = select_task_rq_rt,
        .load_balance           = load_balance_rt,
        .move_one_task          = move_one_task_rt,
        .set_cpus_allowed       = set_cpus_allowed_rt,
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index ee71bec1da66..7dbf72a2b02c 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -298,9 +298,11 @@ static inline void account_group_user_time(struct task_struct *tsk,
 {
        struct signal_struct *sig;
-        sig = tsk->signal;
+        /* tsk == current, ensure it is safe to use ->signal */
-        if (unlikely(!sig))
+        if (unlikely(tsk->exit_state))
                return;
+        sig = tsk->signal;
        if (sig->cputime.totals) {
                struct task_cputime *times;
@@ -325,9 +327,11 @@ static inline void account_group_system_time(struct task_struct *tsk,
 {
        struct signal_struct *sig;
-        sig = tsk->signal;
+        /* tsk == current, ensure it is safe to use ->signal */
-        if (unlikely(!sig))
+        if (unlikely(tsk->exit_state))
                return;
+        sig = tsk->signal;
        if (sig->cputime.totals) {
                struct task_cputime *times;
@@ -353,8 +357,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 105217da5c82..4530fc654455 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1144,7 +1144,8 @@ static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
                struct task_struct * p;
                for_each_process(p) {
-                        if (p->pid > 1 && !same_thread_group(p, current)) {
+                        if (task_pid_vnr(p) > 1 &&
+                                        !same_thread_group(p, current)) {
                                int err = group_send_sig_info(sig, info, p);
                                ++count;
                                if (err != -EPERM)
diff --git a/kernel/smp.c b/kernel/smp.c
index f362a8553777..75c8dde58c55 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -51,10 +51,6 @@ static void csd_flag_wait(struct call_single_data *data)
 {
        /* Wait for response */
        do {
-                /*
-                 * We need to see the flags store in the IPI handler
-                 */
-                smp_mb();
                if (!(data->flags & CSD_FLAG_WAIT))
                        break;
                cpu_relax();
@@ -76,6 +72,11 @@ static void generic_exec_single(int cpu, struct call_single_data *data)
        list_add_tail(&data->list, &dst->list);
        spin_unlock_irqrestore(&dst->lock, flags);
+        /*
+         * Make the list addition visible before sending the ipi.
+         */
+        smp_mb();
        if (ipi)
                arch_send_call_function_single_ipi(cpu);
@@ -157,7 +158,7 @@ void generic_smp_call_function_single_interrupt(void)
         * Need to see other stores to list head for checking whether
         * list is empty without holding q->lock
         */
-        smp_mb();
+        smp_read_barrier_depends();
        while (!list_empty(&q->list)) {
                unsigned int data_flags;
@@ -191,7 +192,7 @@ void generic_smp_call_function_single_interrupt(void)
                /*
                 * See comment on outer loop
                 */
-                smp_mb();
+                smp_read_barrier_depends();
        }
 }
@@ -370,6 +371,11 @@ int smp_call_function_mask(cpumask_t mask, void (*func)(void *), void *info,
        list_add_tail_rcu(&data->csd.list, &call_function_queue);
        spin_unlock_irqrestore(&call_function_lock, flags);
+        /*
+         * Make the list addition visible before sending the ipi.
+         */
+        smp_mb();
        /* Send a message to all CPUs in the map */
        arch_send_call_function_ipi(mask);
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);
+        } else
-        __irq_enter();
+                __irq_enter();
 }
 #ifdef __ARCH_IRQ_EXIT_IRQS_DISABLED
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_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 a13bd4dfaeb1..3d56fe7570da 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;
@@ -474,7 +477,7 @@ static struct ctl_table kern_table[] = {
                .mode           = 0644,
                .proc_handler   = &proc_dointvec,
        },
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
        {
                .ctl_name       = CTL_UNNUMBERED,
                .procname       = "ftrace_enabled",
@@ -1325,6 +1328,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..342fc9ccab46 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -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/timer.c b/kernel/timer.c
index 56becf373c58..dbd50fabe4c7 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -112,27 +112,8 @@ timer_set_base(struct timer_list *timer, struct tvec_base *new_base)
                                      tbase_get_deferrable(timer->base));
 }
-/**
+static unsigned long round_jiffies_common(unsigned long j, int cpu,
- * __round_jiffies - function to round jiffies to a full second
+                bool force_up)
- * @j: the time in (absolute) jiffies that should be rounded
- * @cpu: the processor number on which the timeout will happen
- *
- * __round_jiffies() rounds an absolute time in the future (in jiffies)
- * up or down to (approximately) full seconds. This is useful for timers
- * for which the exact time they fire does not matter too much, as long as
- * they fire approximately every X seconds.
- *
- * By rounding these timers to whole seconds, all such timers will fire
- * at the same time, rather than at various times spread out. The goal
- * of this is to have the CPU wake up less, which saves power.
- *
- * The exact rounding is skewed for each processor to avoid all
- * processors firing at the exact same time, which could lead
- * to lock contention or spurious cache line bouncing.
- *
- * The return value is the rounded version of the @j parameter.
- */
-unsigned long __round_jiffies(unsigned long j, int cpu)
 {
        int rem;
        unsigned long original = j;
@@ -154,8 +135,9 @@ unsigned long __round_jiffies(unsigned long j, int cpu)
         * due to delays of the timer irq, long irq off times etc etc) then
         * we should round down to the whole second, not up. Use 1/4th second
         * as cutoff for this rounding as an extreme upper bound for this.
+         * But never round down if @force_up is set.
         */
-        if (rem < HZ/4) /* round down */
+        if (rem < HZ/4 && !force_up) /* round down */
                j = j - rem;
        else /* round up */
                j = j - rem + HZ;
@@ -167,6 +149,31 @@ unsigned long __round_jiffies(unsigned long j, int cpu)
                return original;
        return j;
 }
+/**
+ * __round_jiffies - function to round jiffies to a full second
+ * @j: the time in (absolute) jiffies that should be rounded
+ * @cpu: the processor number on which the timeout will happen
+ *
+ * __round_jiffies() rounds an absolute time in the future (in jiffies)
+ * up or down to (approximately) full seconds. This is useful for timers
+ * for which the exact time they fire does not matter too much, as long as
+ * they fire approximately every X seconds.
+ *
+ * By rounding these timers to whole seconds, all such timers will fire
+ * at the same time, rather than at various times spread out. The goal
+ * of this is to have the CPU wake up less, which saves power.
+ *
+ * The exact rounding is skewed for each processor to avoid all
+ * processors firing at the exact same time, which could lead
+ * to lock contention or spurious cache line bouncing.
+ *
+ * The return value is the rounded version of the @j parameter.
+ */
+unsigned long __round_jiffies(unsigned long j, int cpu)
+{
+        return round_jiffies_common(j, cpu, false);
+}
 EXPORT_SYMBOL_GPL(__round_jiffies);
 /**
@@ -191,13 +198,10 @@ EXPORT_SYMBOL_GPL(__round_jiffies);
 */
 unsigned long __round_jiffies_relative(unsigned long j, int cpu)
 {
-        /*
+        unsigned long j0 = jiffies;
-         * In theory the following code can skip a jiffy in case jiffies
-         * increments right between the addition and the later subtraction.
+        /* Use j0 because jiffies might change while we run */
-         * However since the entire point of this function is to use approximate
+        return round_jiffies_common(j + j0, cpu, false) - j0;
-         * timeouts, it's entirely ok to not handle that.
-         */
-        return  __round_jiffies(j + jiffies, cpu) - jiffies;
 }
 EXPORT_SYMBOL_GPL(__round_jiffies_relative);
@@ -218,7 +222,7 @@ EXPORT_SYMBOL_GPL(__round_jiffies_relative);
 */
 unsigned long round_jiffies(unsigned long j)
 {
-        return __round_jiffies(j, raw_smp_processor_id());
+        return round_jiffies_common(j, raw_smp_processor_id(), false);
 }
 EXPORT_SYMBOL_GPL(round_jiffies);
@@ -243,6 +247,71 @@ unsigned long round_jiffies_relative(unsigned long j)
 }
 EXPORT_SYMBOL_GPL(round_jiffies_relative);
+/**
+ * __round_jiffies_up - function to round jiffies up to a full second
+ * @j: the time in (absolute) jiffies that should be rounded
+ * @cpu: the processor number on which the timeout will happen
+ *
+ * This is the same as __round_jiffies() except that it will never
+ * round down.  This is useful for timeouts for which the exact time
+ * of firing does not matter too much, as long as they don't fire too
+ * early.
+ */
+unsigned long __round_jiffies_up(unsigned long j, int cpu)
+{
+        return round_jiffies_common(j, cpu, true);
+}
+EXPORT_SYMBOL_GPL(__round_jiffies_up);
+/**
+ * __round_jiffies_up_relative - function to round jiffies up to a full second
+ * @j: the time in (relative) jiffies that should be rounded
+ * @cpu: the processor number on which the timeout will happen
+ *
+ * This is the same as __round_jiffies_relative() except that it will never
+ * round down.  This is useful for timeouts for which the exact time
+ * of firing does not matter too much, as long as they don't fire too
+ * early.
+ */
+unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
+{
+        unsigned long j0 = jiffies;
+        /* Use j0 because jiffies might change while we run */
+        return round_jiffies_common(j + j0, cpu, true) - j0;
+}
+EXPORT_SYMBOL_GPL(__round_jiffies_up_relative);
+/**
+ * round_jiffies_up - function to round jiffies up to a full second
+ * @j: the time in (absolute) jiffies that should be rounded
+ *
+ * This is the same as round_jiffies() except that it will never
+ * round down.  This is useful for timeouts for which the exact time
+ * of firing does not matter too much, as long as they don't fire too
+ * early.
+ */
+unsigned long round_jiffies_up(unsigned long j)
+{
+        return round_jiffies_common(j, raw_smp_processor_id(), true);
+}
+EXPORT_SYMBOL_GPL(round_jiffies_up);
+/**
+ * round_jiffies_up_relative - function to round jiffies up to a full second
+ * @j: the time in (relative) jiffies that should be rounded
+ *
+ * This is the same as round_jiffies_relative() except that it will never
+ * round down.  This is useful for timeouts for which the exact time
+ * of firing does not matter too much, as long as they don't fire too
+ * early.
+ */
+unsigned long round_jiffies_up_relative(unsigned long j)
+{
+        return __round_jiffies_up_relative(j, raw_smp_processor_id());
+}
+EXPORT_SYMBOL_GPL(round_jiffies_up_relative);
 static inline void set_running_timer(struct tvec_base *base,
                                        struct timer_list *timer)
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 1cb3e1f616af..33dbefd471e8 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -1,13 +1,13 @@
 #
-# Architectures that offer an FTRACE implementation should select HAVE_FTRACE:
+# Architectures that offer an FUNCTION_TRACER implementation should
+#  select HAVE_FUNCTION_TRACER:
 #
 config NOP_TRACER
        bool
-config HAVE_FTRACE
+config HAVE_FUNCTION_TRACER
        bool
-        select NOP_TRACER
 config HAVE_DYNAMIC_FTRACE
        bool
@@ -25,12 +25,15 @@ config TRACING
        bool
        select DEBUG_FS
        select RING_BUFFER
-        select STACKTRACE
+        select STACKTRACE if STACKTRACE_SUPPORT
        select TRACEPOINTS
+        select NOP_TRACER
-config FTRACE
+menu "Tracers"
+config FUNCTION_TRACER
        bool "Kernel Function Tracer"
-        depends on HAVE_FTRACE
+        depends on HAVE_FUNCTION_TRACER
        depends on DEBUG_KERNEL
        select FRAME_POINTER
        select TRACING
@@ -49,7 +52,6 @@ config IRQSOFF_TRACER
        default n
        depends on TRACE_IRQFLAGS_SUPPORT
        depends on GENERIC_TIME
-        depends on HAVE_FTRACE
        depends on DEBUG_KERNEL
        select TRACE_IRQFLAGS
        select TRACING
@@ -73,7 +75,6 @@ config PREEMPT_TRACER
        default n
        depends on GENERIC_TIME
        depends on PREEMPT
-        depends on HAVE_FTRACE
        depends on DEBUG_KERNEL
        select TRACING
        select TRACER_MAX_TRACE
@@ -101,7 +102,6 @@ config SYSPROF_TRACER
 config SCHED_TRACER
        bool "Scheduling Latency Tracer"
-        depends on HAVE_FTRACE
        depends on DEBUG_KERNEL
        select TRACING
        select CONTEXT_SWITCH_TRACER
@@ -112,7 +112,6 @@ config SCHED_TRACER
 config CONTEXT_SWITCH_TRACER
        bool "Trace process context switches"
-        depends on HAVE_FTRACE
        depends on DEBUG_KERNEL
        select TRACING
        select MARKERS
@@ -122,9 +121,9 @@ config CONTEXT_SWITCH_TRACER
 config BOOT_TRACER
        bool "Trace boot initcalls"
-        depends on HAVE_FTRACE
        depends on DEBUG_KERNEL
        select TRACING
+        select CONTEXT_SWITCH_TRACER
        help
          This tracer helps developers to optimize boot times: it records
          the timings of the initcalls and traces key events and the identity
@@ -141,9 +140,9 @@ config BOOT_TRACER
 config STACK_TRACER
        bool "Trace max stack"
-        depends on HAVE_FTRACE
+        depends on HAVE_FUNCTION_TRACER
        depends on DEBUG_KERNEL
-        select FTRACE
+        select FUNCTION_TRACER
        select STACKTRACE
        help
          This special tracer records the maximum stack footprint of the
@@ -160,7 +159,7 @@ config STACK_TRACER
 config DYNAMIC_FTRACE
        bool "enable/disable ftrace tracepoints dynamically"
-        depends on FTRACE
+        depends on FUNCTION_TRACER
        depends on HAVE_DYNAMIC_FTRACE
        depends on DEBUG_KERNEL
        default y
@@ -170,7 +169,7 @@ config DYNAMIC_FTRACE
         with a No-Op instruction) as they are called. A table is
         created to dynamically enable them again.
-         This way a CONFIG_FTRACE kernel is slightly larger, but otherwise
+         This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
         has native performance as long as no tracing is active.
         The changes to the code are done by a kernel thread that
@@ -195,3 +194,5 @@ config FTRACE_STARTUP_TEST
          a series of tests are made to verify that the tracer is
          functioning properly. It will do tests on all the configured
          tracers of ftrace.
+endmenu
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index a85dfba88ba0..c8228b1a49e9 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -1,7 +1,7 @@
 # Do not instrument the tracer itself:
-ifdef CONFIG_FTRACE
+ifdef CONFIG_FUNCTION_TRACER
 ORIG_CFLAGS := $(KBUILD_CFLAGS)
 KBUILD_CFLAGS = $(subst -pg,,$(ORIG_CFLAGS))
@@ -10,13 +10,13 @@ CFLAGS_trace_selftest_dynamic.o = -pg
 obj-y += trace_selftest_dynamic.o
 endif
-obj-$(CONFIG_FTRACE) += libftrace.o
+obj-$(CONFIG_FUNCTION_TRACER) += libftrace.o
 obj-$(CONFIG_RING_BUFFER) += ring_buffer.o
 obj-$(CONFIG_TRACING) += trace.o
 obj-$(CONFIG_CONTEXT_SWITCH_TRACER) += trace_sched_switch.o
 obj-$(CONFIG_SYSPROF_TRACER) += trace_sysprof.o
-obj-$(CONFIG_FTRACE) += trace_functions.o
+obj-$(CONFIG_FUNCTION_TRACER) += trace_functions.o
 obj-$(CONFIG_IRQSOFF_TRACER) += trace_irqsoff.o
 obj-$(CONFIG_PREEMPT_TRACER) += trace_irqsoff.o
 obj-$(CONFIG_SCHED_TRACER) += trace_sched_wakeup.o
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 4dda4f60a2a9..78db083390f0 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -25,13 +25,24 @@
 #include <linux/ftrace.h>
 #include <linux/sysctl.h>
 #include <linux/ctype.h>
-#include <linux/hash.h>
 #include <linux/list.h>
 #include <asm/ftrace.h>
 #include "trace.h"
+#define FTRACE_WARN_ON(cond)                    \
+        do {                                    \
+                if (WARN_ON(cond))              \
+                        ftrace_kill();          \
+        } while (0)
+#define FTRACE_WARN_ON_ONCE(cond)               \
+        do {                                    \
+                if (WARN_ON_ONCE(cond))         \
+                        ftrace_kill();          \
+        } while (0)
 /* ftrace_enabled is a method to turn ftrace on or off */
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
@@ -153,21 +164,8 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
 }
 #ifdef CONFIG_DYNAMIC_FTRACE
 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
-/*
+# error Dynamic ftrace depends on MCOUNT_RECORD
- * The hash lock is only needed when the recording of the mcount
- * callers are dynamic. That is, by the caller themselves and
- * not recorded via the compilation.
- */
-static DEFINE_SPINLOCK(ftrace_hash_lock);
-#define ftrace_hash_lock(flags)   spin_lock_irqsave(&ftrace_hash_lock, flags)
-#define ftrace_hash_unlock(flags) \
-                        spin_unlock_irqrestore(&ftrace_hash_lock, flags)
-#else
-/* This is protected via the ftrace_lock with MCOUNT_RECORD. */
-#define ftrace_hash_lock(flags)   do { (void)(flags); } while (0)
-#define ftrace_hash_unlock(flags) do { } while(0)
 #endif
 /*
@@ -178,8 +176,6 @@ static DEFINE_SPINLOCK(ftrace_hash_lock);
 */
 static unsigned long mcount_addr = MCOUNT_ADDR;
-static struct task_struct *ftraced_task;
 enum {
        FTRACE_ENABLE_CALLS             = (1 << 0),
        FTRACE_DISABLE_CALLS            = (1 << 1),
@@ -189,14 +185,9 @@ enum {
 };
 static int ftrace_filtered;
-static int tracing_on;
-static int frozen_record_count;
-static struct hlist_head ftrace_hash[FTRACE_HASHSIZE];
-static DEFINE_PER_CPU(int, ftrace_shutdown_disable_cpu);
+static LIST_HEAD(ftrace_new_addrs);
-static DEFINE_MUTEX(ftraced_lock);
 static DEFINE_MUTEX(ftrace_regex_lock);
 struct ftrace_page {
@@ -214,16 +205,13 @@ struct ftrace_page {
 static struct ftrace_page       *ftrace_pages_start;
 static struct ftrace_page       *ftrace_pages;
-static int ftraced_trigger;
-static int ftraced_suspend;
-static int ftraced_stop;
-static int ftrace_record_suspend;
 static struct dyn_ftrace *ftrace_free_records;
 #ifdef CONFIG_KPROBES
+static int frozen_record_count;
 static inline void freeze_record(struct dyn_ftrace *rec)
 {
        if (!(rec->flags & FTRACE_FL_FROZEN)) {
@@ -250,72 +238,6 @@ static inline int record_frozen(struct dyn_ftrace *rec)
 # define record_frozen(rec)                     ({ 0; })
 #endif /* CONFIG_KPROBES */
-int skip_trace(unsigned long ip)
-{
-        unsigned long fl;
-        struct dyn_ftrace *rec;
-        struct hlist_node *t;
-        struct hlist_head *head;
-        if (frozen_record_count == 0)
-                return 0;
-        head = &ftrace_hash[hash_long(ip, FTRACE_HASHBITS)];
-        hlist_for_each_entry_rcu(rec, t, head, node) {
-                if (rec->ip == ip) {
-                        if (record_frozen(rec)) {
-                                if (rec->flags & FTRACE_FL_FAILED)
-                                        return 1;
-                                if (!(rec->flags & FTRACE_FL_CONVERTED))
-                                        return 1;
-                                if (!tracing_on || !ftrace_enabled)
-                                        return 1;
-                                if (ftrace_filtered) {
-                                        fl = rec->flags & (FTRACE_FL_FILTER |
-                                                           FTRACE_FL_NOTRACE);
-                                        if (!fl || (fl & FTRACE_FL_NOTRACE))
-                                                return 1;
-                                }
-                        }
-                        break;
-                }
-        }
-        return 0;
-}
-static inline int
-ftrace_ip_in_hash(unsigned long ip, unsigned long key)
-{
-        struct dyn_ftrace *p;
-        struct hlist_node *t;
-        int found = 0;
-        hlist_for_each_entry_rcu(p, t, &ftrace_hash[key], node) {
-                if (p->ip == ip) {
-                        found = 1;
-                        break;
-                }
-        }
-        return found;
-}
-static inline void
-ftrace_add_hash(struct dyn_ftrace *node, unsigned long key)
-{
-        hlist_add_head_rcu(&node->node, &ftrace_hash[key]);
-}
-/* called from kstop_machine */
-static inline void ftrace_del_hash(struct dyn_ftrace *node)
-{
-        hlist_del(&node->node);
-}
 static void ftrace_free_rec(struct dyn_ftrace *rec)
 {
        rec->ip = (unsigned long)ftrace_free_records;
@@ -346,7 +268,6 @@ void ftrace_release(void *start, unsigned long size)
                }
        }
        spin_unlock(&ftrace_lock);
 }
 static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
@@ -358,10 +279,8 @@ static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
                rec = ftrace_free_records;
                if (unlikely(!(rec->flags & FTRACE_FL_FREE))) {
-                        WARN_ON_ONCE(1);
+                        FTRACE_WARN_ON_ONCE(1);
                        ftrace_free_records = NULL;
-                        ftrace_disabled = 1;
-                        ftrace_enabled = 0;
                        return NULL;
                }
@@ -371,172 +290,125 @@ static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
        }
        if (ftrace_pages->index == ENTRIES_PER_PAGE) {
-                if (!ftrace_pages->next)
+                if (!ftrace_pages->next) {
-                        return NULL;
+                        /* allocate another page */
+                        ftrace_pages->next =
+                                (void *)get_zeroed_page(GFP_KERNEL);
+                        if (!ftrace_pages->next)
+                                return NULL;
+                }
                ftrace_pages = ftrace_pages->next;
        }
        return &ftrace_pages->records[ftrace_pages->index++];
 }
-static void
+static struct dyn_ftrace *
 ftrace_record_ip(unsigned long ip)
 {
-        struct dyn_ftrace *node;
+        struct dyn_ftrace *rec;
-        unsigned long flags;
-        unsigned long key;
-        int resched;
-        int cpu;
        if (!ftrace_enabled || ftrace_disabled)
-                return;
+                return NULL;
-        resched = need_resched();
-        preempt_disable_notrace();
-        /*
-         * We simply need to protect against recursion.
-         * Use the the raw version of smp_processor_id and not
-         * __get_cpu_var which can call debug hooks that can
-         * cause a recursive crash here.
-         */
-        cpu = raw_smp_processor_id();
-        per_cpu(ftrace_shutdown_disable_cpu, cpu)++;
-        if (per_cpu(ftrace_shutdown_disable_cpu, cpu) != 1)
-                goto out;
-        if (unlikely(ftrace_record_suspend))
-                goto out;
-        key = hash_long(ip, FTRACE_HASHBITS);
-        WARN_ON_ONCE(key >= FTRACE_HASHSIZE);
-        if (ftrace_ip_in_hash(ip, key))
-                goto out;
-        ftrace_hash_lock(flags);
-        /* This ip may have hit the hash before the lock */
-        if (ftrace_ip_in_hash(ip, key))
-                goto out_unlock;
-        node = ftrace_alloc_dyn_node(ip);
-        if (!node)
-                goto out_unlock;
-        node->ip = ip;
+        rec = ftrace_alloc_dyn_node(ip);
+        if (!rec)
-        ftrace_add_hash(node, key);
+                return NULL;
-        ftraced_trigger = 1;
+        rec->ip = ip;
- out_unlock:
+        list_add(&rec->list, &ftrace_new_addrs);
-        ftrace_hash_unlock(flags);
- out:
-        per_cpu(ftrace_shutdown_disable_cpu, cpu)--;
-        /* prevent recursion with scheduler */
+        return rec;
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
 }
 #define FTRACE_ADDR ((long)(ftrace_caller))
 static int
 __ftrace_replace_code(struct dyn_ftrace *rec,
-                      unsigned char *old, unsigned char *new, int enable)
+                      unsigned char *nop, int enable)
 {
        unsigned long ip, fl;
+        unsigned char *call, *old, *new;
        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:
+                 * 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.
                 */
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
-                                   FTRACE_FL_ENABLED);
-                if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
+                /* Record is filtered and enabled, do nothing */
-                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
+                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
-                    !fl || (fl == FTRACE_FL_NOTRACE))
                        return 0;
-                /*
+                /* Record is not filtered and is not enabled do nothing */
-                 * If it is enabled disable it,
+                if (!fl)
-                 * otherwise enable it!
+                        return 0;
-                 */
-                if (fl & FTRACE_FL_ENABLED) {
+                /* Record is not filtered but enabled, disable it */
-                        /* swap new and old */
+                if (fl == FTRACE_FL_ENABLED)
-                        new = old;
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
                        rec->flags &= ~FTRACE_FL_ENABLED;
-                } else {
+                else
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
+                /* Otherwise record is filtered but not enabled, enable it */
                        rec->flags |= FTRACE_FL_ENABLED;
-                }
        } else {
+                /* Disable or not filtered */
                if (enable) {
-                        /*
+                        /* if record is enabled, do nothing */
-                         * 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 (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;
                }
        }
+        call = ftrace_call_replace(ip, FTRACE_ADDR);
+        if (rec->flags & FTRACE_FL_ENABLED) {
+                old = nop;
+                new = call;
+        } else {
+                old = call;
+                new = nop;
+        }
        return ftrace_modify_code(ip, old, new);
 }
 static void ftrace_replace_code(int enable)
 {
        int i, failed;
-        unsigned char *new = NULL, *old = NULL;
+        unsigned char *nop = NULL;
        struct dyn_ftrace *rec;
        struct ftrace_page *pg;
-        if (enable)
+        nop = ftrace_nop_replace();
-                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++) {
@@ -554,12 +426,11 @@ static void ftrace_replace_code(int enable)
                                unfreeze_record(rec);
                        }
-                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        failed = __ftrace_replace_code(rec, nop, enable);
                        if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
                                rec->flags |= FTRACE_FL_FAILED;
                                if ((system_state == SYSTEM_BOOTING) ||
                                    !core_kernel_text(rec->ip)) {
-                                        ftrace_del_hash(rec);
                                        ftrace_free_rec(rec);
                                }
                        }
@@ -567,15 +438,6 @@ static void ftrace_replace_code(int enable)
        }
 }
-static void ftrace_shutdown_replenish(void)
-{
-        if (ftrace_pages->next)
-                return;
-        /* allocate another page */
-        ftrace_pages->next = (void *)get_zeroed_page(GFP_KERNEL);
-}
 static void print_ip_ins(const char *fmt, unsigned char *p)
 {
        int i;
@@ -591,23 +453,23 @@ ftrace_code_disable(struct dyn_ftrace *rec)
 {
        unsigned long ip;
        unsigned char *nop, *call;
-        int failed;
+        int ret;
        ip = rec->ip;
        nop = ftrace_nop_replace();
        call = ftrace_call_replace(ip, mcount_addr);
-        failed = ftrace_modify_code(ip, call, nop);
+        ret = ftrace_modify_code(ip, call, nop);
-        if (failed) {
+        if (ret) {
-                switch (failed) {
+                switch (ret) {
-                case 1:
+                case -EFAULT:
-                        WARN_ON_ONCE(1);
+                        FTRACE_WARN_ON_ONCE(1);
                        pr_info("ftrace faulted on modifying ");
                        print_ip_sym(ip);
                        break;
-                case 2:
+                case -EINVAL:
-                        WARN_ON_ONCE(1);
+                        FTRACE_WARN_ON_ONCE(1);
                        pr_info("ftrace failed to modify ");
                        print_ip_sym(ip);
                        print_ip_ins(" expected: ", call);
@@ -615,6 +477,15 @@ ftrace_code_disable(struct dyn_ftrace *rec)
                        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);
                }
                rec->flags |= FTRACE_FL_FAILED;
@@ -623,37 +494,18 @@ ftrace_code_disable(struct dyn_ftrace *rec)
        return 1;
 }
-static int __ftrace_update_code(void *ignore);
 static int __ftrace_modify_code(void *data)
 {
-        unsigned long addr;
        int *command = data;
-        if (*command & FTRACE_ENABLE_CALLS) {
+        if (*command & FTRACE_ENABLE_CALLS)
-                /*
-                 * Update any recorded ips now that we have the
-                 * machine stopped
-                 */
-                __ftrace_update_code(NULL);
                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_ENABLE_MCOUNT) {
-                addr = (unsigned long)ftrace_record_ip;
-                ftrace_mcount_set(&addr);
-        } else if (*command & FTRACE_DISABLE_MCOUNT) {
-                addr = (unsigned long)ftrace_stub;
-                ftrace_mcount_set(&addr);
-        }
        return 0;
 }
@@ -662,26 +514,9 @@ static void ftrace_run_update_code(int command)
        stop_machine(__ftrace_modify_code, &command, NULL);
 }
-void ftrace_disable_daemon(void)
-{
-        /* Stop the daemon from calling kstop_machine */
-        mutex_lock(&ftraced_lock);
-        ftraced_stop = 1;
-        mutex_unlock(&ftraced_lock);
-        ftrace_force_update();
-}
-void ftrace_enable_daemon(void)
-{
-        mutex_lock(&ftraced_lock);
-        ftraced_stop = 0;
-        mutex_unlock(&ftraced_lock);
-        ftrace_force_update();
-}
 static ftrace_func_t saved_ftrace_func;
+static int ftrace_start;
+static DEFINE_MUTEX(ftrace_start_lock);
 static void ftrace_startup(void)
 {
@@ -690,10 +525,9 @@ static void ftrace_startup(void)
        if (unlikely(ftrace_disabled))
                return;
-        mutex_lock(&ftraced_lock);
+        mutex_lock(&ftrace_start_lock);
-        ftraced_suspend++;
+        ftrace_start++;
-        if (ftraced_suspend == 1)
+        command |= FTRACE_ENABLE_CALLS;
-                command |= FTRACE_ENABLE_CALLS;
        if (saved_ftrace_func != ftrace_trace_function) {
                saved_ftrace_func = ftrace_trace_function;
@@ -705,7 +539,7 @@ static void ftrace_startup(void)
        ftrace_run_update_code(command);
 out:
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 static void ftrace_shutdown(void)
@@ -715,9 +549,9 @@ static void ftrace_shutdown(void)
        if (unlikely(ftrace_disabled))
                return;
-        mutex_lock(&ftraced_lock);
+        mutex_lock(&ftrace_start_lock);
-        ftraced_suspend--;
+        ftrace_start--;
-        if (!ftraced_suspend)
+        if (!ftrace_start)
                command |= FTRACE_DISABLE_CALLS;
        if (saved_ftrace_func != ftrace_trace_function) {
@@ -730,7 +564,7 @@ static void ftrace_shutdown(void)
        ftrace_run_update_code(command);
 out:
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 static void ftrace_startup_sysctl(void)
@@ -740,15 +574,15 @@ static void ftrace_startup_sysctl(void)
        if (unlikely(ftrace_disabled))
                return;
-        mutex_lock(&ftraced_lock);
+        mutex_lock(&ftrace_start_lock);
        /* Force update next time */
        saved_ftrace_func = NULL;
-        /* ftraced_suspend is true if we want ftrace running */
+        /* ftrace_start is true if we want ftrace running */
-        if (ftraced_suspend)
+        if (ftrace_start)
                command |= FTRACE_ENABLE_CALLS;
        ftrace_run_update_code(command);
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 static void ftrace_shutdown_sysctl(void)
@@ -758,112 +592,50 @@ static void ftrace_shutdown_sysctl(void)
        if (unlikely(ftrace_disabled))
                return;
-        mutex_lock(&ftraced_lock);
+        mutex_lock(&ftrace_start_lock);
-        /* ftraced_suspend is true if ftrace is running */
+        /* ftrace_start is true if ftrace is running */
-        if (ftraced_suspend)
+        if (ftrace_start)
                command |= FTRACE_DISABLE_CALLS;
        ftrace_run_update_code(command);
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 static cycle_t          ftrace_update_time;
 static unsigned long    ftrace_update_cnt;
 unsigned long           ftrace_update_tot_cnt;
-static int __ftrace_update_code(void *ignore)
+static int ftrace_update_code(void)
 {
-        int i, save_ftrace_enabled;
+        struct dyn_ftrace *p, *t;
        cycle_t start, stop;
-        struct dyn_ftrace *p;
-        struct hlist_node *t, *n;
-        struct hlist_head *head, temp_list;
-        /* Don't be recording funcs now */
-        ftrace_record_suspend++;
-        save_ftrace_enabled = ftrace_enabled;
-        ftrace_enabled = 0;
        start = ftrace_now(raw_smp_processor_id());
        ftrace_update_cnt = 0;
-        /* No locks needed, the machine is stopped! */
+        list_for_each_entry_safe(p, t, &ftrace_new_addrs, list) {
-        for (i = 0; i < FTRACE_HASHSIZE; i++) {
-                INIT_HLIST_HEAD(&temp_list);
-                head = &ftrace_hash[i];
-                /* all CPUS are stopped, we are safe to modify code */
-                hlist_for_each_entry_safe(p, t, n, head, node) {
-                        /* Skip over failed records which have not been
-                         * freed. */
-                        if (p->flags & FTRACE_FL_FAILED)
-                                continue;
-                        /* Unconverted records are always at the head of the
+                /* If something went wrong, bail without enabling anything */
-                         * hash bucket. Once we encounter a converted record,
+                if (unlikely(ftrace_disabled))
-                         * simply skip over to the next bucket. Saves ftraced
+                        return -1;
-                         * some processor cycles (ftrace does its bid for
-                         * global warming :-p ). */
-                        if (p->flags & (FTRACE_FL_CONVERTED))
-                                break;
-                        /* Ignore updates to this record's mcount site.
+                list_del_init(&p->list);
-                         * Reintroduce this record at the head of this
-                         * bucket to attempt to "convert" it again if
-                         * the kprobe on it is unregistered before the
-                         * next run. */
-                        if (get_kprobe((void *)p->ip)) {
-                                ftrace_del_hash(p);
-                                INIT_HLIST_NODE(&p->node);
-                                hlist_add_head(&p->node, &temp_list);
-                                freeze_record(p);
-                                continue;
-                        } else {
-                                unfreeze_record(p);
-                        }
-                        /* convert record (i.e, patch mcount-call with NOP) */
+                /* convert record (i.e, patch mcount-call with NOP) */
-                        if (ftrace_code_disable(p)) {
+                if (ftrace_code_disable(p)) {
-                                p->flags |= FTRACE_FL_CONVERTED;
+                        p->flags |= FTRACE_FL_CONVERTED;
-                                ftrace_update_cnt++;
+                        ftrace_update_cnt++;
-                        } else {
+                } else
-                                if ((system_state == SYSTEM_BOOTING) ||
+                        ftrace_free_rec(p);
-                                    !core_kernel_text(p->ip)) {
-                                        ftrace_del_hash(p);
-                                        ftrace_free_rec(p);
-                                }
-                        }
-                }
-                hlist_for_each_entry_safe(p, t, n, &temp_list, node) {
-                        hlist_del(&p->node);
-                        INIT_HLIST_NODE(&p->node);
-                        hlist_add_head(&p->node, head);
-                }
        }
        stop = ftrace_now(raw_smp_processor_id());
        ftrace_update_time = stop - start;
        ftrace_update_tot_cnt += ftrace_update_cnt;
-        ftraced_trigger = 0;
-        ftrace_enabled = save_ftrace_enabled;
-        ftrace_record_suspend--;
        return 0;
 }
-static int ftrace_update_code(void)
-{
-        if (unlikely(ftrace_disabled) ||
-            !ftrace_enabled || !ftraced_trigger)
-                return 0;
-        stop_machine(__ftrace_update_code, NULL, NULL);
-        return 1;
-}
 static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
 {
        struct ftrace_page *pg;
@@ -892,8 +664,8 @@ static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
        pg = ftrace_pages = ftrace_pages_start;
        cnt = num_to_init / ENTRIES_PER_PAGE;
-        pr_info("ftrace: allocating %ld hash entries in %d pages\n",
+        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);
@@ -954,6 +726,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;
@@ -973,13 +748,11 @@ static void *t_start(struct seq_file *m, loff_t *pos)
        void *p = NULL;
        loff_t l = -1;
-        if (*pos != iter->pos) {
+        if (*pos > iter->pos)
-                for (p = t_next(m, p, &l); p && l < *pos; p = t_next(m, p, &l))
+                *pos = iter->pos;
-                        ;
-        } else {
+        l = *pos;
-                l = *pos;
+        p = t_next(m, p, &l);
-                p = t_next(m, p, &l);
-        }
        return p;
 }
@@ -990,15 +763,21 @@ static void t_stop(struct seq_file *m, void *p)
 static int t_show(struct seq_file *m, void *v)
 {
+        struct ftrace_iterator *iter = m->private;
        struct dyn_ftrace *rec = v;
        char str[KSYM_SYMBOL_LEN];
+        int ret = 0;
        if (!rec)
                return 0;
        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-        seq_printf(m, "%s\n", str);
+        ret = seq_printf(m, "%s\n", str);
+        if (ret < 0) {
+                iter->pos--;
+                iter->idx--;
+        }
        return 0;
 }
@@ -1024,7 +803,7 @@ ftrace_avail_open(struct inode *inode, struct file *file)
                return -ENOMEM;
        iter->pg = ftrace_pages_start;
-        iter->pos = -1;
+        iter->pos = 0;
        ret = seq_open(file, &show_ftrace_seq_ops);
        if (!ret) {
@@ -1111,7 +890,7 @@ 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->pos = 0;
                iter->flags = enable ? FTRACE_ITER_FILTER :
                        FTRACE_ITER_NOTRACE;
@@ -1401,10 +1180,10 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
        }
        mutex_lock(&ftrace_sysctl_lock);
-        mutex_lock(&ftraced_lock);
+        mutex_lock(&ftrace_start_lock);
-        if (iter->filtered && ftraced_suspend && ftrace_enabled)
+        if (ftrace_start && ftrace_enabled)
                ftrace_run_update_code(FTRACE_ENABLE_CALLS);
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
        mutex_unlock(&ftrace_sysctl_lock);
        kfree(iter);
@@ -1424,55 +1203,6 @@ ftrace_notrace_release(struct inode *inode, struct file *file)
        return ftrace_regex_release(inode, file, 0);
 }
-static ssize_t
-ftraced_read(struct file *filp, char __user *ubuf,
-                     size_t cnt, loff_t *ppos)
-{
-        /* don't worry about races */
-        char *buf = ftraced_stop ? "disabled\n" : "enabled\n";
-        int r = strlen(buf);
-        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-}
-static ssize_t
-ftraced_write(struct file *filp, const char __user *ubuf,
-                      size_t cnt, loff_t *ppos)
-{
-        char buf[64];
-        long val;
-        int ret;
-        if (cnt >= sizeof(buf))
-                return -EINVAL;
-        if (copy_from_user(&buf, ubuf, cnt))
-                return -EFAULT;
-        if (strncmp(buf, "enable", 6) == 0)
-                val = 1;
-        else if (strncmp(buf, "disable", 7) == 0)
-                val = 0;
-        else {
-                buf[cnt] = 0;
-                ret = strict_strtoul(buf, 10, &val);
-                if (ret < 0)
-                        return ret;
-                val = !!val;
-        }
-        if (val)
-                ftrace_enable_daemon();
-        else
-                ftrace_disable_daemon();
-        filp->f_pos += cnt;
-        return cnt;
-}
 static struct file_operations ftrace_avail_fops = {
        .open = ftrace_avail_open,
        .read = seq_read,
@@ -1503,54 +1233,6 @@ static struct file_operations ftrace_notrace_fops = {
        .release = ftrace_notrace_release,
 };
-static struct file_operations ftraced_fops = {
-        .open = tracing_open_generic,
-        .read = ftraced_read,
-        .write = ftraced_write,
-};
-/**
- * ftrace_force_update - force an update to all recording ftrace functions
- */
-int ftrace_force_update(void)
-{
-        int ret = 0;
-        if (unlikely(ftrace_disabled))
-                return -ENODEV;
-        mutex_lock(&ftrace_sysctl_lock);
-        mutex_lock(&ftraced_lock);
-        /*
-         * If ftraced_trigger is not set, then there is nothing
-         * to update.
-         */
-        if (ftraced_trigger && !ftrace_update_code())
-                ret = -EBUSY;
-        mutex_unlock(&ftraced_lock);
-        mutex_unlock(&ftrace_sysctl_lock);
-        return ret;
-}
-static void ftrace_force_shutdown(void)
-{
-        struct task_struct *task;
-        int command = FTRACE_DISABLE_CALLS | FTRACE_UPDATE_TRACE_FUNC;
-        mutex_lock(&ftraced_lock);
-        task = ftraced_task;
-        ftraced_task = NULL;
-        ftraced_suspend = -1;
-        ftrace_run_update_code(command);
-        mutex_unlock(&ftraced_lock);
-        if (task)
-                kthread_stop(task);
-}
 static __init int ftrace_init_debugfs(void)
 {
        struct dentry *d_tracer;
@@ -1581,17 +1263,11 @@ static __init int ftrace_init_debugfs(void)
                pr_warning("Could not create debugfs "
                           "'set_ftrace_notrace' entry\n");
-        entry = debugfs_create_file("ftraced_enabled", 0644, d_tracer,
-                                    NULL, &ftraced_fops);
-        if (!entry)
-                pr_warning("Could not create debugfs "
-                           "'ftraced_enabled' entry\n");
        return 0;
 }
 fs_initcall(ftrace_init_debugfs);
-#ifdef CONFIG_FTRACE_MCOUNT_RECORD
 static int ftrace_convert_nops(unsigned long *start,
                               unsigned long *end)
 {
@@ -1599,20 +1275,18 @@ static int ftrace_convert_nops(unsigned long *start,
        unsigned long addr;
        unsigned long flags;
+        mutex_lock(&ftrace_start_lock);
        p = start;
        while (p < end) {
                addr = ftrace_call_adjust(*p++);
-                /* should not be called from interrupt context */
-                spin_lock(&ftrace_lock);
                ftrace_record_ip(addr);
-                spin_unlock(&ftrace_lock);
-                ftrace_shutdown_replenish();
        }
-        /* p is ignored */
+        /* disable interrupts to prevent kstop machine */
        local_irq_save(flags);
-        __ftrace_update_code(p);
+        ftrace_update_code();
        local_irq_restore(flags);
+        mutex_unlock(&ftrace_start_lock);
        return 0;
 }
@@ -1658,130 +1332,34 @@ void __init ftrace_init(void)
 failed:
        ftrace_disabled = 1;
 }
-#else /* CONFIG_FTRACE_MCOUNT_RECORD */
-static int ftraced(void *ignore)
-{
-        unsigned long usecs;
-        while (!kthread_should_stop()) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                /* check once a second */
-                schedule_timeout(HZ);
-                if (unlikely(ftrace_disabled))
+#else
-                        continue;
-                mutex_lock(&ftrace_sysctl_lock);
-                mutex_lock(&ftraced_lock);
-                if (!ftraced_suspend && !ftraced_stop &&
-                    ftrace_update_code()) {
-                        usecs = nsecs_to_usecs(ftrace_update_time);
-                        if (ftrace_update_tot_cnt > 100000) {
-                                ftrace_update_tot_cnt = 0;
-                                pr_info("hm, dftrace overflow: %lu change%s"
-                                        " (%lu total) in %lu usec%s\n",
-                                        ftrace_update_cnt,
-                                        ftrace_update_cnt != 1 ? "s" : "",
-                                        ftrace_update_tot_cnt,
-                                        usecs, usecs != 1 ? "s" : "");
-                                ftrace_disabled = 1;
-                                WARN_ON_ONCE(1);
-                        }
-                }
-                mutex_unlock(&ftraced_lock);
-                mutex_unlock(&ftrace_sysctl_lock);
-                ftrace_shutdown_replenish();
-        }
-        __set_current_state(TASK_RUNNING);
-        return 0;
-}
-static int __init ftrace_dynamic_init(void)
+static int __init ftrace_nodyn_init(void)
 {
-        struct task_struct *p;
+        ftrace_enabled = 1;
-        unsigned long addr;
-        int ret;
-        addr = (unsigned long)ftrace_record_ip;
-        stop_machine(ftrace_dyn_arch_init, &addr, NULL);
-        /* ftrace_dyn_arch_init places the return code in addr */
-        if (addr) {
-                ret = (int)addr;
-                goto failed;
-        }
-        ret = ftrace_dyn_table_alloc(NR_TO_INIT);
-        if (ret)
-                goto failed;
-        p = kthread_run(ftraced, NULL, "ftraced");
-        if (IS_ERR(p)) {
-                ret = -1;
-                goto failed;
-        }
-        last_ftrace_enabled = ftrace_enabled = 1;
-        ftraced_task = p;
        return 0;
- failed:
-        ftrace_disabled = 1;
-        return ret;
 }
+device_initcall(ftrace_nodyn_init);
-core_initcall(ftrace_dynamic_init);
-#endif /* CONFIG_FTRACE_MCOUNT_RECORD */
-#else
 # define ftrace_startup()               do { } while (0)
 # define ftrace_shutdown()              do { } while (0)
 # define ftrace_startup_sysctl()        do { } while (0)
 # define ftrace_shutdown_sysctl()       do { } while (0)
-# define ftrace_force_shutdown()        do { } while (0)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 /**
- * ftrace_kill_atomic - kill ftrace from critical sections
+ * ftrace_kill - kill ftrace
 *
 * This function should be used by panic code. It stops ftrace
 * but in a not so nice way. If you need to simply kill ftrace
 * from a non-atomic section, use ftrace_kill.
 */
-void ftrace_kill_atomic(void)
-{
-        ftrace_disabled = 1;
-        ftrace_enabled = 0;
-#ifdef CONFIG_DYNAMIC_FTRACE
-        ftraced_suspend = -1;
-#endif
-        clear_ftrace_function();
-}
-/**
- * ftrace_kill - totally shutdown ftrace
- *
- * This is a safety measure. If something was detected that seems
- * wrong, calling this function will keep ftrace from doing
- * any more modifications, and updates.
- * used when something went wrong.
- */
 void ftrace_kill(void)
 {
-        mutex_lock(&ftrace_sysctl_lock);
        ftrace_disabled = 1;
        ftrace_enabled = 0;
        clear_ftrace_function();
-        mutex_unlock(&ftrace_sysctl_lock);
-        /* Try to totally disable ftrace */
-        ftrace_force_shutdown();
 }
 /**
@@ -1870,3 +1448,4 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
        mutex_unlock(&ftrace_sysctl_lock);
        return ret;
 }
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 94af1fe56bb4..668bbb5ef2bd 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -16,14 +16,49 @@
 #include <linux/list.h>
 #include <linux/fs.h>
+#include "trace.h"
+/* Global flag to disable all recording to ring buffers */
+static int ring_buffers_off __read_mostly;
+/**
+ * tracing_on - enable all tracing buffers
+ *
+ * This function enables all tracing buffers that may have been
+ * disabled with tracing_off.
+ */
+void tracing_on(void)
+{
+        ring_buffers_off = 0;
+}
+/**
+ * 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)
+{
+        ring_buffers_off = 1;
+}
 /* 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)
@@ -130,7 +165,7 @@ struct buffer_page {
 static inline void free_buffer_page(struct buffer_page *bpage)
 {
        if (bpage->page)
-                __free_page(bpage->page);
+                free_page((unsigned long)bpage->page);
        kfree(bpage);
 }
@@ -503,6 +538,12 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
        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;
@@ -576,6 +617,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                list_del_init(&page->list);
                free_buffer_page(page);
        }
+        mutex_unlock(&buffer->mutex);
        return -ENOMEM;
 }
@@ -966,7 +1008,9 @@ rb_add_time_stamp(struct ring_buffer_per_cpu *cpu_buffer,
        if (unlikely(*delta > (1ULL << 59) && !once++)) {
                printk(KERN_WARNING "Delta way too big! %llu"
                       " ts=%llu write stamp = %llu\n",
-                       *delta, *ts, cpu_buffer->write_stamp);
+                       (unsigned long long)*delta,
+                       (unsigned long long)*ts,
+                       (unsigned long long)cpu_buffer->write_stamp);
                WARN_ON(1);
        }
@@ -1020,8 +1064,23 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
        struct ring_buffer_event *event;
        u64 ts, delta;
        int commit = 0;
+        int nr_loops = 0;
 again:
+        /*
+         * We allow for interrupts to reenter here and do a trace.
+         * If one does, it will cause this original code to loop
+         * back here. Even with heavy interrupts happening, this
+         * should only happen a few times in a row. If this happens
+         * 1000 times in a row, there must be either an interrupt
+         * storm or we have something buggy.
+         * Bail!
+         */
+        if (unlikely(++nr_loops > 1000)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
        ts = ring_buffer_time_stamp(cpu_buffer->cpu);
        /*
@@ -1043,7 +1102,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)) {
@@ -1116,6 +1175,9 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
        struct ring_buffer_event *event;
        int cpu, resched;
+        if (ring_buffers_off)
+                return NULL;
        if (atomic_read(&buffer->record_disabled))
                return NULL;
@@ -1153,7 +1215,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
 out:
        if (resched)
-                preempt_enable_notrace();
+                preempt_enable_no_resched_notrace();
        else
                preempt_enable_notrace();
        return NULL;
@@ -1232,6 +1294,9 @@ int ring_buffer_write(struct ring_buffer *buffer,
        int ret = -EBUSY;
        int cpu, resched;
+        if (ring_buffers_off)
+                return -EBUSY;
        if (atomic_read(&buffer->record_disabled))
                return -EBUSY;
@@ -1530,10 +1595,23 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
 {
        struct buffer_page *reader = NULL;
        unsigned long flags;
+        int nr_loops = 0;
        spin_lock_irqsave(&cpu_buffer->lock, flags);
 again:
+        /*
+         * This should normally only loop twice. But because the
+         * start of the reader inserts an empty page, it causes
+         * 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);
+                reader = NULL;
+                goto out;
+        }
        reader = cpu_buffer->reader_page;
        /* If there's more to read, return this page */
@@ -1663,6 +1741,7 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
        struct ring_buffer_per_cpu *cpu_buffer;
        struct ring_buffer_event *event;
        struct buffer_page *reader;
+        int nr_loops = 0;
        if (!cpu_isset(cpu, buffer->cpumask))
                return NULL;
@@ -1670,6 +1749,19 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
        cpu_buffer = buffer->buffers[cpu];
 again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have.  Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
        reader = rb_get_reader_page(cpu_buffer);
        if (!reader)
                return NULL;
@@ -1720,6 +1812,7 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
        struct ring_buffer *buffer;
        struct ring_buffer_per_cpu *cpu_buffer;
        struct ring_buffer_event *event;
+        int nr_loops = 0;
        if (ring_buffer_iter_empty(iter))
                return NULL;
@@ -1728,6 +1821,19 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
        buffer = cpu_buffer->buffer;
 again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have. Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
        if (rb_per_cpu_empty(cpu_buffer))
                return NULL;
@@ -2012,3 +2118,69 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
        return 0;
 }
+static ssize_t
+rb_simple_read(struct file *filp, char __user *ubuf,
+               size_t cnt, loff_t *ppos)
+{
+        int *p = filp->private_data;
+        char buf[64];
+        int r;
+        /* !ring_buffers_off == tracing_on */
+        r = sprintf(buf, "%d\n", !*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)
+{
+        int *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;
+        /* !ring_buffers_off == tracing_on */
+        *p = !val;
+        (*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_buffers_off, &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 d345d649d073..d86e3252f300 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -34,6 +34,7 @@
 #include <linux/stacktrace.h>
 #include <linux/ring_buffer.h>
+#include <linux/irqflags.h>
 #include "trace.h"
@@ -655,7 +656,11 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
        entry->preempt_count            = pc & 0xff;
        entry->pid                      = (tsk) ? tsk->pid : 0;
        entry->flags =
+#ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
                (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
+#else
+                TRACE_FLAG_IRQS_NOSUPPORT |
+#endif
                ((pc & HARDIRQ_MASK) ? TRACE_FLAG_HARDIRQ : 0) |
                ((pc & SOFTIRQ_MASK) ? TRACE_FLAG_SOFTIRQ : 0) |
                (need_resched() ? TRACE_FLAG_NEED_RESCHED : 0);
@@ -700,6 +705,7 @@ static void ftrace_trace_stack(struct trace_array *tr,
                               unsigned long flags,
                               int skip, int pc)
 {
+#ifdef CONFIG_STACKTRACE
        struct ring_buffer_event *event;
        struct stack_entry *entry;
        struct stack_trace trace;
@@ -725,6 +731,7 @@ static void ftrace_trace_stack(struct trace_array *tr,
        save_stack_trace(&trace);
        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+#endif
 }
 void __trace_stack(struct trace_array *tr,
@@ -851,7 +858,7 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
        preempt_enable_notrace();
 }
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 static void
 function_trace_call(unsigned long ip, unsigned long parent_ip)
 {
@@ -865,9 +872,6 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
        if (unlikely(!ftrace_function_enabled))
                return;
-        if (skip_trace(ip))
-                return;
        pc = preempt_count();
        resched = need_resched();
        preempt_disable_notrace();
@@ -1084,17 +1088,20 @@ static void s_stop(struct seq_file *m, void *p)
        mutex_unlock(&trace_types_lock);
 }
-#define KRETPROBE_MSG "[unknown/kretprobe'd]"
 #ifdef CONFIG_KRETPROBES
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return addr == (unsigned long)kretprobe_trampoline;
+        static const char tramp_name[] = "kretprobe_trampoline";
+        int size = sizeof(tramp_name);
+        if (strncmp(tramp_name, name, size) == 0)
+                return "[unknown/kretprobe'd]";
+        return name;
 }
 #else
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return 0;
+        return name;
 }
 #endif /* CONFIG_KRETPROBES */
@@ -1103,10 +1110,13 @@ seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
 #ifdef CONFIG_KALLSYMS
        char str[KSYM_SYMBOL_LEN];
+        const char *name;
        kallsyms_lookup(address, NULL, NULL, NULL, str);
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+        return trace_seq_printf(s, fmt, name);
 #endif
        return 1;
 }
@@ -1117,9 +1127,12 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 {
 #ifdef CONFIG_KALLSYMS
        char str[KSYM_SYMBOL_LEN];
+        const char *name;
        sprint_symbol(str, address);
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+        return trace_seq_printf(s, fmt, name);
 #endif
        return 1;
 }
@@ -1246,7 +1259,8 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
        trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid);
        trace_seq_printf(s, "%3d", cpu);
        trace_seq_printf(s, "%c%c",
-                        (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : '.',
+                        (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+                         (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : '.',
                        ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.'));
        hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
@@ -1372,10 +1386,7 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
                seq_print_ip_sym(s, field->ip, sym_flags);
                trace_seq_puts(s, " (");
-                if (kretprobed(field->parent_ip))
+                seq_print_ip_sym(s, field->parent_ip, sym_flags);
-                        trace_seq_puts(s, KRETPROBE_MSG);
-                else
-                        seq_print_ip_sym(s, field->parent_ip, sym_flags);
                trace_seq_puts(s, ")\n");
                break;
        }
@@ -1491,12 +1502,9 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
                        ret = trace_seq_printf(s, " <-");
                        if (!ret)
                                return TRACE_TYPE_PARTIAL_LINE;
-                        if (kretprobed(field->parent_ip))
+                        ret = seq_print_ip_sym(s,
-                                ret = trace_seq_puts(s, KRETPROBE_MSG);
+                                               field->parent_ip,
-                        else
+                                               sym_flags);
-                                ret = seq_print_ip_sym(s,
-                                                       field->parent_ip,
-                                                       sym_flags);
                        if (!ret)
                                return TRACE_TYPE_PARTIAL_LINE;
                }
@@ -1747,7 +1755,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) {
@@ -1928,6 +1936,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);
 }
@@ -2379,9 +2388,10 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
        int i;
        size_t ret;
+        ret = cnt;
        if (cnt > max_tracer_type_len)
                cnt = max_tracer_type_len;
-        ret = cnt;
        if (copy_from_user(&buf, ubuf, cnt))
                return -EFAULT;
@@ -2414,8 +2424,8 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
 out:
        mutex_unlock(&trace_types_lock);
-        if (ret == cnt)
+        if (ret > 0)
-                filp->f_pos += cnt;
+                filp->f_pos += ret;
        return ret;
 }
@@ -2667,7 +2677,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 {
        unsigned long val;
        char buf[64];
-        int ret;
+        int ret, cpu;
        struct trace_array *tr = filp->private_data;
        if (cnt >= sizeof(buf))
@@ -2695,6 +2705,14 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                goto out;
        }
+        /* 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);
+        }
        if (val != global_trace.entries) {
                ret = ring_buffer_resize(global_trace.buffer, val);
                if (ret < 0) {
@@ -2726,6 +2744,13 @@ 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);
+        }
        max_tr.entries = global_trace.entries;
        mutex_unlock(&trace_types_lock);
@@ -3097,7 +3122,7 @@ void ftrace_dump(void)
        dump_ran = 1;
        /* No turning back! */
-        ftrace_kill_atomic();
+        ftrace_kill();
        for_each_tracing_cpu(cpu) {
                atomic_inc(&global_trace.data[cpu]->disabled);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index f1f99572cde7..8465ad052707 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -120,18 +120,20 @@ struct trace_boot {
 /*
 * trace_flag_type is an enumeration that holds different
 * states when a trace occurs. These are:
- *  IRQS_OFF    - interrupts were disabled
+ *  IRQS_OFF            - interrupts were disabled
- *  NEED_RESCED - reschedule is requested
+ *  IRQS_NOSUPPORT      - arch does not support irqs_disabled_flags
- *  HARDIRQ     - inside an interrupt handler
+ *  NEED_RESCED         - reschedule is requested
- *  SOFTIRQ     - inside a softirq handler
+ *  HARDIRQ             - inside an interrupt handler
- *  CONT        - multiple entries hold the trace item
+ *  SOFTIRQ             - inside a softirq handler
+ *  CONT                - multiple entries hold the trace item
 */
 enum trace_flag_type {
        TRACE_FLAG_IRQS_OFF             = 0x01,
-        TRACE_FLAG_NEED_RESCHED         = 0x02,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
-        TRACE_FLAG_HARDIRQ              = 0x04,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
-        TRACE_FLAG_SOFTIRQ              = 0x08,
+        TRACE_FLAG_HARDIRQ              = 0x08,
-        TRACE_FLAG_CONT                 = 0x10,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+        TRACE_FLAG_CONT                 = 0x20,
 };
 #define TRACE_BUF_SIZE          1024
@@ -335,7 +337,7 @@ void update_max_tr_single(struct trace_array *tr,
 extern cycle_t ftrace_now(int cpu);
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 void tracing_start_function_trace(void);
 void tracing_stop_function_trace(void);
 #else
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index e90eb0c2c56c..0f85a64003d3 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -64,7 +64,7 @@ static void function_trace_ctrl_update(struct trace_array *tr)
 static struct tracer function_trace __read_mostly =
 {
-        .name        = "ftrace",
+        .name        = "function",
        .init        = function_trace_init,
        .reset       = function_trace_reset,
        .ctrl_update = function_trace_ctrl_update,
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index a7db7f040ae0..9c74071c10e0 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -63,7 +63,7 @@ irq_trace(void)
 */
 static __cacheline_aligned_in_smp       unsigned long max_sequence;
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 /*
 * irqsoff uses its own tracer function to keep the overhead down:
 */
@@ -104,7 +104,7 @@ static struct ftrace_ops trace_ops __read_mostly =
 {
        .func = irqsoff_tracer_call,
 };
-#endif /* CONFIG_FTRACE */
+#endif /* CONFIG_FUNCTION_TRACER */
 /*
 * Should this new latency be reported/recorded?
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index f28484618ff0..e62cbf78eab6 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -18,12 +18,14 @@ 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)
@@ -128,16 +130,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: */
+        unsigned long over = ring_buffer_overruns(iter->tr->buffer);
-#if 0
-        for_each_online_cpu(cpu) {
+        if (over > prev_overruns)
-                cnt += iter->overrun[cpu];
+                cnt = over - prev_overruns;
-                iter->overrun[cpu] = 0;
+        prev_overruns = over;
-        }
-#endif
-        (void)cpu;
        return cnt;
 }
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index fe4a252c2363..3ae93f16b565 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -31,7 +31,7 @@ static raw_spinlock_t wakeup_lock =
 static void __wakeup_reset(struct trace_array *tr);
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 /*
 * irqsoff uses its own tracer function to keep the overhead down:
 */
@@ -96,7 +96,7 @@ static struct ftrace_ops trace_ops __read_mostly =
 {
        .func = wakeup_tracer_call,
 };
-#endif /* CONFIG_FTRACE */
+#endif /* CONFIG_FUNCTION_TRACER */
 /*
 * Should this new latency be reported/recorded?
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 09cf230d7eca..90bc752a7580 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -70,7 +70,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
        return ret;
 }
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -99,13 +99,6 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
        /* passed in by parameter to fool gcc from optimizing */
        func();
-        /* update the records */
-        ret = ftrace_force_update();
-        if (ret) {
-                printk(KERN_CONT ".. ftraced failed .. ");
-                return ret;
-        }
        /*
         * Some archs *cough*PowerPC*cough* add charachters to the
         * start of the function names. We simply put a '*' to
@@ -183,13 +176,6 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
        /* make sure msleep has been recorded */
        msleep(1);
-        /* force the recorded functions to be traced */
-        ret = ftrace_force_update();
-        if (ret) {
-                printk(KERN_CONT ".. ftraced failed .. ");
-                return ret;
-        }
        /* start the tracing */
        ftrace_enabled = 1;
        tracer_enabled = 1;
@@ -226,7 +212,7 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
        return ret;
 }
-#endif /* CONFIG_FTRACE */
+#endif /* CONFIG_FUNCTION_TRACER */
 #ifdef CONFIG_IRQSOFF_TRACER
 int
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 74c5d9a3afae..3bdb44bde4b7 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -44,6 +44,10 @@ static inline void check_stack(void)
        if (this_size <= max_stack_size)
                return;
+        /* we do not handle interrupt stacks yet */
+        if (!object_is_on_stack(&this_size))
+                return;
        raw_local_irq_save(flags);
        __raw_spin_lock(&max_stack_lock);
@@ -180,11 +184,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)
@@ -197,12 +206,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))
                ;
@@ -231,10 +243,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",
@@ -242,6 +254,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;
@@ -271,10 +285,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/tracepoint.c b/kernel/tracepoint.c
index f2b7c28a4708..af8c85664882 100644
--- a/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@ -131,6 +131,9 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
        old = entry->funcs;
+        if (!old)
+                return NULL;
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
        for (nr_probes = 0; old[nr_probes]; nr_probes++) {
@@ -388,6 +391,11 @@ int tracepoint_probe_unregister(const char *name, void *probe)
        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;
+        }
        mutex_unlock(&tracepoints_mutex);
        tracepoint_update_probes();             /* may update entry */
        mutex_lock(&tracepoints_mutex);
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index f928f2a87b9b..d4dc69ddebd7 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -970,6 +970,51 @@ undo:
        return ret;
 }
+#ifdef CONFIG_SMP
+struct work_for_cpu {
+        struct work_struct work;
+        long (*fn)(void *);
+        void *arg;
+        long ret;
+};
+static void do_work_for_cpu(struct work_struct *w)
+{
+        struct work_for_cpu *wfc = container_of(w, struct work_for_cpu, work);
+        wfc->ret = wfc->fn(wfc->arg);
+}
+/**
+ * work_on_cpu - run a function in user context on a particular cpu
+ * @cpu: the cpu to run on
+ * @fn: the function to run
+ * @arg: the function arg
+ *
+ * This will return -EINVAL in the cpu is not online, or the return value
+ * of @fn otherwise.
+ */
+long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
+{
+        struct work_for_cpu wfc;
+        INIT_WORK(&wfc.work, do_work_for_cpu);
+        wfc.fn = fn;
+        wfc.arg = arg;
+        get_online_cpus();
+        if (unlikely(!cpu_online(cpu)))
+                wfc.ret = -EINVAL;
+        else {
+                schedule_work_on(cpu, &wfc.work);
+                flush_work(&wfc.work);
+        }
+        put_online_cpus();
+        return wfc.ret;
+}
+EXPORT_SYMBOL_GPL(work_on_cpu);
+#endif /* CONFIG_SMP */
 void __init init_workqueues(void)
 {
        cpu_populated_map = cpu_online_map;