71 files changed, 2936 insertions, 1202 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 170a9213c1b6..e4791b3ba55d 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -51,6 +51,7 @@ obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_KALLSYMS) += kallsyms.o
 obj-$(CONFIG_PM) += power/
+obj-$(CONFIG_FREEZER) += power/
 obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
 obj-$(CONFIG_KEXEC) += kexec.o
 obj-$(CONFIG_BACKTRACE_SELF_TEST) += backtracetest.o
diff --git a/kernel/async.c b/kernel/async.c
index 608b32b42812..f565891f2c9b 100644
--- a/kernel/async.c
+++ b/kernel/async.c
@@ -54,6 +54,7 @@ asynchronous and synchronous parts of the kernel.
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kthread.h>
+#include <linux/delay.h>
 #include <asm/atomic.h>
 
 static async_cookie_t next_cookie = 1;
@@ -132,21 +133,23 @@ static void run_one_entry(void)
         entry = list_first_entry(&async_pending, struct async_entry, list);
 
         /* 2) move it to the running queue */
-        list_del(&entry->list);
-        list_add_tail(&entry->list, &async_running);
+        list_move_tail(&entry->list, entry->running);
         spin_unlock_irqrestore(&async_lock, flags);
 
         /* 3) run it (and print duration)*/
         if (initcall_debug && system_state == SYSTEM_BOOTING) {
-                printk("calling  %lli_%pF @ %i\n", entry->cookie, entry->func, task_pid_nr(current));
+                printk("calling  %lli_%pF @ %i\n", (long long)entry->cookie,
+                        entry->func, task_pid_nr(current));
                 calltime = ktime_get();
         }
         entry->func(entry->data, entry->cookie);
         if (initcall_debug && system_state == SYSTEM_BOOTING) {
                 rettime = ktime_get();
                 delta = ktime_sub(rettime, calltime);
-                printk("initcall %lli_%pF returned 0 after %lld usecs\n", entry->cookie,
-                        entry->func, ktime_to_ns(delta) >> 10);
+                printk("initcall %lli_%pF returned 0 after %lld usecs\n",
+                        (long long)entry->cookie,
+                        entry->func,
+                        (long long)ktime_to_ns(delta) >> 10);
         }
 
         /* 4) remove it from the running queue */
@@ -205,18 +208,44 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct l
         return newcookie;
 }
 
+/**
+ * async_schedule - schedule a function for asynchronous execution
+ * @ptr: function to execute asynchronously
+ * @data: data pointer to pass to the function
+ *
+ * Returns an async_cookie_t that may be used for checkpointing later.
+ * Note: This function may be called from atomic or non-atomic contexts.
+ */
 async_cookie_t async_schedule(async_func_ptr *ptr, void *data)
 {
-        return __async_schedule(ptr, data, &async_pending);
+        return __async_schedule(ptr, data, &async_running);
 }
 EXPORT_SYMBOL_GPL(async_schedule);
 
-async_cookie_t async_schedule_special(async_func_ptr *ptr, void *data, struct list_head *running)
+/**
+ * async_schedule_domain - schedule a function for asynchronous execution within a certain domain
+ * @ptr: function to execute asynchronously
+ * @data: data pointer to pass to the function
+ * @running: running list for the domain
+ *
+ * Returns an async_cookie_t that may be used for checkpointing later.
+ * @running may be used in the async_synchronize_*_domain() functions
+ * to wait within a certain synchronization domain rather than globally.
+ * A synchronization domain is specified via the running queue @running to use.
+ * Note: This function may be called from atomic or non-atomic contexts.
+ */
+async_cookie_t async_schedule_domain(async_func_ptr *ptr, void *data,
+                                     struct list_head *running)
 {
         return __async_schedule(ptr, data, running);
 }
-EXPORT_SYMBOL_GPL(async_schedule_special);
+EXPORT_SYMBOL_GPL(async_schedule_domain);
 
+/**
+ * async_synchronize_full - synchronize all asynchronous function calls
+ *
+ * This function waits until all asynchronous function calls have been done.
+ */
 void async_synchronize_full(void)
 {
         do {
@@ -225,13 +254,30 @@ void async_synchronize_full(void)
 }
 EXPORT_SYMBOL_GPL(async_synchronize_full);
 
-void async_synchronize_full_special(struct list_head *list)
+/**
+ * async_synchronize_full_domain - synchronize all asynchronous function within a certain domain
+ * @list: running list to synchronize on
+ *
+ * This function waits until all asynchronous function calls for the
+ * synchronization domain specified by the running list @list have been done.
+ */
+void async_synchronize_full_domain(struct list_head *list)
 {
-        async_synchronize_cookie_special(next_cookie, list);
+        async_synchronize_cookie_domain(next_cookie, list);
 }
-EXPORT_SYMBOL_GPL(async_synchronize_full_special);
+EXPORT_SYMBOL_GPL(async_synchronize_full_domain);
 
-void async_synchronize_cookie_special(async_cookie_t cookie, struct list_head *running)
+/**
+ * async_synchronize_cookie_domain - synchronize asynchronous function calls within a certain domain with cookie checkpointing
+ * @cookie: async_cookie_t to use as checkpoint
+ * @running: running list to synchronize on
+ *
+ * This function waits until all asynchronous function calls for the
+ * synchronization domain specified by the running list @list submitted
+ * prior to @cookie have been done.
+ */
+void async_synchronize_cookie_domain(async_cookie_t cookie,
+                                     struct list_head *running)
 {
         ktime_t starttime, delta, endtime;
 
@@ -247,14 +293,22 @@ void async_synchronize_cookie_special(async_cookie_t cookie, struct list_head *r
                 delta = ktime_sub(endtime, starttime);
 
                 printk("async_continuing @ %i after %lli usec\n",
-                        task_pid_nr(current), ktime_to_ns(delta) >> 10);
+                        task_pid_nr(current),
+                        (long long)ktime_to_ns(delta) >> 10);
         }
 }
-EXPORT_SYMBOL_GPL(async_synchronize_cookie_special);
+EXPORT_SYMBOL_GPL(async_synchronize_cookie_domain);
 
+/**
+ * async_synchronize_cookie - synchronize asynchronous function calls with cookie checkpointing
+ * @cookie: async_cookie_t to use as checkpoint
+ *
+ * This function waits until all asynchronous function calls prior to @cookie
+ * have been done.
+ */
 void async_synchronize_cookie(async_cookie_t cookie)
 {
-        async_synchronize_cookie_special(cookie, &async_running);
+        async_synchronize_cookie_domain(cookie, &async_running);
 }
 EXPORT_SYMBOL_GPL(async_synchronize_cookie);
 
@@ -315,7 +369,11 @@ static int async_manager_thread(void *unused)
                 ec = atomic_read(&entry_count);
 
                 while (tc < ec && tc < MAX_THREADS) {
-                        kthread_run(async_thread, NULL, "async/%i", tc);
+                        if (IS_ERR(kthread_run(async_thread, NULL, "async/%i",
+                                               tc))) {
+                                msleep(100);
+                                continue;
+                        }
                         atomic_inc(&thread_count);
                         tc++;
                 }
@@ -330,7 +388,9 @@ static int async_manager_thread(void *unused)
 static int __init async_init(void)
 {
         if (async_enabled)
-                kthread_run(async_manager_thread, NULL, "async/mgr");
+                if (IS_ERR(kthread_run(async_manager_thread, NULL,
+                                       "async/mgr")))
+                        async_enabled = 0;
         return 0;
 }
 
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index c29831076e7a..9edb5c4b79b4 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1115,13 +1115,15 @@ static void cgroup_kill_sb(struct super_block *sb) {
         }
         write_unlock(&css_set_lock);
 
-        list_del(&root->root_list);
-        root_count--;
+        if (!list_empty(&root->root_list)) {
+                list_del(&root->root_list);
+                root_count--;
+        }
 
         mutex_unlock(&cgroup_mutex);
 
-        kfree(root);
         kill_litter_super(sb);
+        kfree(root);
 }
 
 static struct file_system_type cgroup_fs_type = {
@@ -2349,7 +2351,7 @@ static void cgroup_lock_hierarchy(struct cgroupfs_root *root)
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
                 struct cgroup_subsys *ss = subsys[i];
                 if (ss->root == root)
-                        mutex_lock_nested(&ss->hierarchy_mutex, i);
+                        mutex_lock(&ss->hierarchy_mutex);
         }
 }
 
@@ -2434,7 +2436,9 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
 
  err_remove:
 
+        cgroup_lock_hierarchy(root);
         list_del(&cgrp->sibling);
+        cgroup_unlock_hierarchy(root);
         root->number_of_cgroups--;
 
  err_destroy:
@@ -2507,7 +2511,7 @@ static int cgroup_clear_css_refs(struct cgroup *cgrp)
         for_each_subsys(cgrp->root, ss) {
                 struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
                 int refcnt;
-                do {
+                while (1) {
                         /* We can only remove a CSS with a refcnt==1 */
                         refcnt = atomic_read(&css->refcnt);
                         if (refcnt > 1) {
@@ -2521,7 +2525,10 @@ static int cgroup_clear_css_refs(struct cgroup *cgrp)
                          * css_tryget() to spin until we set the
                          * CSS_REMOVED bits or abort
                          */
-                } while (atomic_cmpxchg(&css->refcnt, refcnt, 0) != refcnt);
+                        if (atomic_cmpxchg(&css->refcnt, refcnt, 0) == refcnt)
+                                break;
+                        cpu_relax();
+                }
         }
  done:
         for_each_subsys(cgrp->root, ss) {
@@ -2630,6 +2637,7 @@ static void __init cgroup_init_subsys(struct cgroup_subsys *ss)
         BUG_ON(!list_empty(&init_task.tasks));
 
         mutex_init(&ss->hierarchy_mutex);
+        lockdep_set_class(&ss->hierarchy_mutex, &ss->subsys_key);
         ss->active = 1;
 }
 
@@ -2991,20 +2999,21 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
                 mutex_unlock(&cgroup_mutex);
                 return 0;
         }
-        task_lock(tsk);
-        cg = tsk->cgroups;
-        parent = task_cgroup(tsk, subsys->subsys_id);
 
         /* Pin the hierarchy */
-        if (!atomic_inc_not_zero(&parent->root->sb->s_active)) {
+        if (!atomic_inc_not_zero(&root->sb->s_active)) {
                 /* We race with the final deactivate_super() */
                 mutex_unlock(&cgroup_mutex);
                 return 0;
         }
 
         /* Keep the cgroup alive */
+        task_lock(tsk);
+        parent = task_cgroup(tsk, subsys->subsys_id);
+        cg = tsk->cgroups;
         get_css_set(cg);
         task_unlock(tsk);
+
         mutex_unlock(&cgroup_mutex);
 
         /* Now do the VFS work to create a cgroup */
@@ -3043,7 +3052,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
                 mutex_unlock(&inode->i_mutex);
                 put_css_set(cg);
 
-                deactivate_super(parent->root->sb);
+                deactivate_super(root->sb);
                 /* The cgroup is still accessible in the VFS, but
                  * we're not going to try to rmdir() it at this
                  * point. */
@@ -3069,7 +3078,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
         mutex_lock(&cgroup_mutex);
         put_css_set(cg);
         mutex_unlock(&cgroup_mutex);
-        deactivate_super(parent->root->sb);
+        deactivate_super(root->sb);
         return ret;
 }
 
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index a85678865c5e..f76db9dcaa05 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -61,6 +61,14 @@
 #include <linux/cgroup.h>
 
 /*
+ * Workqueue for cpuset related tasks.
+ *
+ * Using kevent workqueue may cause deadlock when memory_migrate
+ * is set. So we create a separate workqueue thread for cpuset.
+ */
+static struct workqueue_struct *cpuset_wq;
+
+/*
  * Tracks how many cpusets are currently defined in system.
  * When there is only one cpuset (the root cpuset) we can
  * short circuit some hooks.
@@ -831,7 +839,7 @@ static DECLARE_WORK(rebuild_sched_domains_work, do_rebuild_sched_domains);
  */
 static void async_rebuild_sched_domains(void)
 {
-        schedule_work(&rebuild_sched_domains_work);
+        queue_work(cpuset_wq, &rebuild_sched_domains_work);
 }
 
 /*
@@ -2111,6 +2119,9 @@ void __init cpuset_init_smp(void)
 
         hotcpu_notifier(cpuset_track_online_cpus, 0);
         hotplug_memory_notifier(cpuset_track_online_nodes, 10);
+
+        cpuset_wq = create_singlethread_workqueue("cpuset");
+        BUG_ON(!cpuset_wq);
 }
 
 /**
diff --git a/kernel/dma-coherent.c b/kernel/dma-coherent.c
index 038707404b76..962a3b574f21 100644
--- a/kernel/dma-coherent.c
+++ b/kernel/dma-coherent.c
@@ -98,7 +98,7 @@ EXPORT_SYMBOL(dma_mark_declared_memory_occupied);
  * @size:       size of requested memory area
  * @dma_handle: This will be filled with the correct dma handle
  * @ret:        This pointer will be filled with the virtual address
- *              to allocated area.
+ *              to allocated area.
  *
  * This function should be only called from per-arch dma_alloc_coherent()
  * to support allocation from per-device coherent memory pools.
@@ -118,31 +118,32 @@ int dma_alloc_from_coherent(struct device *dev, ssize_t size,
         mem = dev->dma_mem;
         if (!mem)
                 return 0;
-        if (unlikely(size > mem->size))
-                return 0;
+
+        *ret = NULL;
+
+        if (unlikely(size > (mem->size << PAGE_SHIFT)))
+                goto err;
 
         pageno = bitmap_find_free_region(mem->bitmap, mem->size, order);
-        if (pageno >= 0) {
-                /*
-                 * Memory was found in the per-device arena.
-                 */
-                *dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
-                *ret = mem->virt_base + (pageno << PAGE_SHIFT);
-                memset(*ret, 0, size);
-        } else if (mem->flags & DMA_MEMORY_EXCLUSIVE) {
-                /*
-                 * The per-device arena is exhausted and we are not
-                 * permitted to fall back to generic memory.
-                 */
-                *ret = NULL;
-        } else {
-                /*
-                 * The per-device arena is exhausted and we are
-                 * permitted to fall back to generic memory.
-                 */
-                 return 0;
-        }
+        if (unlikely(pageno < 0))
+                goto err;
+
+        /*
+         * Memory was found in the per-device area.
+         */
+        *dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
+        *ret = mem->virt_base + (pageno << PAGE_SHIFT);
+        memset(*ret, 0, size);
+
         return 1;
+
+err:
+        /*
+         * In the case where the allocation can not be satisfied from the
+         * per-device area, try to fall back to generic memory if the
+         * constraints allow it.
+         */
+        return mem->flags & DMA_MEMORY_EXCLUSIVE;
 }
 EXPORT_SYMBOL(dma_alloc_from_coherent);
 
diff --git a/kernel/exit.c b/kernel/exit.c
index f80dec3f1875..efd30ccf3858 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -118,6 +118,8 @@ static void __exit_signal(struct task_struct *tsk)
                  * We won't ever get here for the group leader, since it
                  * will have been the last reference on the signal_struct.
                  */
+                sig->utime = cputime_add(sig->utime, task_utime(tsk));
+                sig->stime = cputime_add(sig->stime, task_stime(tsk));
                 sig->gtime = cputime_add(sig->gtime, task_gtime(tsk));
                 sig->min_flt += tsk->min_flt;
                 sig->maj_flt += tsk->maj_flt;
@@ -126,6 +128,7 @@ static void __exit_signal(struct task_struct *tsk)
                 sig->inblock += task_io_get_inblock(tsk);
                 sig->oublock += task_io_get_oublock(tsk);
                 task_io_accounting_add(&sig->ioac, &tsk->ioac);
+                sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
                 sig = NULL; /* Marker for below. */
         }
 
diff --git a/kernel/fork.c b/kernel/fork.c
index bf0cef8bbdf2..4854c2c4a82e 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -817,17 +817,17 @@ static void posix_cpu_timers_init_group(struct signal_struct *sig)
 static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
 {
         struct signal_struct *sig;
-        int ret;
 
         if (clone_flags & CLONE_THREAD) {
-                ret = thread_group_cputime_clone_thread(current);
-                if (likely(!ret)) {
-                        atomic_inc(&current->signal->count);
-                        atomic_inc(&current->signal->live);
-                }
-                return ret;
+                atomic_inc(&current->signal->count);
+                atomic_inc(&current->signal->live);
+                return 0;
         }
         sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
+
+        if (sig)
+                posix_cpu_timers_init_group(sig);
+
         tsk->signal = sig;
         if (!sig)
                 return -ENOMEM;
@@ -851,21 +851,20 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
         sig->tty_old_pgrp = NULL;
         sig->tty = NULL;
 
-        sig->cutime = sig->cstime = cputime_zero;
+        sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
         sig->gtime = cputime_zero;
         sig->cgtime = cputime_zero;
         sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
         sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
         sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;
         task_io_accounting_init(&sig->ioac);
+        sig->sum_sched_runtime = 0;
         taskstats_tgid_init(sig);
 
         task_lock(current->group_leader);
         memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
         task_unlock(current->group_leader);
 
-        posix_cpu_timers_init_group(sig);
-
         acct_init_pacct(&sig->pacct);
 
         tty_audit_fork(sig);
@@ -1007,6 +1006,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
          * triggers too late. This doesn't hurt, the check is only there
          * to stop root fork bombs.
          */
+        retval = -EAGAIN;
         if (nr_threads >= max_threads)
                 goto bad_fork_cleanup_count;
 
@@ -1095,7 +1095,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
 #ifdef CONFIG_DEBUG_MUTEXES
         p->blocked_on = NULL; /* not blocked yet */
 #endif
-        if (unlikely(ptrace_reparented(current)))
+        if (unlikely(current->ptrace))
                 ptrace_fork(p, clone_flags);
 
         /* Perform scheduler related setup. Assign this task to a CPU. */
@@ -1179,10 +1179,6 @@ static struct task_struct *copy_process(unsigned long clone_flags,
 #endif
         clear_all_latency_tracing(p);
 
-        /* Our parent execution domain becomes current domain
-           These must match for thread signalling to apply */
-        p->parent_exec_id = p->self_exec_id;
-
         /* ok, now we should be set up.. */
         p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
         p->pdeath_signal = 0;
@@ -1220,10 +1216,13 @@ static struct task_struct *copy_process(unsigned long clone_flags,
                 set_task_cpu(p, smp_processor_id());
 
         /* CLONE_PARENT re-uses the old parent */
-        if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
+        if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
                 p->real_parent = current->real_parent;
-        else
+                p->parent_exec_id = current->parent_exec_id;
+        } else {
                 p->real_parent = current;
+                p->parent_exec_id = current->self_exec_id;
+        }
 
         spin_lock(&current->sighand->siglock);
 
diff --git a/kernel/futex.c b/kernel/futex.c
index f89d373a9c6d..438701adce23 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -1165,6 +1165,7 @@ static int futex_wait(u32 __user *uaddr, int fshared,
                       u32 val, ktime_t *abs_time, u32 bitset, int clockrt)
 {
         struct task_struct *curr = current;
+        struct restart_block *restart;
         DECLARE_WAITQUEUE(wait, curr);
         struct futex_hash_bucket *hb;
         struct futex_q q;
@@ -1216,11 +1217,13 @@ retry:
 
                 if (!ret)
                         goto retry;
-                return ret;
+                goto out;
         }
         ret = -EWOULDBLOCK;
-        if (uval != val)
-                goto out_unlock_put_key;
+        if (unlikely(uval != val)) {
+                queue_unlock(&q, hb);
+                goto out_put_key;
+        }
 
         /* Only actually queue if *uaddr contained val.  */
         queue_me(&q, hb);
@@ -1284,38 +1287,38 @@ retry:
          */
 
         /* If we were woken (and unqueued), we succeeded, whatever. */
+        ret = 0;
         if (!unqueue_me(&q))
-                return 0;
+                goto out_put_key;
+        ret = -ETIMEDOUT;
         if (rem)
-                return -ETIMEDOUT;
+                goto out_put_key;
 
         /*
          * We expect signal_pending(current), but another thread may
          * have handled it for us already.
          */
+        ret = -ERESTARTSYS;
         if (!abs_time)
-                return -ERESTARTSYS;
-        else {
-                struct restart_block *restart;
-                restart = &current_thread_info()->restart_block;
-                restart->fn = futex_wait_restart;
-                restart->futex.uaddr = (u32 *)uaddr;
-                restart->futex.val = val;
-                restart->futex.time = abs_time->tv64;
-                restart->futex.bitset = bitset;
-                restart->futex.flags = 0;
-
-                if (fshared)
-                        restart->futex.flags |= FLAGS_SHARED;
-                if (clockrt)
-                        restart->futex.flags |= FLAGS_CLOCKRT;
-                return -ERESTART_RESTARTBLOCK;
-        }
+                goto out_put_key;
 
-out_unlock_put_key:
-        queue_unlock(&q, hb);
-        put_futex_key(fshared, &q.key);
+        restart = &current_thread_info()->restart_block;
+        restart->fn = futex_wait_restart;
+        restart->futex.uaddr = (u32 *)uaddr;
+        restart->futex.val = val;
+        restart->futex.time = abs_time->tv64;
+        restart->futex.bitset = bitset;
+        restart->futex.flags = 0;
+
+        if (fshared)
+                restart->futex.flags |= FLAGS_SHARED;
+        if (clockrt)
+                restart->futex.flags |= FLAGS_CLOCKRT;
 
+        ret = -ERESTART_RESTARTBLOCK;
+
+out_put_key:
+        put_futex_key(fshared, &q.key);
 out:
         return ret;
 }
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 2dc30c59c5fd..f394d2a42ca3 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -501,6 +501,13 @@ static void hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base)
                         continue;
                 timer = rb_entry(base->first, struct hrtimer, node);
                 expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
+                /*
+                 * clock_was_set() has changed base->offset so the
+                 * result might be negative. Fix it up to prevent a
+                 * false positive in clockevents_program_event()
+                 */
+                if (expires.tv64 < 0)
+                        expires.tv64 = 0;
                 if (expires.tv64 < cpu_base->expires_next.tv64)
                         cpu_base->expires_next = expires;
         }
@@ -614,7 +621,9 @@ void clock_was_set(void)
  */
 void hres_timers_resume(void)
 {
-        /* Retrigger the CPU local events: */
+        WARN_ONCE(!irqs_disabled(),
+                  KERN_INFO "hres_timers_resume() called with IRQs enabled!");
+
         retrigger_next_event(NULL);
 }
 
@@ -1156,6 +1165,29 @@ static void __run_hrtimer(struct hrtimer *timer)
 
 #ifdef CONFIG_HIGH_RES_TIMERS
 
+static int force_clock_reprogram;
+
+/*
+ * After 5 iteration's attempts, we consider that hrtimer_interrupt()
+ * is hanging, which could happen with something that slows the interrupt
+ * such as the tracing. Then we force the clock reprogramming for each future
+ * hrtimer interrupts to avoid infinite loops and use the min_delta_ns
+ * threshold that we will overwrite.
+ * The next tick event will be scheduled to 3 times we currently spend on
+ * hrtimer_interrupt(). This gives a good compromise, the cpus will spend
+ * 1/4 of their time to process the hrtimer interrupts. This is enough to
+ * let it running without serious starvation.
+ */
+
+static inline void
+hrtimer_interrupt_hanging(struct clock_event_device *dev,
+                        ktime_t try_time)
+{
+        force_clock_reprogram = 1;
+        dev->min_delta_ns = (unsigned long)try_time.tv64 * 3;
+        printk(KERN_WARNING "hrtimer: interrupt too slow, "
+                "forcing clock min delta to %lu ns\n", dev->min_delta_ns);
+}
 /*
  * High resolution timer interrupt
  * Called with interrupts disabled
@@ -1165,6 +1197,7 @@ void hrtimer_interrupt(struct clock_event_device *dev)
         struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
         struct hrtimer_clock_base *base;
         ktime_t expires_next, now;
+        int nr_retries = 0;
         int i;
 
         BUG_ON(!cpu_base->hres_active);
@@ -1172,6 +1205,10 @@ void hrtimer_interrupt(struct clock_event_device *dev)
         dev->next_event.tv64 = KTIME_MAX;
 
  retry:
+        /* 5 retries is enough to notice a hang */
+        if (!(++nr_retries % 5))
+                hrtimer_interrupt_hanging(dev, ktime_sub(ktime_get(), now));
+
         now = ktime_get();
 
         expires_next.tv64 = KTIME_MAX;
@@ -1224,7 +1261,7 @@ void hrtimer_interrupt(struct clock_event_device *dev)
 
         /* Reprogramming necessary ? */
         if (expires_next.tv64 != KTIME_MAX) {
-                if (tick_program_event(expires_next, 0))
+                if (tick_program_event(expires_next, force_clock_reprogram))
                         goto retry;
         }
 }
@@ -1578,6 +1615,10 @@ static int __cpuinit hrtimer_cpu_notify(struct notifier_block *self,
                 break;
 
 #ifdef CONFIG_HOTPLUG_CPU
+        case CPU_DYING:
+        case CPU_DYING_FROZEN:
+                clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DYING, &scpu);
+                break;
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
         {
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index f63c706d25e1..03d0bed2b8d9 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -78,6 +78,7 @@ void dynamic_irq_cleanup(unsigned int irq)
         desc->handle_irq = handle_bad_irq;
         desc->chip = &no_irq_chip;
         desc->name = NULL;
+        clear_kstat_irqs(desc);
         spin_unlock_irqrestore(&desc->lock, flags);
 }
 
@@ -290,7 +291,8 @@ static inline void mask_ack_irq(struct irq_desc *desc, int irq)
                 desc->chip->mask_ack(irq);
         else {
                 desc->chip->mask(irq);
-                desc->chip->ack(irq);
+                if (desc->chip->ack)
+                        desc->chip->ack(irq);
         }
 }
 
@@ -383,6 +385,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
 out_unlock:
         spin_unlock(&desc->lock);
 }
+EXPORT_SYMBOL_GPL(handle_level_irq);
 
 /**
  *      handle_fasteoi_irq - irq handler for transparent controllers
@@ -475,7 +478,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
         kstat_incr_irqs_this_cpu(irq, desc);
 
         /* Start handling the irq */
-        desc->chip->ack(irq);
+        if (desc->chip->ack)
+                desc->chip->ack(irq);
         desc = irq_remap_to_desc(irq, desc);
 
         /* Mark the IRQ currently in progress.*/
@@ -593,6 +597,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
         }
         spin_unlock_irqrestore(&desc->lock, flags);
 }
+EXPORT_SYMBOL_GPL(__set_irq_handler);
 
 void
 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index c20db0be9173..f6cdda68e5c6 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -39,6 +39,18 @@ void handle_bad_irq(unsigned int irq, struct irq_desc *desc)
         ack_bad_irq(irq);
 }
 
+#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
+static void __init init_irq_default_affinity(void)
+{
+        alloc_bootmem_cpumask_var(&irq_default_affinity);
+        cpumask_setall(irq_default_affinity);
+}
+#else
+static void __init init_irq_default_affinity(void)
+{
+}
+#endif
+
 /*
  * Linux has a controller-independent interrupt architecture.
  * Every controller has a 'controller-template', that is used
@@ -71,19 +83,21 @@ static struct irq_desc irq_desc_init = {
 
 void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr)
 {
-        unsigned long bytes;
-        char *ptr;
         int node;
-
-        /* Compute how many bytes we need per irq and allocate them */
-        bytes = nr * sizeof(unsigned int);
+        void *ptr;
 
         node = cpu_to_node(cpu);
-        ptr = kzalloc_node(bytes, GFP_ATOMIC, node);
-        printk(KERN_DEBUG "  alloc kstat_irqs on cpu %d node %d\n", cpu, node);
+        ptr = kzalloc_node(nr * sizeof(*desc->kstat_irqs), GFP_ATOMIC, node);
 
-        if (ptr)
-                desc->kstat_irqs = (unsigned int *)ptr;
+        /*
+         * don't overwite if can not get new one
+         * init_copy_kstat_irqs() could still use old one
+         */
+        if (ptr) {
+                printk(KERN_DEBUG "  alloc kstat_irqs on cpu %d node %d\n",
+                         cpu, node);
+                desc->kstat_irqs = ptr;
+        }
 }
 
 static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
@@ -134,6 +148,8 @@ int __init early_irq_init(void)
         int legacy_count;
         int i;
 
+        init_irq_default_affinity();
+
         desc = irq_desc_legacy;
         legacy_count = ARRAY_SIZE(irq_desc_legacy);
 
@@ -213,17 +229,22 @@ struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
         }
 };
 
+static unsigned int kstat_irqs_all[NR_IRQS][NR_CPUS];
 int __init early_irq_init(void)
 {
         struct irq_desc *desc;
         int count;
         int i;
 
+        init_irq_default_affinity();
+
         desc = irq_desc;
         count = ARRAY_SIZE(irq_desc);
 
-        for (i = 0; i < count; i++)
+        for (i = 0; i < count; i++) {
                 desc[i].irq = i;
+                desc[i].kstat_irqs = kstat_irqs_all[i];
+        }
 
         return arch_early_irq_init();
 }
@@ -239,6 +260,11 @@ struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
 }
 #endif /* !CONFIG_SPARSE_IRQ */
 
+void clear_kstat_irqs(struct irq_desc *desc)
+{
+        memset(desc->kstat_irqs, 0, nr_cpu_ids * sizeof(*(desc->kstat_irqs)));
+}
+
 /*
  * What should we do if we get a hw irq event on an illegal vector?
  * Each architecture has to answer this themself.
@@ -312,6 +338,8 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
         irqreturn_t ret, retval = IRQ_NONE;
         unsigned int status = 0;
 
+        WARN_ONCE(!in_irq(), "BUG: IRQ handler called from non-hardirq context!");
+
         if (!(action->flags & IRQF_DISABLED))
                 local_irq_enable_in_hardirq();
 
@@ -331,6 +359,11 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
 }
 
 #ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
+
+#ifdef CONFIG_ENABLE_WARN_DEPRECATED
+# warning __do_IRQ is deprecated. Please convert to proper flow handlers
+#endif
+
 /**
  * __do_IRQ - original all in one highlevel IRQ handler
  * @irq:        the interrupt number
@@ -451,12 +484,10 @@ void early_init_irq_lock_class(void)
         }
 }
 
-#ifdef CONFIG_SPARSE_IRQ
 unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
 {
         struct irq_desc *desc = irq_to_desc(irq);
         return desc ? desc->kstat_irqs[cpu] : 0;
 }
-#endif
 EXPORT_SYMBOL(kstat_irqs_cpu);
 
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index e6d0a43cc125..b60950bf5a16 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -15,6 +15,7 @@ extern int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
 
 extern struct lock_class_key irq_desc_lock_class;
 extern void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr);
+extern void clear_kstat_irqs(struct irq_desc *desc);
 extern spinlock_t sparse_irq_lock;
 extern struct irq_desc *irq_desc_ptrs[NR_IRQS];
 
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index cd0cd8dcb345..ea119effe096 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -15,17 +15,9 @@
 
 #include "internals.h"
 
-#ifdef CONFIG_SMP
+#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 cpumask_var_t irq_default_affinity;
 
-static int init_irq_default_affinity(void)
-{
-        alloc_cpumask_var(&irq_default_affinity, GFP_KERNEL);
-        cpumask_setall(irq_default_affinity);
-        return 0;
-}
-core_initcall(init_irq_default_affinity);
-
 /**
  *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
  *      @irq: interrupt number to wait for
@@ -117,7 +109,7 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
 /*
  * Generic version of the affinity autoselector.
  */
-int do_irq_select_affinity(unsigned int irq, struct irq_desc *desc)
+static int setup_affinity(unsigned int irq, struct irq_desc *desc)
 {
         if (!irq_can_set_affinity(irq))
                 return 0;
@@ -141,7 +133,7 @@ set_affinity:
         return 0;
 }
 #else
-static inline int do_irq_select_affinity(unsigned int irq, struct irq_desc *d)
+static inline int setup_affinity(unsigned int irq, struct irq_desc *d)
 {
         return irq_select_affinity(irq);
 }
@@ -157,14 +149,14 @@ int irq_select_affinity_usr(unsigned int irq)
         int ret;
 
         spin_lock_irqsave(&desc->lock, flags);
-        ret = do_irq_select_affinity(irq, desc);
+        ret = setup_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)
+static inline int setup_affinity(unsigned int irq, struct irq_desc *desc)
 {
         return 0;
 }
@@ -397,9 +389,9 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
  * allocate special interrupts that are part of the architecture.
  */
 static int
-__setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
+__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
 {
-        struct irqaction *old, **p;
+        struct irqaction *old, **old_ptr;
         const char *old_name = NULL;
         unsigned long flags;
         int shared = 0;
@@ -431,8 +423,8 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
          * The following block of code has to be executed atomically
          */
         spin_lock_irqsave(&desc->lock, flags);
-        p = &desc->action;
-        old = *p;
+        old_ptr = &desc->action;
+        old = *old_ptr;
         if (old) {
                 /*
                  * Can't share interrupts unless both agree to and are
@@ -455,8 +447,8 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
 
                 /* add new interrupt at end of irq queue */
                 do {
-                        p = &old->next;
-                        old = *p;
+                        old_ptr = &old->next;
+                        old = *old_ptr;
                 } while (old);
                 shared = 1;
         }
@@ -496,7 +488,7 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
                         desc->status |= IRQ_NO_BALANCING;
 
                 /* Set default affinity mask once everything is setup */
-                do_irq_select_affinity(irq, desc);
+                setup_affinity(irq, desc);
 
         } else if ((new->flags & IRQF_TRIGGER_MASK)
                         && (new->flags & IRQF_TRIGGER_MASK)
@@ -507,7 +499,7 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
                                 (int)(new->flags & IRQF_TRIGGER_MASK));
         }
 
-        *p = new;
+        *old_ptr = new;
 
         /* Reset broken irq detection when installing new handler */
         desc->irq_count = 0;
@@ -557,90 +549,117 @@ int setup_irq(unsigned int irq, struct irqaction *act)
 
         return __setup_irq(irq, desc, act);
 }
+EXPORT_SYMBOL_GPL(setup_irq);
 
-/**
- *      free_irq - free an interrupt
- *      @irq: Interrupt line to free
- *      @dev_id: Device identity to free
- *
- *      Remove an interrupt handler. The handler is removed and if the
- *      interrupt line is no longer in use by any driver it is disabled.
- *      On a shared IRQ the caller must ensure the interrupt is disabled
- *      on the card it drives before calling this function. The function
- *      does not return until any executing interrupts for this IRQ
- *      have completed.
- *
- *      This function must not be called from interrupt context.
+ /*
+ * Internal function to unregister an irqaction - used to free
+ * regular and special interrupts that are part of the architecture.
  */
-void free_irq(unsigned int irq, void *dev_id)
+static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
 {
         struct irq_desc *desc = irq_to_desc(irq);
-        struct irqaction **p;
+        struct irqaction *action, **action_ptr;
         unsigned long flags;
 
-        WARN_ON(in_interrupt());
+        WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
 
         if (!desc)
-                return;
+                return NULL;
 
         spin_lock_irqsave(&desc->lock, flags);
-        p = &desc->action;
+
+        /*
+         * There can be multiple actions per IRQ descriptor, find the right
+         * one based on the dev_id:
+         */
+        action_ptr = &desc->action;
         for (;;) {
-                struct irqaction *action = *p;
+                action = *action_ptr;
 
-                if (action) {
-                        struct irqaction **pp = p;
+                if (!action) {
+                        WARN(1, "Trying to free already-free IRQ %d\n", irq);
+                        spin_unlock_irqrestore(&desc->lock, flags);
 
-                        p = &action->next;
-                        if (action->dev_id != dev_id)
-                                continue;
+                        return NULL;
+                }
 
-                        /* Found it - now remove it from the list of entries */
-                        *pp = action->next;
+                if (action->dev_id == dev_id)
+                        break;
+                action_ptr = &action->next;
+        }
+
+        /* Found it - now remove it from the list of entries: */
+        *action_ptr = action->next;
 
-                        /* Currently used only by UML, might disappear one day.*/
+        /* Currently used only by UML, might disappear one day: */
 #ifdef CONFIG_IRQ_RELEASE_METHOD
-                        if (desc->chip->release)
-                                desc->chip->release(irq, dev_id);
+        if (desc->chip->release)
+                desc->chip->release(irq, dev_id);
 #endif
 
-                        if (!desc->action) {
-                                desc->status |= IRQ_DISABLED;
-                                if (desc->chip->shutdown)
-                                        desc->chip->shutdown(irq);
-                                else
-                                        desc->chip->disable(irq);
-                        }
-                        spin_unlock_irqrestore(&desc->lock, flags);
-                        unregister_handler_proc(irq, action);
+        /* If this was the last handler, shut down the IRQ line: */
+        if (!desc->action) {
+                desc->status |= IRQ_DISABLED;
+                if (desc->chip->shutdown)
+                        desc->chip->shutdown(irq);
+                else
+                        desc->chip->disable(irq);
+        }
+        spin_unlock_irqrestore(&desc->lock, flags);
+
+        unregister_handler_proc(irq, action);
+
+        /* Make sure it's not being used on another CPU: */
+        synchronize_irq(irq);
 
-                        /* Make sure it's not being used on another CPU */
-                        synchronize_irq(irq);
-#ifdef CONFIG_DEBUG_SHIRQ
-                        /*
-                         * It's a shared IRQ -- the driver ought to be
-                         * prepared for it to happen even now it's
-                         * being freed, so let's make sure....  We do
-                         * this after actually deregistering it, to
-                         * make sure that a 'real' IRQ doesn't run in
-                         * parallel with our fake
-                         */
-                        if (action->flags & IRQF_SHARED) {
-                                local_irq_save(flags);
-                                action->handler(irq, dev_id);
-                                local_irq_restore(flags);
-                        }
-#endif
-                        kfree(action);
-                        return;
-                }
-                printk(KERN_ERR "Trying to free already-free IRQ %d\n", irq);
 #ifdef CONFIG_DEBUG_SHIRQ
-                dump_stack();
-#endif
-                spin_unlock_irqrestore(&desc->lock, flags);
-                return;
+        /*
+         * It's a shared IRQ -- the driver ought to be prepared for an IRQ
+         * event to happen even now it's being freed, so let's make sure that
+         * is so by doing an extra call to the handler ....
+         *
+         * ( We do this after actually deregistering it, to make sure that a
+         *   'real' IRQ doesn't run in * parallel with our fake. )
+         */
+        if (action->flags & IRQF_SHARED) {
+                local_irq_save(flags);
+                action->handler(irq, dev_id);
+                local_irq_restore(flags);
         }
+#endif
+        return action;
+}
+
+/**
+ *      remove_irq - free an interrupt
+ *      @irq: Interrupt line to free
+ *      @act: irqaction for the interrupt
+ *
+ * Used to remove interrupts statically setup by the early boot process.
+ */
+void remove_irq(unsigned int irq, struct irqaction *act)
+{
+        __free_irq(irq, act->dev_id);
+}
+EXPORT_SYMBOL_GPL(remove_irq);
+
+/**
+ *      free_irq - free an interrupt allocated with request_irq
+ *      @irq: Interrupt line to free
+ *      @dev_id: Device identity to free
+ *
+ *      Remove an interrupt handler. The handler is removed and if the
+ *      interrupt line is no longer in use by any driver it is disabled.
+ *      On a shared IRQ the caller must ensure the interrupt is disabled
+ *      on the card it drives before calling this function. The function
+ *      does not return until any executing interrupts for this IRQ
+ *      have completed.
+ *
+ *      This function must not be called from interrupt context.
+ */
+void free_irq(unsigned int irq, void *dev_id)
+{
+        kfree(__free_irq(irq, dev_id));
 }
 EXPORT_SYMBOL(free_irq);
 
@@ -687,11 +706,12 @@ int request_irq(unsigned int irq, irq_handler_t handler,
          * the behavior is classified as "will not fix" so we need to
          * start nudging drivers away from using that idiom.
          */
-        if ((irqflags & (IRQF_SHARED|IRQF_DISABLED))
-                        == (IRQF_SHARED|IRQF_DISABLED))
-                pr_warning("IRQ %d/%s: IRQF_DISABLED is not "
-                                "guaranteed on shared IRQs\n",
-                                irq, devname);
+        if ((irqflags & (IRQF_SHARED|IRQF_DISABLED)) ==
+                                        (IRQF_SHARED|IRQF_DISABLED)) {
+                pr_warning(
+                  "IRQ %d/%s: IRQF_DISABLED is not guaranteed on shared IRQs\n",
+                        irq, devname);
+        }
 
 #ifdef CONFIG_LOCKDEP
         /*
@@ -717,15 +737,13 @@ int request_irq(unsigned int irq, irq_handler_t handler,
         if (!handler)
                 return -EINVAL;
 
-        action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
+        action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
         if (!action)
                 return -ENOMEM;
 
         action->handler = handler;
         action->flags = irqflags;
-        cpus_clear(action->mask);
         action->name = devname;
-        action->next = NULL;
         action->dev_id = dev_id;
 
         retval = __setup_irq(irq, desc, action);
diff --git a/kernel/irq/numa_migrate.c b/kernel/irq/numa_migrate.c
index ecf765c6a77a..aef18ab6b75b 100644
--- a/kernel/irq/numa_migrate.c
+++ b/kernel/irq/numa_migrate.c
@@ -17,16 +17,11 @@ static void init_copy_kstat_irqs(struct irq_desc *old_desc,
                                  struct irq_desc *desc,
                                  int cpu, int nr)
 {
-        unsigned long bytes;
-
         init_kstat_irqs(desc, cpu, nr);
 
-        if (desc->kstat_irqs != old_desc->kstat_irqs) {
-                /* Compute how many bytes we need per irq and allocate them */
-                bytes = nr * sizeof(unsigned int);
-
-                memcpy(desc->kstat_irqs, old_desc->kstat_irqs, bytes);
-        }
+        if (desc->kstat_irqs != old_desc->kstat_irqs)
+                memcpy(desc->kstat_irqs, old_desc->kstat_irqs,
+                         nr * sizeof(*desc->kstat_irqs));
 }
 
 static void free_kstat_irqs(struct irq_desc *old_desc, struct irq_desc *desc)
@@ -71,7 +66,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
         desc = irq_desc_ptrs[irq];
 
         if (desc && old_desc != desc)
-                        goto out_unlock;
+                goto out_unlock;
 
         node = cpu_to_node(cpu);
         desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
@@ -84,10 +79,15 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
         init_copy_one_irq_desc(irq, old_desc, desc, cpu);
 
         irq_desc_ptrs[irq] = desc;
+        spin_unlock_irqrestore(&sparse_irq_lock, flags);
 
         /* free the old one */
         free_one_irq_desc(old_desc, desc);
+        spin_unlock(&old_desc->lock);
         kfree(old_desc);
+        spin_lock(&desc->lock);
+
+        return desc;
 
 out_unlock:
         spin_unlock_irqrestore(&sparse_irq_lock, flags);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index dd364c11e56e..4d568294de3e 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -104,7 +104,7 @@ static int misrouted_irq(int irq)
         return ok;
 }
 
-static void poll_spurious_irqs(unsigned long dummy)
+static void poll_all_shared_irqs(void)
 {
         struct irq_desc *desc;
         int i;
@@ -123,11 +123,23 @@ static void poll_spurious_irqs(unsigned long dummy)
 
                 try_one_irq(i, desc);
         }
+}
+
+static void poll_spurious_irqs(unsigned long dummy)
+{
+        poll_all_shared_irqs();
 
         mod_timer(&poll_spurious_irq_timer,
                   jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
 }
 
+#ifdef CONFIG_DEBUG_SHIRQ
+void debug_poll_all_shared_irqs(void)
+{
+        poll_all_shared_irqs();
+}
+#endif
+
 /*
  * If 99,900 of the previous 100,000 interrupts have not been handled
  * then assume that the IRQ is stuck in some manner. Drop a diagnostic
diff --git a/kernel/itimer.c b/kernel/itimer.c
index 6a5fe93dd8bd..58762f7077ec 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -62,7 +62,7 @@ int do_getitimer(int which, struct itimerval *value)
                         struct task_cputime cputime;
                         cputime_t utime;
 
-                        thread_group_cputime(tsk, &cputime);
+                        thread_group_cputimer(tsk, &cputime);
                         utime = cputime.utime;
                         if (cputime_le(cval, utime)) { /* about to fire */
                                 cval = jiffies_to_cputime(1);
@@ -82,7 +82,7 @@ int do_getitimer(int which, struct itimerval *value)
                         struct task_cputime times;
                         cputime_t ptime;
 
-                        thread_group_cputime(tsk, &times);
+                        thread_group_cputimer(tsk, &times);
                         ptime = cputime_add(times.utime, times.stime);
                         if (cputime_le(cval, ptime)) { /* about to fire */
                                 cval = jiffies_to_cputime(1);
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index e694afa0eb8c..7b8b0f21a5b1 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -30,19 +30,20 @@
 #define all_var 0
 #endif
 
-extern const unsigned long kallsyms_addresses[];
-extern const u8 kallsyms_names[];
+/* These will be re-linked against their real values during the second link stage */
+extern const unsigned long kallsyms_addresses[] __attribute__((weak));
+extern const u8 kallsyms_names[] __attribute__((weak));
 
 /* tell the compiler that the count isn't in the small data section if the arch
  * has one (eg: FRV)
  */
 extern const unsigned long kallsyms_num_syms
-        __attribute__((__section__(".rodata")));
+__attribute__((weak, section(".rodata")));
 
-extern const u8 kallsyms_token_table[];
-extern const u16 kallsyms_token_index[];
+extern const u8 kallsyms_token_table[] __attribute__((weak));
+extern const u16 kallsyms_token_index[] __attribute__((weak));
 
-extern const unsigned long kallsyms_markers[];
+extern const unsigned long kallsyms_markers[] __attribute__((weak));
 
 static inline int is_kernel_inittext(unsigned long addr)
 {
@@ -167,6 +168,9 @@ static unsigned long get_symbol_pos(unsigned long addr,
         unsigned long symbol_start = 0, symbol_end = 0;
         unsigned long i, low, high, mid;
 
+        /* This kernel should never had been booted. */
+        BUG_ON(!kallsyms_addresses);
+
         /* do a binary search on the sorted kallsyms_addresses array */
         low = 0;
         high = kallsyms_num_syms;
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 8a6d7b08864e..483899578259 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -1465,6 +1465,11 @@ int kernel_kexec(void)
                 error = device_power_down(PMSG_FREEZE);
                 if (error)
                         goto Enable_irqs;
+
+                /* Suspend system devices */
+                error = sysdev_suspend(PMSG_FREEZE);
+                if (error)
+                        goto Power_up_devices;
         } else
 #endif
         {
@@ -1477,6 +1482,8 @@ int kernel_kexec(void)
 
 #ifdef CONFIG_KEXEC_JUMP
         if (kexec_image->preserve_context) {
+                sysdev_resume();
+ Power_up_devices:
                 device_power_up(PMSG_RESTORE);
  Enable_irqs:
                 local_irq_enable();
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 1b9cbdc0127a..7ba8cd9845cb 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -123,7 +123,7 @@ static int collect_garbage_slots(void);
 static int __kprobes check_safety(void)
 {
         int ret = 0;
-#if defined(CONFIG_PREEMPT) && defined(CONFIG_PM)
+#if defined(CONFIG_PREEMPT) && defined(CONFIG_FREEZER)
         ret = freeze_processes();
         if (ret == 0) {
                 struct task_struct *p, *q;
diff --git a/kernel/latencytop.c b/kernel/latencytop.c
index 449db466bdbc..ca07c5c0c914 100644
--- a/kernel/latencytop.c
+++ b/kernel/latencytop.c
@@ -9,6 +9,44 @@
  * as published by the Free Software Foundation; version 2
  * of the License.
  */
+
+/*
+ * CONFIG_LATENCYTOP enables a kernel latency tracking infrastructure that is
+ * used by the "latencytop" userspace tool. The latency that is tracked is not
+ * the 'traditional' interrupt latency (which is primarily caused by something
+ * else consuming CPU), but instead, it is the latency an application encounters
+ * because the kernel sleeps on its behalf for various reasons.
+ *
+ * This code tracks 2 levels of statistics:
+ * 1) System level latency
+ * 2) Per process latency
+ *
+ * The latency is stored in fixed sized data structures in an accumulated form;
+ * if the "same" latency cause is hit twice, this will be tracked as one entry
+ * in the data structure. Both the count, total accumulated latency and maximum
+ * latency are tracked in this data structure. When the fixed size structure is
+ * full, no new causes are tracked until the buffer is flushed by writing to
+ * the /proc file; the userspace tool does this on a regular basis.
+ *
+ * A latency cause is identified by a stringified backtrace at the point that
+ * the scheduler gets invoked. The userland tool will use this string to
+ * identify the cause of the latency in human readable form.
+ *
+ * The information is exported via /proc/latency_stats and /proc/<pid>/latency.
+ * These files look like this:
+ *
+ * Latency Top version : v0.1
+ * 70 59433 4897 i915_irq_wait drm_ioctl vfs_ioctl do_vfs_ioctl sys_ioctl
+ * |    |    |    |
+ * |    |    |    +----> the stringified backtrace
+ * |    |    +---------> The maximum latency for this entry in microseconds
+ * |    +--------------> The accumulated latency for this entry (microseconds)
+ * +-------------------> The number of times this entry is hit
+ *
+ * (note: the average latency is the accumulated latency divided by the number
+ * of times)
+ */
+
 #include <linux/latencytop.h>
 #include <linux/kallsyms.h>
 #include <linux/seq_file.h>
@@ -72,7 +110,7 @@ account_global_scheduler_latency(struct task_struct *tsk, struct latency_record
                                 firstnonnull = i;
                         continue;
                 }
-                for (q = 0 ; q < LT_BACKTRACEDEPTH ; q++) {
+                for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
                         unsigned long record = lat->backtrace[q];
 
                         if (latency_record[i].backtrace[q] != record) {
@@ -101,31 +139,52 @@ account_global_scheduler_latency(struct task_struct *tsk, struct latency_record
         memcpy(&latency_record[i], lat, sizeof(struct latency_record));
 }
 
-static inline void store_stacktrace(struct task_struct *tsk, struct latency_record *lat)
+/*
+ * Iterator to store a backtrace into a latency record entry
+ */
+static inline void store_stacktrace(struct task_struct *tsk,
+                                        struct latency_record *lat)
 {
         struct stack_trace trace;
 
         memset(&trace, 0, sizeof(trace));
         trace.max_entries = LT_BACKTRACEDEPTH;
         trace.entries = &lat->backtrace[0];
-        trace.skip = 0;
         save_stack_trace_tsk(tsk, &trace);
 }
 
+/**
+ * __account_scheduler_latency - record an occured latency
+ * @tsk - the task struct of the task hitting the latency
+ * @usecs - the duration of the latency in microseconds
+ * @inter - 1 if the sleep was interruptible, 0 if uninterruptible
+ *
+ * This function is the main entry point for recording latency entries
+ * as called by the scheduler.
+ *
+ * This function has a few special cases to deal with normal 'non-latency'
+ * sleeps: specifically, interruptible sleep longer than 5 msec is skipped
+ * since this usually is caused by waiting for events via select() and co.
+ *
+ * Negative latencies (caused by time going backwards) are also explicitly
+ * skipped.
+ */
 void __sched
-account_scheduler_latency(struct task_struct *tsk, int usecs, int inter)
+__account_scheduler_latency(struct task_struct *tsk, int usecs, int inter)
 {
         unsigned long flags;
         int i, q;
         struct latency_record lat;
 
-        if (!latencytop_enabled)
-                return;
-
         /* Long interruptible waits are generally user requested... */
         if (inter && usecs > 5000)
                 return;
 
+        /* Negative sleeps are time going backwards */
+        /* Zero-time sleeps are non-interesting */
+        if (usecs <= 0)
+                return;
+
         memset(&lat, 0, sizeof(lat));
         lat.count = 1;
         lat.time = usecs;
@@ -143,12 +202,12 @@ account_scheduler_latency(struct task_struct *tsk, int usecs, int inter)
         if (tsk->latency_record_count >= LT_SAVECOUNT)
                 goto out_unlock;
 
-        for (i = 0; i < LT_SAVECOUNT ; i++) {
+        for (i = 0; i < LT_SAVECOUNT; i++) {
                 struct latency_record *mylat;
                 int same = 1;
 
                 mylat = &tsk->latency_record[i];
-                for (q = 0 ; q < LT_BACKTRACEDEPTH ; q++) {
+                for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
                         unsigned long record = lat.backtrace[q];
 
                         if (mylat->backtrace[q] != record) {
@@ -186,7 +245,7 @@ static int lstats_show(struct seq_file *m, void *v)
         for (i = 0; i < MAXLR; i++) {
                 if (latency_record[i].backtrace[0]) {
                         int q;
-                        seq_printf(m, "%i %li %li ",
+                        seq_printf(m, "%i %lu %lu ",
                                 latency_record[i].count,
                                 latency_record[i].time,
                                 latency_record[i].max);
@@ -223,7 +282,7 @@ static int lstats_open(struct inode *inode, struct file *filp)
         return single_open(filp, lstats_show, NULL);
 }
 
-static struct file_operations lstats_fops = {
+static const struct file_operations lstats_fops = {
         .open           = lstats_open,
         .read           = seq_read,
         .write          = lstats_write,
@@ -236,4 +295,4 @@ static int __init init_lstats_procfs(void)
         proc_create("latency_stats", 0644, NULL, &lstats_fops);
         return 0;
 }
-__initcall(init_lstats_procfs);
+device_initcall(init_lstats_procfs);
diff --git a/kernel/module.c b/kernel/module.c
index e8b51d41dd72..77672233387f 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -573,13 +573,13 @@ static char last_unloaded_module[MODULE_NAME_LEN+1];
 /* Init the unload section of the module. */
 static void module_unload_init(struct module *mod)
 {
-        unsigned int i;
+        int cpu;
 
         INIT_LIST_HEAD(&mod->modules_which_use_me);
-        for (i = 0; i < NR_CPUS; i++)
-                local_set(&mod->ref[i].count, 0);
+        for_each_possible_cpu(cpu)
+                local_set(__module_ref_addr(mod, cpu), 0);
         /* Hold reference count during initialization. */
-        local_set(&mod->ref[raw_smp_processor_id()].count, 1);
+        local_set(__module_ref_addr(mod, raw_smp_processor_id()), 1);
         /* Backwards compatibility macros put refcount during init. */
         mod->waiter = current;
 }
@@ -717,10 +717,11 @@ static int try_stop_module(struct module *mod, int flags, int *forced)
 
 unsigned int module_refcount(struct module *mod)
 {
-        unsigned int i, total = 0;
+        unsigned int total = 0;
+        int cpu;
 
-        for (i = 0; i < NR_CPUS; i++)
-                total += local_read(&mod->ref[i].count);
+        for_each_possible_cpu(cpu)
+                total += local_read(__module_ref_addr(mod, cpu));
         return total;
 }
 EXPORT_SYMBOL(module_refcount);
@@ -821,7 +822,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
         mutex_lock(&module_mutex);
         /* Store the name of the last unloaded module for diagnostic purposes */
         strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
-        unregister_dynamic_debug_module(mod->name);
+        ddebug_remove_module(mod->name);
         free_module(mod);
 
  out:
@@ -894,7 +895,7 @@ void module_put(struct module *module)
 {
         if (module) {
                 unsigned int cpu = get_cpu();
-                local_dec(&module->ref[cpu].count);
+                local_dec(__module_ref_addr(module, cpu));
                 /* Maybe they're waiting for us to drop reference? */
                 if (unlikely(!module_is_live(module)))
                         wake_up_process(module->waiter);
@@ -1464,7 +1465,10 @@ static void free_module(struct module *mod)
         kfree(mod->args);
         if (mod->percpu)
                 percpu_modfree(mod->percpu);
-
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        if (mod->refptr)
+                percpu_modfree(mod->refptr);
+#endif
         /* Free lock-classes: */
         lockdep_free_key_range(mod->module_core, mod->core_size);
 
@@ -1823,19 +1827,13 @@ static inline void add_kallsyms(struct module *mod,
 }
 #endif /* CONFIG_KALLSYMS */
 
-static void dynamic_printk_setup(struct mod_debug *debug, unsigned int num)
+static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
 {
-#ifdef CONFIG_DYNAMIC_PRINTK_DEBUG
-        unsigned int i;
-
-        for (i = 0; i < num; i++) {
-                register_dynamic_debug_module(debug[i].modname,
-                                              debug[i].type,
-                                              debug[i].logical_modname,
-                                              debug[i].flag_names,
-                                              debug[i].hash, debug[i].hash2);
-        }
-#endif /* CONFIG_DYNAMIC_PRINTK_DEBUG */
+#ifdef CONFIG_DYNAMIC_DEBUG
+        if (ddebug_add_module(debug, num, debug->modname))
+                printk(KERN_ERR "dynamic debug error adding module: %s\n",
+                                        debug->modname);
+#endif
 }
 
 static void *module_alloc_update_bounds(unsigned long size)
@@ -2070,6 +2068,14 @@ static noinline struct module *load_module(void __user *umod,
         /* Module has been moved. */
         mod = (void *)sechdrs[modindex].sh_addr;
 
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        mod->refptr = percpu_modalloc(sizeof(local_t), __alignof__(local_t),
+                                      mod->name);
+        if (!mod->refptr) {
+                err = -ENOMEM;
+                goto free_init;
+        }
+#endif
         /* Now we've moved module, initialize linked lists, etc. */
         module_unload_init(mod);
 
@@ -2201,12 +2207,13 @@ static noinline struct module *load_module(void __user *umod,
         add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);
 
         if (!mod->taints) {
-                struct mod_debug *debug;
+                struct _ddebug *debug;
                 unsigned int num_debug;
 
                 debug = section_objs(hdr, sechdrs, secstrings, "__verbose",
                                      sizeof(*debug), &num_debug);
-                dynamic_printk_setup(debug, num_debug);
+                if (debug)
+                        dynamic_debug_setup(debug, num_debug);
         }
 
         /* sechdrs[0].sh_size is always zero */
@@ -2276,9 +2283,14 @@ static noinline struct module *load_module(void __user *umod,
         ftrace_release(mod->module_core, mod->core_size);
  free_unload:
         module_unload_free(mod);
+ free_init:
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        percpu_modfree(mod->refptr);
+#endif
         module_free(mod, mod->module_init);
  free_core:
         module_free(mod, mod->module_core);
+        /* mod will be freed with core. Don't access it beyond this line! */
  free_percpu:
         if (percpu)
                 percpu_modfree(percpu);
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 157de3a47832..8e5d9a68b022 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -10,76 +10,6 @@
 #include <linux/kernel_stat.h>
 
 /*
- * Allocate the thread_group_cputime structure appropriately and fill in the
- * current values of the fields.  Called from copy_signal() via
- * thread_group_cputime_clone_thread() when adding a second or subsequent
- * thread to a thread group.  Assumes interrupts are enabled when called.
- */
-int thread_group_cputime_alloc(struct task_struct *tsk)
-{
-        struct signal_struct *sig = tsk->signal;
-        struct task_cputime *cputime;
-
-        /*
-         * If we have multiple threads and we don't already have a
-         * per-CPU task_cputime struct (checked in the caller), allocate
-         * one and fill it in with the times accumulated so far.  We may
-         * race with another thread so recheck after we pick up the sighand
-         * lock.
-         */
-        cputime = alloc_percpu(struct task_cputime);
-        if (cputime == NULL)
-                return -ENOMEM;
-        spin_lock_irq(&tsk->sighand->siglock);
-        if (sig->cputime.totals) {
-                spin_unlock_irq(&tsk->sighand->siglock);
-                free_percpu(cputime);
-                return 0;
-        }
-        sig->cputime.totals = cputime;
-        cputime = per_cpu_ptr(sig->cputime.totals, smp_processor_id());
-        cputime->utime = tsk->utime;
-        cputime->stime = tsk->stime;
-        cputime->sum_exec_runtime = tsk->se.sum_exec_runtime;
-        spin_unlock_irq(&tsk->sighand->siglock);
-        return 0;
-}
-
-/**
- * thread_group_cputime - Sum the thread group time fields across all CPUs.
- *
- * @tsk:        The task we use to identify the thread group.
- * @times:      task_cputime structure in which we return the summed fields.
- *
- * Walk the list of CPUs to sum the per-CPU time fields in the thread group
- * time structure.
- */
-void thread_group_cputime(
-        struct task_struct *tsk,
-        struct task_cputime *times)
-{
-        struct task_cputime *totals, *tot;
-        int i;
-
-        totals = tsk->signal->cputime.totals;
-        if (!totals) {
-                times->utime = tsk->utime;
-                times->stime = tsk->stime;
-                times->sum_exec_runtime = tsk->se.sum_exec_runtime;
-                return;
-        }
-
-        times->stime = times->utime = cputime_zero;
-        times->sum_exec_runtime = 0;
-        for_each_possible_cpu(i) {
-                tot = per_cpu_ptr(totals, i);
-                times->utime = cputime_add(times->utime, tot->utime);
-                times->stime = cputime_add(times->stime, tot->stime);
-                times->sum_exec_runtime += tot->sum_exec_runtime;
-        }
-}
-
-/*
  * Called after updating RLIMIT_CPU to set timer expiration if necessary.
  */
 void update_rlimit_cpu(unsigned long rlim_new)
@@ -300,6 +230,71 @@ static int cpu_clock_sample(const clockid_t which_clock, struct task_struct *p,
         return 0;
 }
 
+void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times)
+{
+        struct sighand_struct *sighand;
+        struct signal_struct *sig;
+        struct task_struct *t;
+
+        *times = INIT_CPUTIME;
+
+        rcu_read_lock();
+        sighand = rcu_dereference(tsk->sighand);
+        if (!sighand)
+                goto out;
+
+        sig = tsk->signal;
+
+        t = tsk;
+        do {
+                times->utime = cputime_add(times->utime, t->utime);
+                times->stime = cputime_add(times->stime, t->stime);
+                times->sum_exec_runtime += t->se.sum_exec_runtime;
+
+                t = next_thread(t);
+        } while (t != tsk);
+
+        times->utime = cputime_add(times->utime, sig->utime);
+        times->stime = cputime_add(times->stime, sig->stime);
+        times->sum_exec_runtime += sig->sum_sched_runtime;
+out:
+        rcu_read_unlock();
+}
+
+static void update_gt_cputime(struct task_cputime *a, struct task_cputime *b)
+{
+        if (cputime_gt(b->utime, a->utime))
+                a->utime = b->utime;
+
+        if (cputime_gt(b->stime, a->stime))
+                a->stime = b->stime;
+
+        if (b->sum_exec_runtime > a->sum_exec_runtime)
+                a->sum_exec_runtime = b->sum_exec_runtime;
+}
+
+void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times)
+{
+        struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
+        struct task_cputime sum;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cputimer->lock, flags);
+        if (!cputimer->running) {
+                cputimer->running = 1;
+                /*
+                 * The POSIX timer interface allows for absolute time expiry
+                 * values through the TIMER_ABSTIME flag, therefore we have
+                 * to synchronize the timer to the clock every time we start
+                 * it.
+                 */
+                thread_group_cputime(tsk, &sum);
+                update_gt_cputime(&cputimer->cputime, &sum);
+        }
+        *times = cputimer->cputime;
+        spin_unlock_irqrestore(&cputimer->lock, flags);
+}
+
 /*
  * Sample a process (thread group) clock for the given group_leader task.
  * Must be called with tasklist_lock held for reading.
@@ -527,7 +522,7 @@ void posix_cpu_timers_exit_group(struct task_struct *tsk)
 {
         struct task_cputime cputime;
 
-        thread_group_cputime(tsk, &cputime);
+        thread_group_cputimer(tsk, &cputime);
         cleanup_timers(tsk->signal->cpu_timers,
                        cputime.utime, cputime.stime, cputime.sum_exec_runtime);
 }
@@ -686,6 +681,33 @@ static void cpu_timer_fire(struct k_itimer *timer)
 }
 
 /*
+ * Sample a process (thread group) timer for the given group_leader task.
+ * Must be called with tasklist_lock held for reading.
+ */
+static int cpu_timer_sample_group(const clockid_t which_clock,
+                                  struct task_struct *p,
+                                  union cpu_time_count *cpu)
+{
+        struct task_cputime cputime;
+
+        thread_group_cputimer(p, &cputime);
+        switch (CPUCLOCK_WHICH(which_clock)) {
+        default:
+                return -EINVAL;
+        case CPUCLOCK_PROF:
+                cpu->cpu = cputime_add(cputime.utime, cputime.stime);
+                break;
+        case CPUCLOCK_VIRT:
+                cpu->cpu = cputime.utime;
+                break;
+        case CPUCLOCK_SCHED:
+                cpu->sched = cputime.sum_exec_runtime + task_delta_exec(p);
+                break;
+        }
+        return 0;
+}
+
+/*
  * Guts of sys_timer_settime for CPU timers.
  * This is called with the timer locked and interrupts disabled.
  * If we return TIMER_RETRY, it's necessary to release the timer's lock
@@ -746,7 +768,7 @@ int posix_cpu_timer_set(struct k_itimer *timer, int flags,
         if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
                 cpu_clock_sample(timer->it_clock, p, &val);
         } else {
-                cpu_clock_sample_group(timer->it_clock, p, &val);
+                cpu_timer_sample_group(timer->it_clock, p, &val);
         }
 
         if (old) {
@@ -894,7 +916,7 @@ void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
                         read_unlock(&tasklist_lock);
                         goto dead;
                 } else {
-                        cpu_clock_sample_group(timer->it_clock, p, &now);
+                        cpu_timer_sample_group(timer->it_clock, p, &now);
                         clear_dead = (unlikely(p->exit_state) &&
                                       thread_group_empty(p));
                 }
@@ -1034,6 +1056,19 @@ static void check_thread_timers(struct task_struct *tsk,
         }
 }
 
+static void stop_process_timers(struct task_struct *tsk)
+{
+        struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
+        unsigned long flags;
+
+        if (!cputimer->running)
+                return;
+
+        spin_lock_irqsave(&cputimer->lock, flags);
+        cputimer->running = 0;
+        spin_unlock_irqrestore(&cputimer->lock, flags);
+}
+
 /*
  * Check for any per-thread CPU timers that have fired and move them
  * off the tsk->*_timers list onto the firing list.  Per-thread timers
@@ -1057,13 +1092,15 @@ static void check_process_timers(struct task_struct *tsk,
             sig->rlim[RLIMIT_CPU].rlim_cur == RLIM_INFINITY &&
             list_empty(&timers[CPUCLOCK_VIRT]) &&
             cputime_eq(sig->it_virt_expires, cputime_zero) &&
-            list_empty(&timers[CPUCLOCK_SCHED]))
+            list_empty(&timers[CPUCLOCK_SCHED])) {
+                stop_process_timers(tsk);
                 return;
+        }
 
         /*
          * Collect the current process totals.
          */
-        thread_group_cputime(tsk, &cputime);
+        thread_group_cputimer(tsk, &cputime);
         utime = cputime.utime;
         ptime = cputime_add(utime, cputime.stime);
         sum_sched_runtime = cputime.sum_exec_runtime;
@@ -1234,7 +1271,7 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
                         clear_dead_task(timer, now);
                         goto out_unlock;
                 }
-                cpu_clock_sample_group(timer->it_clock, p, &now);
+                cpu_timer_sample_group(timer->it_clock, p, &now);
                 bump_cpu_timer(timer, now);
                 /* Leave the tasklist_lock locked for the call below.  */
         }
@@ -1329,11 +1366,12 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
         if (!task_cputime_zero(&sig->cputime_expires)) {
                 struct task_cputime group_sample;
 
-                thread_group_cputime(tsk, &group_sample);
+                thread_group_cputimer(tsk, &group_sample);
                 if (task_cputime_expired(&group_sample, &sig->cputime_expires))
                         return 1;
         }
-        return 0;
+
+        return sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY;
 }
 
 /*
@@ -1411,7 +1449,7 @@ void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx,
         struct list_head *head;
 
         BUG_ON(clock_idx == CPUCLOCK_SCHED);
-        cpu_clock_sample_group(clock_idx, tsk, &now);
+        cpu_timer_sample_group(clock_idx, tsk, &now);
 
         if (oldval) {
                 if (!cputime_eq(*oldval, cputime_zero)) {
diff --git a/kernel/power/Makefile b/kernel/power/Makefile
index 597823b5b700..720ea4f781bd 100644
--- a/kernel/power/Makefile
+++ b/kernel/power/Makefile
@@ -3,8 +3,9 @@ ifeq ($(CONFIG_PM_DEBUG),y)
 EXTRA_CFLAGS    +=      -DDEBUG
 endif
 
-obj-y                           := main.o
-obj-$(CONFIG_PM_SLEEP)          += process.o console.o
+obj-$(CONFIG_PM)                += main.o
+obj-$(CONFIG_PM_SLEEP)          += console.o
+obj-$(CONFIG_FREEZER)           += process.o
 obj-$(CONFIG_HIBERNATION)       += swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)       += poweroff.o
diff --git a/kernel/power/console.c b/kernel/power/console.c
index b8628be2a465..a3961b205de7 100644
--- a/kernel/power/console.c
+++ b/kernel/power/console.c
@@ -78,6 +78,12 @@ void pm_restore_console(void)
         }
         set_console(orig_fgconsole);
         release_console_sem();
+
+        if (vt_waitactive(orig_fgconsole)) {
+                pr_debug("Resume: Can't switch VCs.");
+                return;
+        }
+
         kmsg_redirect = orig_kmsg;
 }
 #endif
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 45e8541ab7e3..4a4a206b1979 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -71,6 +71,14 @@ void hibernation_set_ops(struct platform_hibernation_ops *ops)
         mutex_unlock(&pm_mutex);
 }
 
+static bool entering_platform_hibernation;
+
+bool system_entering_hibernation(void)
+{
+        return entering_platform_hibernation;
+}
+EXPORT_SYMBOL(system_entering_hibernation);
+
 #ifdef CONFIG_PM_DEBUG
 static void hibernation_debug_sleep(void)
 {
@@ -219,6 +227,12 @@ static int create_image(int platform_mode)
                         "aborting hibernation\n");
                 goto Enable_irqs;
         }
+        sysdev_suspend(PMSG_FREEZE);
+        if (error) {
+                printk(KERN_ERR "PM: Some devices failed to power down, "
+                        "aborting hibernation\n");
+                goto Power_up_devices;
+        }
 
         if (hibernation_test(TEST_CORE))
                 goto Power_up;
@@ -234,9 +248,11 @@ static int create_image(int platform_mode)
         if (!in_suspend)
                 platform_leave(platform_mode);
  Power_up:
+        sysdev_resume();
         /* NOTE:  device_power_up() is just a resume() for devices
          * that suspended with irqs off ... no overall powerup.
          */
+ Power_up_devices:
         device_power_up(in_suspend ?
                 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
  Enable_irqs:
@@ -327,6 +343,7 @@ static int resume_target_kernel(void)
                         "aborting resume\n");
                 goto Enable_irqs;
         }
+        sysdev_suspend(PMSG_QUIESCE);
         /* We'll ignore saved state, but this gets preempt count (etc) right */
         save_processor_state();
         error = restore_highmem();
@@ -349,6 +366,7 @@ static int resume_target_kernel(void)
         swsusp_free();
         restore_processor_state();
         touch_softlockup_watchdog();
+        sysdev_resume();
         device_power_up(PMSG_RECOVER);
  Enable_irqs:
         local_irq_enable();
@@ -411,6 +429,7 @@ int hibernation_platform_enter(void)
         if (error)
                 goto Close;
 
+        entering_platform_hibernation = true;
         suspend_console();
         error = device_suspend(PMSG_HIBERNATE);
         if (error) {
@@ -431,6 +450,7 @@ int hibernation_platform_enter(void)
         local_irq_disable();
         error = device_power_down(PMSG_HIBERNATE);
         if (!error) {
+                sysdev_suspend(PMSG_HIBERNATE);
                 hibernation_ops->enter();
                 /* We should never get here */
                 while (1);
@@ -445,6 +465,7 @@ int hibernation_platform_enter(void)
  Finish:
         hibernation_ops->finish();
  Resume_devices:
+        entering_platform_hibernation = false;
         device_resume(PMSG_RESTORE);
         resume_console();
  Close:
@@ -585,6 +606,12 @@ static int software_resume(void)
         unsigned int flags;
 
         /*
+         * If the user said "noresume".. bail out early.
+         */
+        if (noresume)
+                return 0;
+
+        /*
          * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
          * is configured into the kernel. Since the regular hibernate
          * trigger path is via sysfs which takes a buffer mutex before
@@ -600,6 +627,11 @@ static int software_resume(void)
                         mutex_unlock(&pm_mutex);
                         return -ENOENT;
                 }
+                /*
+                 * Some device discovery might still be in progress; we need
+                 * to wait for this to finish.
+                 */
+                wait_for_device_probe();
                 swsusp_resume_device = name_to_dev_t(resume_file);
                 pr_debug("PM: Resume from partition %s\n", resume_file);
         } else {
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 239988873971..c9632f841f64 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -57,16 +57,6 @@ int pm_notifier_call_chain(unsigned long val)
 #ifdef CONFIG_PM_DEBUG
 int pm_test_level = TEST_NONE;
 
-static int suspend_test(int level)
-{
-        if (pm_test_level == level) {
-                printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
-                mdelay(5000);
-                return 1;
-        }
-        return 0;
-}
-
 static const char * const pm_tests[__TEST_AFTER_LAST] = {
         [TEST_NONE] = "none",
         [TEST_CORE] = "core",
@@ -125,14 +115,24 @@ static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
 }
 
 power_attr(pm_test);
-#else /* !CONFIG_PM_DEBUG */
-static inline int suspend_test(int level) { return 0; }
-#endif /* !CONFIG_PM_DEBUG */
+#endif /* CONFIG_PM_DEBUG */
 
 #endif /* CONFIG_PM_SLEEP */
 
 #ifdef CONFIG_SUSPEND
 
+static int suspend_test(int level)
+{
+#ifdef CONFIG_PM_DEBUG
+        if (pm_test_level == level) {
+                printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
+                mdelay(5000);
+                return 1;
+        }
+#endif /* !CONFIG_PM_DEBUG */
+        return 0;
+}
+
 #ifdef CONFIG_PM_TEST_SUSPEND
 
 /*
@@ -298,8 +298,12 @@ static int suspend_enter(suspend_state_t state)
                 goto Done;
         }
 
-        if (!suspend_test(TEST_CORE))
-                error = suspend_ops->enter(state);
+        error = sysdev_suspend(PMSG_SUSPEND);
+        if (!error) {
+                if (!suspend_test(TEST_CORE))
+                        error = suspend_ops->enter(state);
+                sysdev_resume();
+        }
 
         device_power_up(PMSG_RESUME);
  Done:
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 6da14358537c..505f319e489c 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -60,6 +60,7 @@ static struct block_device *resume_bdev;
 static int submit(int rw, pgoff_t page_off, struct page *page,
                         struct bio **bio_chain)
 {
+        const int bio_rw = rw | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
         struct bio *bio;
 
         bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
@@ -80,7 +81,7 @@ static int submit(int rw, pgoff_t page_off, struct page *page,
         bio_get(bio);
 
         if (bio_chain == NULL) {
-                submit_bio(rw | (1 << BIO_RW_SYNC), bio);
+                submit_bio(bio_rw, bio);
                 wait_on_page_locked(page);
                 if (rw == READ)
                         bio_set_pages_dirty(bio);
@@ -90,7 +91,7 @@ static int submit(int rw, pgoff_t page_off, struct page *page,
                         get_page(page); /* These pages are freed later */
                 bio->bi_private = *bio_chain;
                 *bio_chain = bio;
-                submit_bio(rw | (1 << BIO_RW_SYNC), bio);
+                submit_bio(bio_rw, bio);
         }
         return 0;
 }
diff --git a/kernel/power/user.c b/kernel/power/user.c
index 005b93d839ba..6c85359364f2 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -95,15 +95,15 @@ static int snapshot_open(struct inode *inode, struct file *filp)
                 data->swap = swsusp_resume_device ?
                         swap_type_of(swsusp_resume_device, 0, NULL) : -1;
                 data->mode = O_RDONLY;
-                error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
+                error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
                 if (error)
-                        pm_notifier_call_chain(PM_POST_RESTORE);
+                        pm_notifier_call_chain(PM_POST_HIBERNATION);
         } else {
                 data->swap = -1;
                 data->mode = O_WRONLY;
-                error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
+                error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
                 if (error)
-                        pm_notifier_call_chain(PM_POST_HIBERNATION);
+                        pm_notifier_call_chain(PM_POST_RESTORE);
         }
         if (error)
                 atomic_inc(&snapshot_device_available);
diff --git a/kernel/printk.c b/kernel/printk.c
index 69188f226a93..e3602d0755b0 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -73,7 +73,6 @@ EXPORT_SYMBOL(oops_in_progress);
  * driver system.
  */
 static DECLARE_MUTEX(console_sem);
-static DECLARE_MUTEX(secondary_console_sem);
 struct console *console_drivers;
 EXPORT_SYMBOL_GPL(console_drivers);
 
@@ -891,12 +890,14 @@ void suspend_console(void)
         printk("Suspending console(s) (use no_console_suspend to debug)\n");
         acquire_console_sem();
         console_suspended = 1;
+        up(&console_sem);
 }
 
 void resume_console(void)
 {
         if (!console_suspend_enabled)
                 return;
+        down(&console_sem);
         console_suspended = 0;
         release_console_sem();
 }
@@ -912,11 +913,9 @@ void resume_console(void)
 void acquire_console_sem(void)
 {
         BUG_ON(in_interrupt());
-        if (console_suspended) {
-                down(&secondary_console_sem);
-                return;
-        }
         down(&console_sem);
+        if (console_suspended)
+                return;
         console_locked = 1;
         console_may_schedule = 1;
 }
@@ -926,6 +925,10 @@ int try_acquire_console_sem(void)
 {
         if (down_trylock(&console_sem))
                 return -1;
+        if (console_suspended) {
+                up(&console_sem);
+                return -1;
+        }
         console_locked = 1;
         console_may_schedule = 0;
         return 0;
@@ -979,7 +982,7 @@ void release_console_sem(void)
         unsigned wake_klogd = 0;
 
         if (console_suspended) {
-                up(&secondary_console_sem);
+                up(&console_sem);
                 return;
         }
 
diff --git a/kernel/profile.c b/kernel/profile.c
index 784933acf5b8..7724e0409bae 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -114,12 +114,15 @@ int __ref profile_init(void)
         if (!slab_is_available()) {
                 prof_buffer = alloc_bootmem(buffer_bytes);
                 alloc_bootmem_cpumask_var(&prof_cpu_mask);
+                cpumask_copy(prof_cpu_mask, cpu_possible_mask);
                 return 0;
         }
 
         if (!alloc_cpumask_var(&prof_cpu_mask, GFP_KERNEL))
                 return -ENOMEM;
 
+        cpumask_copy(prof_cpu_mask, cpu_possible_mask);
+
         prof_buffer = kzalloc(buffer_bytes, GFP_KERNEL);
         if (prof_buffer)
                 return 0;
diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
index 490934fc7ac3..654c640a6b9c 100644
--- a/kernel/rcuclassic.c
+++ b/kernel/rcuclassic.c
@@ -679,8 +679,8 @@ int rcu_needs_cpu(int cpu)
 void rcu_check_callbacks(int cpu, int user)
 {
         if (user ||
-            (idle_cpu(cpu) && !in_softirq() &&
-                                hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
+            (idle_cpu(cpu) && rcu_scheduler_active &&
+             !in_softirq() && hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
 
                 /*
                  * Get here if this CPU took its interrupt from user
@@ -716,7 +716,7 @@ void rcu_check_callbacks(int cpu, int user)
         raise_rcu_softirq();
 }
 
-static void rcu_init_percpu_data(int cpu, struct rcu_ctrlblk *rcp,
+static void __cpuinit rcu_init_percpu_data(int cpu, struct rcu_ctrlblk *rcp,
                                                 struct rcu_data *rdp)
 {
         unsigned long flags;
diff --git a/kernel/rcupdate.c b/kernel/rcupdate.c
index d92a76a881aa..cae8a059cf47 100644
--- a/kernel/rcupdate.c
+++ b/kernel/rcupdate.c
@@ -44,6 +44,7 @@
 #include <linux/cpu.h>
 #include <linux/mutex.h>
 #include <linux/module.h>
+#include <linux/kernel_stat.h>
 
 enum rcu_barrier {
         RCU_BARRIER_STD,
@@ -55,6 +56,7 @@ static DEFINE_PER_CPU(struct rcu_head, rcu_barrier_head) = {NULL};
 static atomic_t rcu_barrier_cpu_count;
 static DEFINE_MUTEX(rcu_barrier_mutex);
 static struct completion rcu_barrier_completion;
+int rcu_scheduler_active __read_mostly;
 
 /*
  * Awaken the corresponding synchronize_rcu() instance now that a
@@ -80,6 +82,10 @@ void wakeme_after_rcu(struct rcu_head  *head)
 void synchronize_rcu(void)
 {
         struct rcu_synchronize rcu;
+
+        if (rcu_blocking_is_gp())
+                return;
+
         init_completion(&rcu.completion);
         /* Will wake me after RCU finished. */
         call_rcu(&rcu.head, wakeme_after_rcu);
@@ -175,3 +181,9 @@ void __init rcu_init(void)
         __rcu_init();
 }
 
+void rcu_scheduler_starting(void)
+{
+        WARN_ON(num_online_cpus() != 1);
+        WARN_ON(nr_context_switches() > 0);
+        rcu_scheduler_active = 1;
+}
diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
index 33cfc50781f9..5d59e850fb71 100644
--- a/kernel/rcupreempt.c
+++ b/kernel/rcupreempt.c
@@ -1181,6 +1181,9 @@ void __synchronize_sched(void)
 {
         struct rcu_synchronize rcu;
 
+        if (num_online_cpus() == 1)
+                return;  /* blocking is gp if only one CPU! */
+
         init_completion(&rcu.completion);
         /* Will wake me after RCU finished. */
         call_rcu_sched(&rcu.head, wakeme_after_rcu);
diff --git a/kernel/rcutree.c b/kernel/rcutree.c
index f2d8638e6c60..97ce31579ec0 100644
--- a/kernel/rcutree.c
+++ b/kernel/rcutree.c
@@ -948,8 +948,8 @@ static void rcu_do_batch(struct rcu_data *rdp)
 void rcu_check_callbacks(int cpu, int user)
 {
         if (user ||
-            (idle_cpu(cpu) && !in_softirq() &&
-                                hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
+            (idle_cpu(cpu) && rcu_scheduler_active &&
+             !in_softirq() && hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
 
                 /*
                  * Get here if this CPU took its interrupt from user
@@ -1314,7 +1314,7 @@ int rcu_needs_cpu(int cpu)
  * access due to the fact that this CPU cannot possibly have any RCU
  * callbacks in flight yet.
  */
-static void
+static void __cpuinit
 rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
 {
         unsigned long flags;
diff --git a/kernel/relay.c b/kernel/relay.c
index 09ac2008f77b..8f2179c8056f 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -663,8 +663,10 @@ int relay_late_setup_files(struct rchan *chan,
 
         mutex_lock(&relay_channels_mutex);
         /* Is chan already set up? */
-        if (unlikely(chan->has_base_filename))
+        if (unlikely(chan->has_base_filename)) {
+                mutex_unlock(&relay_channels_mutex);
                 return -EEXIST;
+        }
         chan->has_base_filename = 1;
         chan->parent = parent;
         curr_cpu = get_cpu();
@@ -748,7 +750,7 @@ size_t relay_switch_subbuf(struct rchan_buf *buf, size_t length)
                          * from the scheduler (trying to re-grab
                          * rq->lock), so defer it.
                          */
-                        __mod_timer(&buf->timer, jiffies + 1);
+                        mod_timer(&buf->timer, jiffies + 1);
         }
 
         old = buf->data;
diff --git a/kernel/sched.c b/kernel/sched.c
index 52bbf1c842a8..9f8506d68fdc 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -223,7 +223,7 @@ static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
 {
         ktime_t now;
 
-        if (rt_bandwidth_enabled() && rt_b->rt_runtime == RUNTIME_INF)
+        if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
                 return;
 
         if (hrtimer_active(&rt_b->rt_period_timer))
@@ -331,6 +331,13 @@ static DEFINE_PER_CPU(struct rt_rq, init_rt_rq) ____cacheline_aligned_in_smp;
  */
 static DEFINE_SPINLOCK(task_group_lock);
 
+#ifdef CONFIG_SMP
+static int root_task_group_empty(void)
+{
+        return list_empty(&root_task_group.children);
+}
+#endif
+
 #ifdef CONFIG_FAIR_GROUP_SCHED
 #ifdef CONFIG_USER_SCHED
 # define INIT_TASK_GROUP_LOAD   (2*NICE_0_LOAD)
@@ -391,6 +398,13 @@ static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
 
 #else
 
+#ifdef CONFIG_SMP
+static int root_task_group_empty(void)
+{
+        return 1;
+}
+#endif
+
 static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
 static inline struct task_group *task_group(struct task_struct *p)
 {
@@ -467,11 +481,17 @@ struct rt_rq {
         struct rt_prio_array active;
         unsigned long rt_nr_running;
 #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
-        int highest_prio; /* highest queued rt task prio */
+        struct {
+                int curr; /* highest queued rt task prio */
+#ifdef CONFIG_SMP
+                int next; /* next highest */
+#endif
+        } highest_prio;
 #endif
 #ifdef CONFIG_SMP
         unsigned long rt_nr_migratory;
         int overloaded;
+        struct plist_head pushable_tasks;
 #endif
         int rt_throttled;
         u64 rt_time;
@@ -549,7 +569,6 @@ struct rq {
         unsigned long nr_running;
         #define CPU_LOAD_IDX_MAX 5
         unsigned long cpu_load[CPU_LOAD_IDX_MAX];
-        unsigned char idle_at_tick;
 #ifdef CONFIG_NO_HZ
         unsigned long last_tick_seen;
         unsigned char in_nohz_recently;
@@ -590,6 +609,7 @@ struct rq {
         struct root_domain *rd;
         struct sched_domain *sd;
 
+        unsigned char idle_at_tick;
         /* For active balancing */
         int active_balance;
         int push_cpu;
@@ -618,9 +638,6 @@ struct rq {
         /* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */
 
         /* sys_sched_yield() stats */
-        unsigned int yld_exp_empty;
-        unsigned int yld_act_empty;
-        unsigned int yld_both_empty;
         unsigned int yld_count;
 
         /* schedule() stats */
@@ -1183,10 +1200,10 @@ static void resched_task(struct task_struct *p)
 
         assert_spin_locked(&task_rq(p)->lock);
 
-        if (unlikely(test_tsk_thread_flag(p, TIF_NEED_RESCHED)))
+        if (test_tsk_need_resched(p))
                 return;
 
-        set_tsk_thread_flag(p, TIF_NEED_RESCHED);
+        set_tsk_need_resched(p);
 
         cpu = task_cpu(p);
         if (cpu == smp_processor_id())
@@ -1242,7 +1259,7 @@ void wake_up_idle_cpu(int cpu)
          * lockless. The worst case is that the other CPU runs the
          * idle task through an additional NOOP schedule()
          */
-        set_tsk_thread_flag(rq->idle, TIF_NEED_RESCHED);
+        set_tsk_need_resched(rq->idle);
 
         /* NEED_RESCHED must be visible before we test polling */
         smp_mb();
@@ -1610,21 +1627,42 @@ static inline void update_shares_locked(struct rq *rq, struct sched_domain *sd)
 
 #endif
 
+#ifdef CONFIG_PREEMPT
+
 /*
- * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
+ * fair double_lock_balance: Safely acquires both rq->locks in a fair
+ * way at the expense of forcing extra atomic operations in all
+ * invocations.  This assures that the double_lock is acquired using the
+ * same underlying policy as the spinlock_t on this architecture, which
+ * reduces latency compared to the unfair variant below.  However, it
+ * also adds more overhead and therefore may reduce throughput.
  */
-static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
+static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
+        __releases(this_rq->lock)
+        __acquires(busiest->lock)
+        __acquires(this_rq->lock)
+{
+        spin_unlock(&this_rq->lock);
+        double_rq_lock(this_rq, busiest);
+
+        return 1;
+}
+
+#else
+/*
+ * Unfair double_lock_balance: Optimizes throughput at the expense of
+ * latency by eliminating extra atomic operations when the locks are
+ * already in proper order on entry.  This favors lower cpu-ids and will
+ * grant the double lock to lower cpus over higher ids under contention,
+ * regardless of entry order into the function.
+ */
+static int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
         __releases(this_rq->lock)
         __acquires(busiest->lock)
         __acquires(this_rq->lock)
 {
         int ret = 0;
 
-        if (unlikely(!irqs_disabled())) {
-                /* printk() doesn't work good under rq->lock */
-                spin_unlock(&this_rq->lock);
-                BUG_ON(1);
-        }
         if (unlikely(!spin_trylock(&busiest->lock))) {
                 if (busiest < this_rq) {
                         spin_unlock(&this_rq->lock);
@@ -1637,6 +1675,22 @@ static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
         return ret;
 }
 
+#endif /* CONFIG_PREEMPT */
+
+/*
+ * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
+ */
+static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
+{
+        if (unlikely(!irqs_disabled())) {
+                /* printk() doesn't work good under rq->lock */
+                spin_unlock(&this_rq->lock);
+                BUG_ON(1);
+        }
+
+        return _double_lock_balance(this_rq, busiest);
+}
+
 static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
         __releases(busiest->lock)
 {
@@ -1705,6 +1759,9 @@ static void update_avg(u64 *avg, u64 sample)
 
 static void enqueue_task(struct rq *rq, struct task_struct *p, int wakeup)
 {
+        if (wakeup)
+                p->se.start_runtime = p->se.sum_exec_runtime;
+
         sched_info_queued(p);
         p->sched_class->enqueue_task(rq, p, wakeup);
         p->se.on_rq = 1;
@@ -1712,10 +1769,15 @@ static void enqueue_task(struct rq *rq, struct task_struct *p, int wakeup)
 
 static void dequeue_task(struct rq *rq, struct task_struct *p, int sleep)
 {
-        if (sleep && p->se.last_wakeup) {
-                update_avg(&p->se.avg_overlap,
-                           p->se.sum_exec_runtime - p->se.last_wakeup);
-                p->se.last_wakeup = 0;
+        if (sleep) {
+                if (p->se.last_wakeup) {
+                        update_avg(&p->se.avg_overlap,
+                                p->se.sum_exec_runtime - p->se.last_wakeup);
+                        p->se.last_wakeup = 0;
+                } else {
+                        update_avg(&p->se.avg_wakeup,
+                                sysctl_sched_wakeup_granularity);
+                }
         }
 
         sched_info_dequeued(p);
@@ -2017,7 +2079,7 @@ unsigned long wait_task_inactive(struct task_struct *p, long match_state)
                  * it must be off the runqueue _entirely_, and not
                  * preempted!
                  *
-                 * So if it wa still runnable (but just not actively
+                 * So if it was still runnable (but just not actively
                  * running right now), it's preempted, and we should
                  * yield - it could be a while.
                  */
@@ -2267,7 +2329,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
                 sync = 0;
 
 #ifdef CONFIG_SMP
-        if (sched_feat(LB_WAKEUP_UPDATE)) {
+        if (sched_feat(LB_WAKEUP_UPDATE) && !root_task_group_empty()) {
                 struct sched_domain *sd;
 
                 this_cpu = raw_smp_processor_id();
@@ -2345,6 +2407,22 @@ out_activate:
         activate_task(rq, p, 1);
         success = 1;
 
+        /*
+         * Only attribute actual wakeups done by this task.
+         */
+        if (!in_interrupt()) {
+                struct sched_entity *se = &current->se;
+                u64 sample = se->sum_exec_runtime;
+
+                if (se->last_wakeup)
+                        sample -= se->last_wakeup;
+                else
+                        sample -= se->start_runtime;
+                update_avg(&se->avg_wakeup, sample);
+
+                se->last_wakeup = se->sum_exec_runtime;
+        }
+
 out_running:
         trace_sched_wakeup(rq, p, success);
         check_preempt_curr(rq, p, sync);
@@ -2355,8 +2433,6 @@ out_running:
                 p->sched_class->task_wake_up(rq, p);
 #endif
 out:
-        current->se.last_wakeup = current->se.sum_exec_runtime;
-
         task_rq_unlock(rq, &flags);
 
         return success;
@@ -2386,6 +2462,8 @@ static void __sched_fork(struct task_struct *p)
         p->se.prev_sum_exec_runtime     = 0;
         p->se.last_wakeup               = 0;
         p->se.avg_overlap               = 0;
+        p->se.start_runtime             = 0;
+        p->se.avg_wakeup                = sysctl_sched_wakeup_granularity;
 
 #ifdef CONFIG_SCHEDSTATS
         p->se.wait_start                = 0;
@@ -2448,6 +2526,8 @@ void sched_fork(struct task_struct *p, int clone_flags)
         /* Want to start with kernel preemption disabled. */
         task_thread_info(p)->preempt_count = 1;
 #endif
+        plist_node_init(&p->pushable_tasks, MAX_PRIO);
+
         put_cpu();
 }
 
@@ -2491,7 +2571,7 @@ void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
 #ifdef CONFIG_PREEMPT_NOTIFIERS
 
 /**
- * preempt_notifier_register - tell me when current is being being preempted & rescheduled
+ * preempt_notifier_register - tell me when current is being preempted & rescheduled
  * @notifier: notifier struct to register
  */
 void preempt_notifier_register(struct preempt_notifier *notifier)
@@ -2588,6 +2668,12 @@ static void finish_task_switch(struct rq *rq, struct task_struct *prev)
 {
         struct mm_struct *mm = rq->prev_mm;
         long prev_state;
+#ifdef CONFIG_SMP
+        int post_schedule = 0;
+
+        if (current->sched_class->needs_post_schedule)
+                post_schedule = current->sched_class->needs_post_schedule(rq);
+#endif
 
         rq->prev_mm = NULL;
 
@@ -2606,7 +2692,7 @@ static void finish_task_switch(struct rq *rq, struct task_struct *prev)
         finish_arch_switch(prev);
         finish_lock_switch(rq, prev);
 #ifdef CONFIG_SMP
-        if (current->sched_class->post_schedule)
+        if (post_schedule)
                 current->sched_class->post_schedule(rq);
 #endif
 
@@ -2913,6 +2999,7 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
                      struct sched_domain *sd, enum cpu_idle_type idle,
                      int *all_pinned)
 {
+        int tsk_cache_hot = 0;
         /*
          * We do not migrate tasks that are:
          * 1) running (obviously), or
@@ -2936,10 +3023,11 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
          * 2) too many balance attempts have failed.
          */
 
-        if (!task_hot(p, rq->clock, sd) ||
-                        sd->nr_balance_failed > sd->cache_nice_tries) {
+        tsk_cache_hot = task_hot(p, rq->clock, sd);
+        if (!tsk_cache_hot ||
+                sd->nr_balance_failed > sd->cache_nice_tries) {
 #ifdef CONFIG_SCHEDSTATS
-                if (task_hot(p, rq->clock, sd)) {
+                if (tsk_cache_hot) {
                         schedstat_inc(sd, lb_hot_gained[idle]);
                         schedstat_inc(p, se.nr_forced_migrations);
                 }
@@ -2947,7 +3035,7 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
                 return 1;
         }
 
-        if (task_hot(p, rq->clock, sd)) {
+        if (tsk_cache_hot) {
                 schedstat_inc(p, se.nr_failed_migrations_hot);
                 return 0;
         }
@@ -2987,6 +3075,16 @@ next:
         pulled++;
         rem_load_move -= p->se.load.weight;
 
+#ifdef CONFIG_PREEMPT
+        /*
+         * NEWIDLE balancing is a source of latency, so preemptible kernels
+         * will stop after the first task is pulled to minimize the critical
+         * section.
+         */
+        if (idle == CPU_NEWLY_IDLE)
+                goto out;
+#endif
+
         /*
          * We only want to steal up to the prescribed amount of weighted load.
          */
@@ -3033,9 +3131,15 @@ static int move_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest,
                                 sd, idle, all_pinned, &this_best_prio);
                 class = class->next;
 
+#ifdef CONFIG_PREEMPT
+                /*
+                 * NEWIDLE balancing is a source of latency, so preemptible
+                 * kernels will stop after the first task is pulled to minimize
+                 * the critical section.
+                 */
                 if (idle == CPU_NEWLY_IDLE && this_rq->nr_running)
                         break;
-
+#endif
         } while (class && max_load_move > total_load_moved);
 
         return total_load_moved > 0;
@@ -3085,246 +3189,479 @@ static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
 
         return 0;
 }
+/********** Helpers for find_busiest_group ************************/
+/**
+ * sd_lb_stats - Structure to store the statistics of a sched_domain
+ *              during load balancing.
+ */
+struct sd_lb_stats {
+        struct sched_group *busiest; /* Busiest group in this sd */
+        struct sched_group *this;  /* Local group in this sd */
+        unsigned long total_load;  /* Total load of all groups in sd */
+        unsigned long total_pwr;   /*   Total power of all groups in sd */
+        unsigned long avg_load;    /* Average load across all groups in sd */
+
+        /** Statistics of this group */
+        unsigned long this_load;
+        unsigned long this_load_per_task;
+        unsigned long this_nr_running;
+
+        /* Statistics of the busiest group */
+        unsigned long max_load;
+        unsigned long busiest_load_per_task;
+        unsigned long busiest_nr_running;
+
+        int group_imb; /* Is there imbalance in this sd */
+#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
+        int power_savings_balance; /* Is powersave balance needed for this sd */
+        struct sched_group *group_min; /* Least loaded group in sd */
+        struct sched_group *group_leader; /* Group which relieves group_min */
+        unsigned long min_load_per_task; /* load_per_task in group_min */
+        unsigned long leader_nr_running; /* Nr running of group_leader */
+        unsigned long min_nr_running; /* Nr running of group_min */
+#endif
+};
 
-/*
- * find_busiest_group finds and returns the busiest CPU group within the
- * domain. It calculates and returns the amount of weighted load which
- * should be moved to restore balance via the imbalance parameter.
+/**
+ * sg_lb_stats - stats of a sched_group required for load_balancing
+ */
+struct sg_lb_stats {
+        unsigned long avg_load; /*Avg load across the CPUs of the group */
+        unsigned long group_load; /* Total load over the CPUs of the group */
+        unsigned long sum_nr_running; /* Nr tasks running in the group */
+        unsigned long sum_weighted_load; /* Weighted load of group's tasks */
+        unsigned long group_capacity;
+        int group_imb; /* Is there an imbalance in the group ? */
+};
+
+/**
+ * group_first_cpu - Returns the first cpu in the cpumask of a sched_group.
+ * @group: The group whose first cpu is to be returned.
  */
-static struct sched_group *
-find_busiest_group(struct sched_domain *sd, int this_cpu,
-                   unsigned long *imbalance, enum cpu_idle_type idle,
-                   int *sd_idle, const struct cpumask *cpus, int *balance)
+static inline unsigned int group_first_cpu(struct sched_group *group)
 {
-        struct sched_group *busiest = NULL, *this = NULL, *group = sd->groups;
-        unsigned long max_load, avg_load, total_load, this_load, total_pwr;
-        unsigned long max_pull;
-        unsigned long busiest_load_per_task, busiest_nr_running;
-        unsigned long this_load_per_task, this_nr_running;
-        int load_idx, group_imb = 0;
-#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
-        int power_savings_balance = 1;
-        unsigned long leader_nr_running = 0, min_load_per_task = 0;
-        unsigned long min_nr_running = ULONG_MAX;
-        struct sched_group *group_min = NULL, *group_leader = NULL;
-#endif
+        return cpumask_first(sched_group_cpus(group));
+}
 
-        max_load = this_load = total_load = total_pwr = 0;
-        busiest_load_per_task = busiest_nr_running = 0;
-        this_load_per_task = this_nr_running = 0;
+/**
+ * get_sd_load_idx - Obtain the load index for a given sched domain.
+ * @sd: The sched_domain whose load_idx is to be obtained.
+ * @idle: The Idle status of the CPU for whose sd load_icx is obtained.
+ */
+static inline int get_sd_load_idx(struct sched_domain *sd,
+                                        enum cpu_idle_type idle)
+{
+        int load_idx;
 
-        if (idle == CPU_NOT_IDLE)
+        switch (idle) {
+        case CPU_NOT_IDLE:
                 load_idx = sd->busy_idx;
-        else if (idle == CPU_NEWLY_IDLE)
+                break;
+
+        case CPU_NEWLY_IDLE:
                 load_idx = sd->newidle_idx;
-        else
+                break;
+        default:
                 load_idx = sd->idle_idx;
+                break;
+        }
 
-        do {
-                unsigned long load, group_capacity, max_cpu_load, min_cpu_load;
-                int local_group;
-                int i;
-                int __group_imb = 0;
-                unsigned int balance_cpu = -1, first_idle_cpu = 0;
-                unsigned long sum_nr_running, sum_weighted_load;
-                unsigned long sum_avg_load_per_task;
-                unsigned long avg_load_per_task;
+        return load_idx;
+}
 
-                local_group = cpumask_test_cpu(this_cpu,
-                                               sched_group_cpus(group));
 
-                if (local_group)
-                        balance_cpu = cpumask_first(sched_group_cpus(group));
+#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
+/**
+ * init_sd_power_savings_stats - Initialize power savings statistics for
+ * the given sched_domain, during load balancing.
+ *
+ * @sd: Sched domain whose power-savings statistics are to be initialized.
+ * @sds: Variable containing the statistics for sd.
+ * @idle: Idle status of the CPU at which we're performing load-balancing.
+ */
+static inline void init_sd_power_savings_stats(struct sched_domain *sd,
+        struct sd_lb_stats *sds, enum cpu_idle_type idle)
+{
+        /*
+         * Busy processors will not participate in power savings
+         * balance.
+         */
+        if (idle == CPU_NOT_IDLE || !(sd->flags & SD_POWERSAVINGS_BALANCE))
+                sds->power_savings_balance = 0;
+        else {
+                sds->power_savings_balance = 1;
+                sds->min_nr_running = ULONG_MAX;
+                sds->leader_nr_running = 0;
+        }
+}
 
-                /* Tally up the load of all CPUs in the group */
-                sum_weighted_load = sum_nr_running = avg_load = 0;
-                sum_avg_load_per_task = avg_load_per_task = 0;
+/**
+ * update_sd_power_savings_stats - Update the power saving stats for a
+ * sched_domain while performing load balancing.
+ *
+ * @group: sched_group belonging to the sched_domain under consideration.
+ * @sds: Variable containing the statistics of the sched_domain
+ * @local_group: Does group contain the CPU for which we're performing
+ *              load balancing ?
+ * @sgs: Variable containing the statistics of the group.
+ */
+static inline void update_sd_power_savings_stats(struct sched_group *group,
+        struct sd_lb_stats *sds, int local_group, struct sg_lb_stats *sgs)
+{
 
-                max_cpu_load = 0;
-                min_cpu_load = ~0UL;
+        if (!sds->power_savings_balance)
+                return;
 
-                for_each_cpu_and(i, sched_group_cpus(group), cpus) {
-                        struct rq *rq = cpu_rq(i);
+        /*
+         * If the local group is idle or completely loaded
+         * no need to do power savings balance at this domain
+         */
+        if (local_group && (sds->this_nr_running >= sgs->group_capacity ||
+                                !sds->this_nr_running))
+                sds->power_savings_balance = 0;
+
+        /*
+         * If a group is already running at full capacity or idle,
+         * don't include that group in power savings calculations
+         */
+        if (!sds->power_savings_balance ||
+                sgs->sum_nr_running >= sgs->group_capacity ||
+                !sgs->sum_nr_running)
+                return;
 
-                        if (*sd_idle && rq->nr_running)
-                                *sd_idle = 0;
+        /*
+         * Calculate the group which has the least non-idle load.
+         * This is the group from where we need to pick up the load
+         * for saving power
+         */
+        if ((sgs->sum_nr_running < sds->min_nr_running) ||
+            (sgs->sum_nr_running == sds->min_nr_running &&
+             group_first_cpu(group) > group_first_cpu(sds->group_min))) {
+                sds->group_min = group;
+                sds->min_nr_running = sgs->sum_nr_running;
+                sds->min_load_per_task = sgs->sum_weighted_load /
+                                                sgs->sum_nr_running;
+        }
 
-                        /* Bias balancing toward cpus of our domain */
-                        if (local_group) {
-                                if (idle_cpu(i) && !first_idle_cpu) {
-                                        first_idle_cpu = 1;
-                                        balance_cpu = i;
-                                }
+        /*
+         * Calculate the group which is almost near its
+         * capacity but still has some space to pick up some load
+         * from other group and save more power
+         */
+        if (sgs->sum_nr_running > sgs->group_capacity - 1)
+                return;
 
-                                load = target_load(i, load_idx);
-                        } else {
-                                load = source_load(i, load_idx);
-                                if (load > max_cpu_load)
-                                        max_cpu_load = load;
-                                if (min_cpu_load > load)
-                                        min_cpu_load = load;
-                        }
+        if (sgs->sum_nr_running > sds->leader_nr_running ||
+            (sgs->sum_nr_running == sds->leader_nr_running &&
+             group_first_cpu(group) < group_first_cpu(sds->group_leader))) {
+                sds->group_leader = group;
+                sds->leader_nr_running = sgs->sum_nr_running;
+        }
+}
 
-                        avg_load += load;
-                        sum_nr_running += rq->nr_running;
-                        sum_weighted_load += weighted_cpuload(i);
+/**
+ * check_power_save_busiest_group - Check if we have potential to perform
+ *      some power-savings balance. If yes, set the busiest group to be
+ *      the least loaded group in the sched_domain, so that it's CPUs can
+ *      be put to idle.
+ *
+ * @sds: Variable containing the statistics of the sched_domain
+ *      under consideration.
+ * @this_cpu: Cpu at which we're currently performing load-balancing.
+ * @imbalance: Variable to store the imbalance.
+ *
+ * Returns 1 if there is potential to perform power-savings balance.
+ * Else returns 0.
+ */
+static inline int check_power_save_busiest_group(struct sd_lb_stats *sds,
+                                        int this_cpu, unsigned long *imbalance)
+{
+        if (!sds->power_savings_balance)
+                return 0;
 
-                        sum_avg_load_per_task += cpu_avg_load_per_task(i);
-                }
+        if (sds->this != sds->group_leader ||
+                        sds->group_leader == sds->group_min)
+                return 0;
 
-                /*
-                 * First idle cpu or the first cpu(busiest) in this sched group
-                 * is eligible for doing load balancing at this and above
-                 * domains. In the newly idle case, we will allow all the cpu's
-                 * to do the newly idle load balance.
-                 */
-                if (idle != CPU_NEWLY_IDLE && local_group &&
-                    balance_cpu != this_cpu && balance) {
-                        *balance = 0;
-                        goto ret;
-                }
+        *imbalance = sds->min_load_per_task;
+        sds->busiest = sds->group_min;
 
-                total_load += avg_load;
-                total_pwr += group->__cpu_power;
+        if (sched_mc_power_savings >= POWERSAVINGS_BALANCE_WAKEUP) {
+                cpu_rq(this_cpu)->rd->sched_mc_preferred_wakeup_cpu =
+                        group_first_cpu(sds->group_leader);
+        }
 
-                /* Adjust by relative CPU power of the group */
-                avg_load = sg_div_cpu_power(group,
-                                avg_load * SCHED_LOAD_SCALE);
+        return 1;
 
+}
+#else /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
+static inline void init_sd_power_savings_stats(struct sched_domain *sd,
+        struct sd_lb_stats *sds, enum cpu_idle_type idle)
+{
+        return;
+}
 
-                /*
-                 * Consider the group unbalanced when the imbalance is larger
-                 * than the average weight of two tasks.
-                 *
-                 * APZ: with cgroup the avg task weight can vary wildly and
-                 *      might not be a suitable number - should we keep a
-                 *      normalized nr_running number somewhere that negates
-                 *      the hierarchy?
-                 */
-                avg_load_per_task = sg_div_cpu_power(group,
-                                sum_avg_load_per_task * SCHED_LOAD_SCALE);
+static inline void update_sd_power_savings_stats(struct sched_group *group,
+        struct sd_lb_stats *sds, int local_group, struct sg_lb_stats *sgs)
+{
+        return;
+}
 
-                if ((max_cpu_load - min_cpu_load) > 2*avg_load_per_task)
-                        __group_imb = 1;
+static inline int check_power_save_busiest_group(struct sd_lb_stats *sds,
+                                        int this_cpu, unsigned long *imbalance)
+{
+        return 0;
+}
+#endif /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
 
-                group_capacity = group->__cpu_power / SCHED_LOAD_SCALE;
 
+/**
+ * update_sg_lb_stats - Update sched_group's statistics for load balancing.
+ * @group: sched_group whose statistics are to be updated.
+ * @this_cpu: Cpu for which load balance is currently performed.
+ * @idle: Idle status of this_cpu
+ * @load_idx: Load index of sched_domain of this_cpu for load calc.
+ * @sd_idle: Idle status of the sched_domain containing group.
+ * @local_group: Does group contain this_cpu.
+ * @cpus: Set of cpus considered for load balancing.
+ * @balance: Should we balance.
+ * @sgs: variable to hold the statistics for this group.
+ */
+static inline void update_sg_lb_stats(struct sched_group *group, int this_cpu,
+                        enum cpu_idle_type idle, int load_idx, int *sd_idle,
+                        int local_group, const struct cpumask *cpus,
+                        int *balance, struct sg_lb_stats *sgs)
+{
+        unsigned long load, max_cpu_load, min_cpu_load;
+        int i;
+        unsigned int balance_cpu = -1, first_idle_cpu = 0;
+        unsigned long sum_avg_load_per_task;
+        unsigned long avg_load_per_task;
+
+        if (local_group)
+                balance_cpu = group_first_cpu(group);
+
+        /* Tally up the load of all CPUs in the group */
+        sum_avg_load_per_task = avg_load_per_task = 0;
+        max_cpu_load = 0;
+        min_cpu_load = ~0UL;
+
+        for_each_cpu_and(i, sched_group_cpus(group), cpus) {
+                struct rq *rq = cpu_rq(i);
+
+                if (*sd_idle && rq->nr_running)
+                        *sd_idle = 0;
+
+                /* Bias balancing toward cpus of our domain */
                 if (local_group) {
-                        this_load = avg_load;
-                        this = group;
-                        this_nr_running = sum_nr_running;
-                        this_load_per_task = sum_weighted_load;
-                } else if (avg_load > max_load &&
-                           (sum_nr_running > group_capacity || __group_imb)) {
-                        max_load = avg_load;
-                        busiest = group;
-                        busiest_nr_running = sum_nr_running;
-                        busiest_load_per_task = sum_weighted_load;
-                        group_imb = __group_imb;
+                        if (idle_cpu(i) && !first_idle_cpu) {
+                                first_idle_cpu = 1;
+                                balance_cpu = i;
+                        }
+
+                        load = target_load(i, load_idx);
+                } else {
+                        load = source_load(i, load_idx);
+                        if (load > max_cpu_load)
+                                max_cpu_load = load;
+                        if (min_cpu_load > load)
+                                min_cpu_load = load;
                 }
 
-#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
-                /*
-                 * Busy processors will not participate in power savings
-                 * balance.
-                 */
-                if (idle == CPU_NOT_IDLE ||
-                                !(sd->flags & SD_POWERSAVINGS_BALANCE))
-                        goto group_next;
+                sgs->group_load += load;
+                sgs->sum_nr_running += rq->nr_running;
+                sgs->sum_weighted_load += weighted_cpuload(i);
 
-                /*
-                 * If the local group is idle or completely loaded
-                 * no need to do power savings balance at this domain
-                 */
-                if (local_group && (this_nr_running >= group_capacity ||
-                                    !this_nr_running))
-                        power_savings_balance = 0;
+                sum_avg_load_per_task += cpu_avg_load_per_task(i);
+        }
 
-                /*
-                 * If a group is already running at full capacity or idle,
-                 * don't include that group in power savings calculations
-                 */
-                if (!power_savings_balance || sum_nr_running >= group_capacity
-                    || !sum_nr_running)
-                        goto group_next;
+        /*
+         * First idle cpu or the first cpu(busiest) in this sched group
+         * is eligible for doing load balancing at this and above
+         * domains. In the newly idle case, we will allow all the cpu's
+         * to do the newly idle load balance.
+         */
+        if (idle != CPU_NEWLY_IDLE && local_group &&
+            balance_cpu != this_cpu && balance) {
+                *balance = 0;
+                return;
+        }
 
-                /*
-                 * Calculate the group which has the least non-idle load.
-                 * This is the group from where we need to pick up the load
-                 * for saving power
-                 */
-                if ((sum_nr_running < min_nr_running) ||
-                    (sum_nr_running == min_nr_running &&
-                     cpumask_first(sched_group_cpus(group)) >
-                     cpumask_first(sched_group_cpus(group_min)))) {
-                        group_min = group;
-                        min_nr_running = sum_nr_running;
-                        min_load_per_task = sum_weighted_load /
-                                                sum_nr_running;
-                }
+        /* Adjust by relative CPU power of the group */
+        sgs->avg_load = sg_div_cpu_power(group,
+                        sgs->group_load * SCHED_LOAD_SCALE);
 
-                /*
-                 * Calculate the group which is almost near its
-                 * capacity but still has some space to pick up some load
-                 * from other group and save more power
-                 */
-                if (sum_nr_running <= group_capacity - 1) {
-                        if (sum_nr_running > leader_nr_running ||
-                            (sum_nr_running == leader_nr_running &&
-                             cpumask_first(sched_group_cpus(group)) <
-                             cpumask_first(sched_group_cpus(group_leader)))) {
-                                group_leader = group;
-                                leader_nr_running = sum_nr_running;
-                        }
+
+        /*
+         * Consider the group unbalanced when the imbalance is larger
+         * than the average weight of two tasks.
+         *
+         * APZ: with cgroup the avg task weight can vary wildly and
+         *      might not be a suitable number - should we keep a
+         *      normalized nr_running number somewhere that negates
+         *      the hierarchy?
+         */
+        avg_load_per_task = sg_div_cpu_power(group,
+                        sum_avg_load_per_task * SCHED_LOAD_SCALE);
+
+        if ((max_cpu_load - min_cpu_load) > 2*avg_load_per_task)
+                sgs->group_imb = 1;
+
+        sgs->group_capacity = group->__cpu_power / SCHED_LOAD_SCALE;
+
+}
+
+/**
+ * update_sd_lb_stats - Update sched_group's statistics for load balancing.
+ * @sd: sched_domain whose statistics are to be updated.
+ * @this_cpu: Cpu for which load balance is currently performed.
+ * @idle: Idle status of this_cpu
+ * @sd_idle: Idle status of the sched_domain containing group.
+ * @cpus: Set of cpus considered for load balancing.
+ * @balance: Should we balance.
+ * @sds: variable to hold the statistics for this sched_domain.
+ */
+static inline void update_sd_lb_stats(struct sched_domain *sd, int this_cpu,
+                        enum cpu_idle_type idle, int *sd_idle,
+                        const struct cpumask *cpus, int *balance,
+                        struct sd_lb_stats *sds)
+{
+        struct sched_group *group = sd->groups;
+        struct sg_lb_stats sgs;
+        int load_idx;
+
+        init_sd_power_savings_stats(sd, sds, idle);
+        load_idx = get_sd_load_idx(sd, idle);
+
+        do {
+                int local_group;
+
+                local_group = cpumask_test_cpu(this_cpu,
+                                               sched_group_cpus(group));
+                memset(&sgs, 0, sizeof(sgs));
+                update_sg_lb_stats(group, this_cpu, idle, load_idx, sd_idle,
+                                local_group, cpus, balance, &sgs);
+
+                if (local_group && balance && !(*balance))
+                        return;
+
+                sds->total_load += sgs.group_load;
+                sds->total_pwr += group->__cpu_power;
+
+                if (local_group) {
+                        sds->this_load = sgs.avg_load;
+                        sds->this = group;
+                        sds->this_nr_running = sgs.sum_nr_running;
+                        sds->this_load_per_task = sgs.sum_weighted_load;
+                } else if (sgs.avg_load > sds->max_load &&
+                           (sgs.sum_nr_running > sgs.group_capacity ||
+                                sgs.group_imb)) {
+                        sds->max_load = sgs.avg_load;
+                        sds->busiest = group;
+                        sds->busiest_nr_running = sgs.sum_nr_running;
+                        sds->busiest_load_per_task = sgs.sum_weighted_load;
+                        sds->group_imb = sgs.group_imb;
                 }
-group_next:
-#endif
+
+                update_sd_power_savings_stats(group, sds, local_group, &sgs);
                 group = group->next;
         } while (group != sd->groups);
 
-        if (!busiest || this_load >= max_load || busiest_nr_running == 0)
-                goto out_balanced;
-
-        avg_load = (SCHED_LOAD_SCALE * total_load) / total_pwr;
+}
 
-        if (this_load >= avg_load ||
-                        100*max_load <= sd->imbalance_pct*this_load)
-                goto out_balanced;
+/**
+ * fix_small_imbalance - Calculate the minor imbalance that exists
+ *                      amongst the groups of a sched_domain, during
+ *                      load balancing.
+ * @sds: Statistics of the sched_domain whose imbalance is to be calculated.
+ * @this_cpu: The cpu at whose sched_domain we're performing load-balance.
+ * @imbalance: Variable to store the imbalance.
+ */
+static inline void fix_small_imbalance(struct sd_lb_stats *sds,
+                                int this_cpu, unsigned long *imbalance)
+{
+        unsigned long tmp, pwr_now = 0, pwr_move = 0;
+        unsigned int imbn = 2;
+
+        if (sds->this_nr_running) {
+                sds->this_load_per_task /= sds->this_nr_running;
+                if (sds->busiest_load_per_task >
+                                sds->this_load_per_task)
+                        imbn = 1;
+        } else
+                sds->this_load_per_task =
+                        cpu_avg_load_per_task(this_cpu);
 
-        busiest_load_per_task /= busiest_nr_running;
-        if (group_imb)
-                busiest_load_per_task = min(busiest_load_per_task, avg_load);
+        if (sds->max_load - sds->this_load + sds->busiest_load_per_task >=
+                        sds->busiest_load_per_task * imbn) {
+                *imbalance = sds->busiest_load_per_task;
+                return;
+        }
 
         /*
-         * We're trying to get all the cpus to the average_load, so we don't
-         * want to push ourselves above the average load, nor do we wish to
-         * reduce the max loaded cpu below the average load, as either of these
-         * actions would just result in more rebalancing later, and ping-pong
-         * tasks around. Thus we look for the minimum possible imbalance.
-         * Negative imbalances (*we* are more loaded than anyone else) will
-         * be counted as no imbalance for these purposes -- we can't fix that
-         * by pulling tasks to us. Be careful of negative numbers as they'll
-         * appear as very large values with unsigned longs.
+         * OK, we don't have enough imbalance to justify moving tasks,
+         * however we may be able to increase total CPU power used by
+         * moving them.
          */
-        if (max_load <= busiest_load_per_task)
-                goto out_balanced;
 
+        pwr_now += sds->busiest->__cpu_power *
+                        min(sds->busiest_load_per_task, sds->max_load);
+        pwr_now += sds->this->__cpu_power *
+                        min(sds->this_load_per_task, sds->this_load);
+        pwr_now /= SCHED_LOAD_SCALE;
+
+        /* Amount of load we'd subtract */
+        tmp = sg_div_cpu_power(sds->busiest,
+                        sds->busiest_load_per_task * SCHED_LOAD_SCALE);
+        if (sds->max_load > tmp)
+                pwr_move += sds->busiest->__cpu_power *
+                        min(sds->busiest_load_per_task, sds->max_load - tmp);
+
+        /* Amount of load we'd add */
+        if (sds->max_load * sds->busiest->__cpu_power <
+                sds->busiest_load_per_task * SCHED_LOAD_SCALE)
+                tmp = sg_div_cpu_power(sds->this,
+                        sds->max_load * sds->busiest->__cpu_power);
+        else
+                tmp = sg_div_cpu_power(sds->this,
+                        sds->busiest_load_per_task * SCHED_LOAD_SCALE);
+        pwr_move += sds->this->__cpu_power *
+                        min(sds->this_load_per_task, sds->this_load + tmp);
+        pwr_move /= SCHED_LOAD_SCALE;
+
+        /* Move if we gain throughput */
+        if (pwr_move > pwr_now)
+                *imbalance = sds->busiest_load_per_task;
+}
+
+/**
+ * calculate_imbalance - Calculate the amount of imbalance present within the
+ *                       groups of a given sched_domain during load balance.
+ * @sds: statistics of the sched_domain whose imbalance is to be calculated.
+ * @this_cpu: Cpu for which currently load balance is being performed.
+ * @imbalance: The variable to store the imbalance.
+ */
+static inline void calculate_imbalance(struct sd_lb_stats *sds, int this_cpu,
+                unsigned long *imbalance)
+{
+        unsigned long max_pull;
         /*
          * In the presence of smp nice balancing, certain scenarios can have
          * max load less than avg load(as we skip the groups at or below
          * its cpu_power, while calculating max_load..)
          */
-        if (max_load < avg_load) {
+        if (sds->max_load < sds->avg_load) {
                 *imbalance = 0;
-                goto small_imbalance;
+                return fix_small_imbalance(sds, this_cpu, imbalance);
         }
 
         /* Don't want to pull so many tasks that a group would go idle */
-        max_pull = min(max_load - avg_load, max_load - busiest_load_per_task);
+        max_pull = min(sds->max_load - sds->avg_load,
+                        sds->max_load - sds->busiest_load_per_task);
 
         /* How much load to actually move to equalise the imbalance */
-        *imbalance = min(max_pull * busiest->__cpu_power,
-                                (avg_load - this_load) * this->__cpu_power)
+        *imbalance = min(max_pull * sds->busiest->__cpu_power,
+                (sds->avg_load - sds->this_load) * sds->this->__cpu_power)
                         / SCHED_LOAD_SCALE;
 
         /*
@@ -3333,78 +3670,110 @@ group_next:
          * a think about bumping its value to force at least one task to be
          * moved
          */
-        if (*imbalance < busiest_load_per_task) {
-                unsigned long tmp, pwr_now, pwr_move;
-                unsigned int imbn;
-
-small_imbalance:
-                pwr_move = pwr_now = 0;
-                imbn = 2;
-                if (this_nr_running) {
-                        this_load_per_task /= this_nr_running;
-                        if (busiest_load_per_task > this_load_per_task)
-                                imbn = 1;
-                } else
-                        this_load_per_task = cpu_avg_load_per_task(this_cpu);
+        if (*imbalance < sds->busiest_load_per_task)
+                return fix_small_imbalance(sds, this_cpu, imbalance);
 
-                if (max_load - this_load + busiest_load_per_task >=
-                                        busiest_load_per_task * imbn) {
-                        *imbalance = busiest_load_per_task;
-                        return busiest;
-                }
+}
+/******* find_busiest_group() helpers end here *********************/
 
-                /*
-                 * OK, we don't have enough imbalance to justify moving tasks,
-                 * however we may be able to increase total CPU power used by
-                 * moving them.
-                 */
+/**
+ * find_busiest_group - Returns the busiest group within the sched_domain
+ * if there is an imbalance. If there isn't an imbalance, and
+ * the user has opted for power-savings, it returns a group whose
+ * CPUs can be put to idle by rebalancing those tasks elsewhere, if
+ * such a group exists.
+ *
+ * Also calculates the amount of weighted load which should be moved
+ * to restore balance.
+ *
+ * @sd: The sched_domain whose busiest group is to be returned.
+ * @this_cpu: The cpu for which load balancing is currently being performed.
+ * @imbalance: Variable which stores amount of weighted load which should
+ *              be moved to restore balance/put a group to idle.
+ * @idle: The idle status of this_cpu.
+ * @sd_idle: The idleness of sd
+ * @cpus: The set of CPUs under consideration for load-balancing.
+ * @balance: Pointer to a variable indicating if this_cpu
+ *      is the appropriate cpu to perform load balancing at this_level.
+ *
+ * Returns:     - the busiest group if imbalance exists.
+ *              - If no imbalance and user has opted for power-savings balance,
+ *                 return the least loaded group whose CPUs can be
+ *                 put to idle by rebalancing its tasks onto our group.
+ */
+static struct sched_group *
+find_busiest_group(struct sched_domain *sd, int this_cpu,
+                   unsigned long *imbalance, enum cpu_idle_type idle,
+                   int *sd_idle, const struct cpumask *cpus, int *balance)
+{
+        struct sd_lb_stats sds;
 
-                pwr_now += busiest->__cpu_power *
-                                min(busiest_load_per_task, max_load);
-                pwr_now += this->__cpu_power *
-                                min(this_load_per_task, this_load);
-                pwr_now /= SCHED_LOAD_SCALE;
-
-                /* Amount of load we'd subtract */
-                tmp = sg_div_cpu_power(busiest,
-                                busiest_load_per_task * SCHED_LOAD_SCALE);
-                if (max_load > tmp)
-                        pwr_move += busiest->__cpu_power *
-                                min(busiest_load_per_task, max_load - tmp);
-
-                /* Amount of load we'd add */
-                if (max_load * busiest->__cpu_power <
-                                busiest_load_per_task * SCHED_LOAD_SCALE)
-                        tmp = sg_div_cpu_power(this,
-                                        max_load * busiest->__cpu_power);
-                else
-                        tmp = sg_div_cpu_power(this,
-                                busiest_load_per_task * SCHED_LOAD_SCALE);
-                pwr_move += this->__cpu_power *
-                                min(this_load_per_task, this_load + tmp);
-                pwr_move /= SCHED_LOAD_SCALE;
+        memset(&sds, 0, sizeof(sds));
 
-                /* Move if we gain throughput */
-                if (pwr_move > pwr_now)
-                        *imbalance = busiest_load_per_task;
-        }
+        /*
+         * Compute the various statistics relavent for load balancing at
+         * this level.
+         */
+        update_sd_lb_stats(sd, this_cpu, idle, sd_idle, cpus,
+                                        balance, &sds);
+
+        /* Cases where imbalance does not exist from POV of this_cpu */
+        /* 1) this_cpu is not the appropriate cpu to perform load balancing
+         *    at this level.
+         * 2) There is no busy sibling group to pull from.
+         * 3) This group is the busiest group.
+         * 4) This group is more busy than the avg busieness at this
+         *    sched_domain.
+         * 5) The imbalance is within the specified limit.
+         * 6) Any rebalance would lead to ping-pong
+         */
+        if (balance && !(*balance))
+                goto ret;
 
-        return busiest;
+        if (!sds.busiest || sds.busiest_nr_running == 0)
+                goto out_balanced;
 
-out_balanced:
-#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
-        if (idle == CPU_NOT_IDLE || !(sd->flags & SD_POWERSAVINGS_BALANCE))
-                goto ret;
+        if (sds.this_load >= sds.max_load)
+                goto out_balanced;
 
-        if (this == group_leader && group_leader != group_min) {
-                *imbalance = min_load_per_task;
-                if (sched_mc_power_savings >= POWERSAVINGS_BALANCE_WAKEUP) {
-                        cpu_rq(this_cpu)->rd->sched_mc_preferred_wakeup_cpu =
-                                cpumask_first(sched_group_cpus(group_leader));
-                }
-                return group_min;
-        }
-#endif
+        sds.avg_load = (SCHED_LOAD_SCALE * sds.total_load) / sds.total_pwr;
+
+        if (sds.this_load >= sds.avg_load)
+                goto out_balanced;
+
+        if (100 * sds.max_load <= sd->imbalance_pct * sds.this_load)
+                goto out_balanced;
+
+        sds.busiest_load_per_task /= sds.busiest_nr_running;
+        if (sds.group_imb)
+                sds.busiest_load_per_task =
+                        min(sds.busiest_load_per_task, sds.avg_load);
+
+        /*
+         * We're trying to get all the cpus to the average_load, so we don't
+         * want to push ourselves above the average load, nor do we wish to
+         * reduce the max loaded cpu below the average load, as either of these
+         * actions would just result in more rebalancing later, and ping-pong
+         * tasks around. Thus we look for the minimum possible imbalance.
+         * Negative imbalances (*we* are more loaded than anyone else) will
+         * be counted as no imbalance for these purposes -- we can't fix that
+         * by pulling tasks to us. Be careful of negative numbers as they'll
+         * appear as very large values with unsigned longs.
+         */
+        if (sds.max_load <= sds.busiest_load_per_task)
+                goto out_balanced;
+
+        /* Looks like there is an imbalance. Compute it */
+        calculate_imbalance(&sds, this_cpu, imbalance);
+        return sds.busiest;
+
+out_balanced:
+        /*
+         * There is no obvious imbalance. But check if we can do some balancing
+         * to save power.
+         */
+        if (check_power_save_busiest_group(&sds, this_cpu, imbalance))
+                return sds.busiest;
 ret:
         *imbalance = 0;
         return NULL;
@@ -3880,19 +4249,24 @@ int select_nohz_load_balancer(int stop_tick)
         int cpu = smp_processor_id();
 
         if (stop_tick) {
-                cpumask_set_cpu(cpu, nohz.cpu_mask);
                 cpu_rq(cpu)->in_nohz_recently = 1;
 
-                /*
-                 * If we are going offline and still the leader, give up!
-                 */
-                if (!cpu_active(cpu) &&
-                    atomic_read(&nohz.load_balancer) == cpu) {
+                if (!cpu_active(cpu)) {
+                        if (atomic_read(&nohz.load_balancer) != cpu)
+                                return 0;
+
+                        /*
+                         * If we are going offline and still the leader,
+                         * give up!
+                         */
                         if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
                                 BUG();
+
                         return 0;
                 }
 
+                cpumask_set_cpu(cpu, nohz.cpu_mask);
+
                 /* time for ilb owner also to sleep */
                 if (cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                         if (atomic_read(&nohz.load_balancer) == cpu)
@@ -4052,6 +4426,11 @@ static void run_rebalance_domains(struct softirq_action *h)
 #endif
 }
 
+static inline int on_null_domain(int cpu)
+{
+        return !rcu_dereference(cpu_rq(cpu)->sd);
+}
+
 /*
  * Trigger the SCHED_SOFTIRQ if it is time to do periodic load balancing.
  *
@@ -4109,7 +4488,9 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
             cpumask_test_cpu(cpu, nohz.cpu_mask))
                 return;
 #endif
-        if (time_after_eq(jiffies, rq->next_balance))
+        /* Don't need to rebalance while attached to NULL domain */
+        if (time_after_eq(jiffies, rq->next_balance) &&
+            likely(!on_null_domain(cpu)))
                 raise_softirq(SCHED_SOFTIRQ);
 }
 
@@ -4503,11 +4884,33 @@ static inline void schedule_debug(struct task_struct *prev)
 #endif
 }
 
+static void put_prev_task(struct rq *rq, struct task_struct *prev)
+{
+        if (prev->state == TASK_RUNNING) {
+                u64 runtime = prev->se.sum_exec_runtime;
+
+                runtime -= prev->se.prev_sum_exec_runtime;
+                runtime = min_t(u64, runtime, 2*sysctl_sched_migration_cost);
+
+                /*
+                 * In order to avoid avg_overlap growing stale when we are
+                 * indeed overlapping and hence not getting put to sleep, grow
+                 * the avg_overlap on preemption.
+                 *
+                 * We use the average preemption runtime because that
+                 * correlates to the amount of cache footprint a task can
+                 * build up.
+                 */
+                update_avg(&prev->se.avg_overlap, runtime);
+        }
+        prev->sched_class->put_prev_task(rq, prev);
+}
+
 /*
  * Pick up the highest-prio task:
  */
 static inline struct task_struct *
-pick_next_task(struct rq *rq, struct task_struct *prev)
+pick_next_task(struct rq *rq)
 {
         const struct sched_class *class;
         struct task_struct *p;
@@ -4581,8 +4984,8 @@ need_resched_nonpreemptible:
         if (unlikely(!rq->nr_running))
                 idle_balance(cpu, rq);
 
-        prev->sched_class->put_prev_task(rq, prev);
-        next = pick_next_task(rq, prev);
+        put_prev_task(rq, prev);
+        next = pick_next_task(rq);
 
         if (likely(prev != next)) {
                 sched_info_switch(prev, next);
@@ -4637,7 +5040,7 @@ asmlinkage void __sched preempt_schedule(void)
                  * between schedule and now.
                  */
                 barrier();
-        } while (unlikely(test_thread_flag(TIF_NEED_RESCHED)));
+        } while (need_resched());
 }
 EXPORT_SYMBOL(preempt_schedule);
 
@@ -4666,7 +5069,7 @@ asmlinkage void __sched preempt_schedule_irq(void)
                  * between schedule and now.
                  */
                 barrier();
-        } while (unlikely(test_thread_flag(TIF_NEED_RESCHED)));
+        } while (need_resched());
 }
 
 #endif /* CONFIG_PREEMPT */
@@ -4687,8 +5090,8 @@ EXPORT_SYMBOL(default_wake_function);
  * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
  * zero in this (rare) case, and we handle it by continuing to scan the queue.
  */
-static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
-                             int nr_exclusive, int sync, void *key)
+void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
+                        int nr_exclusive, int sync, void *key)
 {
         wait_queue_t *curr, *next;
 
@@ -5140,7 +5543,7 @@ SYSCALL_DEFINE1(nice, int, increment)
         if (increment > 40)
                 increment = 40;
 
-        nice = PRIO_TO_NICE(current->static_prio) + increment;
+        nice = TASK_NICE(current) + increment;
         if (nice < -20)
                 nice = -20;
         if (nice > 19)
@@ -6418,7 +6821,7 @@ static void migrate_dead_tasks(unsigned int dead_cpu)
                 if (!rq->nr_running)
                         break;
                 update_rq_clock(rq);
-                next = pick_next_task(rq, rq->curr);
+                next = pick_next_task(rq);
                 if (!next)
                         break;
                 next->sched_class->put_prev_task(rq, next);
@@ -6939,20 +7342,26 @@ static void free_rootdomain(struct root_domain *rd)
 
 static void rq_attach_root(struct rq *rq, struct root_domain *rd)
 {
+        struct root_domain *old_rd = NULL;
         unsigned long flags;
 
         spin_lock_irqsave(&rq->lock, flags);
 
         if (rq->rd) {
-                struct root_domain *old_rd = rq->rd;
+                old_rd = rq->rd;
 
                 if (cpumask_test_cpu(rq->cpu, old_rd->online))
                         set_rq_offline(rq);
 
                 cpumask_clear_cpu(rq->cpu, old_rd->span);
 
-                if (atomic_dec_and_test(&old_rd->refcount))
-                        free_rootdomain(old_rd);
+                /*
+                 * If we dont want to free the old_rt yet then
+                 * set old_rd to NULL to skip the freeing later
+                 * in this function:
+                 */
+                if (!atomic_dec_and_test(&old_rd->refcount))
+                        old_rd = NULL;
         }
 
         atomic_inc(&rd->refcount);
@@ -6963,6 +7372,9 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
                 set_rq_online(rq);
 
         spin_unlock_irqrestore(&rq->lock, flags);
+
+        if (old_rd)
+                free_rootdomain(old_rd);
 }
 
 static int __init_refok init_rootdomain(struct root_domain *rd, bool bootmem)
@@ -8204,11 +8616,15 @@ static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
         __set_bit(MAX_RT_PRIO, array->bitmap);
 
 #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
-        rt_rq->highest_prio = MAX_RT_PRIO;
+        rt_rq->highest_prio.curr = MAX_RT_PRIO;
+#ifdef CONFIG_SMP
+        rt_rq->highest_prio.next = MAX_RT_PRIO;
+#endif
 #endif
 #ifdef CONFIG_SMP
         rt_rq->rt_nr_migratory = 0;
         rt_rq->overloaded = 0;
+        plist_head_init(&rq->rt.pushable_tasks, &rq->lock);
 #endif
 
         rt_rq->rt_time = 0;
@@ -9210,6 +9626,16 @@ static int sched_rt_global_constraints(void)
 
         return ret;
 }
+
+int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk)
+{
+        /* Don't accept realtime tasks when there is no way for them to run */
+        if (rt_task(tsk) && tg->rt_bandwidth.rt_runtime == 0)
+                return 0;
+
+        return 1;
+}
+
 #else /* !CONFIG_RT_GROUP_SCHED */
 static int sched_rt_global_constraints(void)
 {
@@ -9303,8 +9729,7 @@ cpu_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,
                       struct task_struct *tsk)
 {
 #ifdef CONFIG_RT_GROUP_SCHED
-        /* Don't accept realtime tasks when there is no way for them to run */
-        if (rt_task(tsk) && cgroup_tg(cgrp)->rt_bandwidth.rt_runtime == 0)
+        if (!sched_rt_can_attach(cgroup_tg(cgrp), tsk))
                 return -EINVAL;
 #else
         /* We don't support RT-tasks being in separate groups */
@@ -9575,7 +10000,7 @@ static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
         struct cpuacct *ca;
         int cpu;
 
-        if (!cpuacct_subsys.active)
+        if (unlikely(!cpuacct_subsys.active))
                 return;
 
         cpu = task_cpu(tsk);
diff --git a/kernel/sched_clock.c b/kernel/sched_clock.c
index a0b0852414cc..390f33234bd0 100644
--- a/kernel/sched_clock.c
+++ b/kernel/sched_clock.c
@@ -24,11 +24,11 @@
  * The clock: sched_clock_cpu() is monotonic per cpu, and should be somewhat
  * consistent between cpus (never more than 2 jiffies difference).
  */
-#include <linux/sched.h>
-#include <linux/percpu.h>
 #include <linux/spinlock.h>
-#include <linux/ktime.h>
 #include <linux/module.h>
+#include <linux/percpu.h>
+#include <linux/ktime.h>
+#include <linux/sched.h>
 
 /*
  * Scheduler clock - returns current time in nanosec units.
@@ -43,6 +43,7 @@ unsigned long long __attribute__((weak)) sched_clock(void)
 static __read_mostly int sched_clock_running;
 
 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
+__read_mostly int sched_clock_stable;
 
 struct sched_clock_data {
         /*
@@ -87,7 +88,7 @@ void sched_clock_init(void)
 }
 
 /*
- * min,max except they take wrapping into account
+ * min, max except they take wrapping into account
  */
 
 static inline u64 wrap_min(u64 x, u64 y)
@@ -111,15 +112,13 @@ static u64 __update_sched_clock(struct sched_clock_data *scd, u64 now)
         s64 delta = now - scd->tick_raw;
         u64 clock, min_clock, max_clock;
 
-        WARN_ON_ONCE(!irqs_disabled());
-
         if (unlikely(delta < 0))
                 delta = 0;
 
         /*
          * scd->clock = clamp(scd->tick_gtod + delta,
-         *                    max(scd->tick_gtod, scd->clock),
-         *                    scd->tick_gtod + TICK_NSEC);
+         *                    max(scd->tick_gtod, scd->clock),
+         *                    scd->tick_gtod + TICK_NSEC);
          */
 
         clock = scd->tick_gtod + delta;
@@ -148,12 +147,13 @@ static void lock_double_clock(struct sched_clock_data *data1,
 
 u64 sched_clock_cpu(int cpu)
 {
-        struct sched_clock_data *scd = cpu_sdc(cpu);
         u64 now, clock, this_clock, remote_clock;
+        struct sched_clock_data *scd;
 
-        if (unlikely(!sched_clock_running))
-                return 0ull;
+        if (sched_clock_stable)
+                return sched_clock();
 
+        scd = cpu_sdc(cpu);
         WARN_ON_ONCE(!irqs_disabled());
         now = sched_clock();
 
@@ -195,14 +195,18 @@ u64 sched_clock_cpu(int cpu)
 
 void sched_clock_tick(void)
 {
-        struct sched_clock_data *scd = this_scd();
+        struct sched_clock_data *scd;
         u64 now, now_gtod;
 
+        if (sched_clock_stable)
+                return;
+
         if (unlikely(!sched_clock_running))
                 return;
 
         WARN_ON_ONCE(!irqs_disabled());
 
+        scd = this_scd();
         now_gtod = ktime_to_ns(ktime_get());
         now = sched_clock();
 
@@ -250,7 +254,7 @@ u64 sched_clock_cpu(int cpu)
         return sched_clock();
 }
 
-#endif
+#endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
 
 unsigned long long cpu_clock(int cpu)
 {
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 16eeba4e4169..467ca72f1657 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -272,7 +272,6 @@ static void print_cpu(struct seq_file *m, int cpu)
         P(nr_switches);
         P(nr_load_updates);
         P(nr_uninterruptible);
-        SEQ_printf(m, "  .%-30s: %lu\n", "jiffies", jiffies);
         PN(next_balance);
         P(curr->pid);
         PN(clock);
@@ -287,9 +286,6 @@ static void print_cpu(struct seq_file *m, int cpu)
 #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);
@@ -314,7 +310,7 @@ static int sched_debug_show(struct seq_file *m, void *v)
         u64 now = ktime_to_ns(ktime_get());
         int cpu;
 
-        SEQ_printf(m, "Sched Debug Version: v0.08, %s %.*s\n",
+        SEQ_printf(m, "Sched Debug Version: v0.09, %s %.*s\n",
                 init_utsname()->release,
                 (int)strcspn(init_utsname()->version, " "),
                 init_utsname()->version);
@@ -325,6 +321,7 @@ static int sched_debug_show(struct seq_file *m, void *v)
         SEQ_printf(m, "  .%-40s: %Ld\n", #x, (long long)(x))
 #define PN(x) \
         SEQ_printf(m, "  .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
+        P(jiffies);
         PN(sysctl_sched_latency);
         PN(sysctl_sched_min_granularity);
         PN(sysctl_sched_wakeup_granularity);
@@ -397,6 +394,7 @@ void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
         PN(se.vruntime);
         PN(se.sum_exec_runtime);
         PN(se.avg_overlap);
+        PN(se.avg_wakeup);
 
         nr_switches = p->nvcsw + p->nivcsw;
 
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 5cc1c162044f..3816f217f119 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -719,7 +719,7 @@ 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)
+static void __clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
         if (cfs_rq->last == se)
                 cfs_rq->last = NULL;
@@ -728,6 +728,12 @@ static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
                 cfs_rq->next = NULL;
 }
 
+static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+{
+        for_each_sched_entity(se)
+                __clear_buddies(cfs_rq_of(se), se);
+}
+
 static void
 dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
 {
@@ -768,8 +774,14 @@ check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 
         ideal_runtime = sched_slice(cfs_rq, curr);
         delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
-        if (delta_exec > ideal_runtime)
+        if (delta_exec > ideal_runtime) {
                 resched_task(rq_of(cfs_rq)->curr);
+                /*
+                 * The current task ran long enough, ensure it doesn't get
+                 * re-elected due to buddy favours.
+                 */
+                clear_buddies(cfs_rq, curr);
+        }
 }
 
 static void
@@ -1302,16 +1314,63 @@ out:
 }
 #endif /* CONFIG_SMP */
 
-static unsigned long wakeup_gran(struct sched_entity *se)
+/*
+ * Adaptive granularity
+ *
+ * se->avg_wakeup gives the average time a task runs until it does a wakeup,
+ * with the limit of wakeup_gran -- when it never does a wakeup.
+ *
+ * So the smaller avg_wakeup is the faster we want this task to preempt,
+ * but we don't want to treat the preemptee unfairly and therefore allow it
+ * to run for at least the amount of time we'd like to run.
+ *
+ * NOTE: we use 2*avg_wakeup to increase the probability of actually doing one
+ *
+ * NOTE: we use *nr_running to scale with load, this nicely matches the
+ *       degrading latency on load.
+ */
+static unsigned long
+adaptive_gran(struct sched_entity *curr, struct sched_entity *se)
+{
+        u64 this_run = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
+        u64 expected_wakeup = 2*se->avg_wakeup * cfs_rq_of(se)->nr_running;
+        u64 gran = 0;
+
+        if (this_run < expected_wakeup)
+                gran = expected_wakeup - this_run;
+
+        return min_t(s64, gran, sysctl_sched_wakeup_granularity);
+}
+
+static unsigned long
+wakeup_gran(struct sched_entity *curr, struct sched_entity *se)
 {
         unsigned long gran = sysctl_sched_wakeup_granularity;
 
+        if (cfs_rq_of(curr)->curr && sched_feat(ADAPTIVE_GRAN))
+                gran = adaptive_gran(curr, se);
+
         /*
-         * More easily preempt - nice tasks, while not making it harder for
-         * + nice tasks.
+         * Since its curr running now, convert the gran from real-time
+         * to virtual-time in his units.
          */
-        if (!sched_feat(ASYM_GRAN) || se->load.weight > NICE_0_LOAD)
-                gran = calc_delta_fair(sysctl_sched_wakeup_granularity, se);
+        if (sched_feat(ASYM_GRAN)) {
+                /*
+                 * By using 'se' instead of 'curr' we penalize light tasks, so
+                 * they get preempted easier. That is, if 'se' < 'curr' then
+                 * the resulting gran will be larger, therefore penalizing the
+                 * lighter, if otoh 'se' > 'curr' then the resulting gran will
+                 * be smaller, again penalizing the lighter task.
+                 *
+                 * This is especially important for buddies when the leftmost
+                 * task is higher priority than the buddy.
+                 */
+                if (unlikely(se->load.weight != NICE_0_LOAD))
+                        gran = calc_delta_fair(gran, se);
+        } else {
+                if (unlikely(curr->load.weight != NICE_0_LOAD))
+                        gran = calc_delta_fair(gran, curr);
+        }
 
         return gran;
 }
@@ -1338,7 +1397,7 @@ wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
         if (vdiff <= 0)
                 return -1;
 
-        gran = wakeup_gran(curr);
+        gran = wakeup_gran(curr, se);
         if (vdiff > gran)
                 return 1;
 
@@ -1452,6 +1511,11 @@ static struct task_struct *pick_next_task_fair(struct rq *rq)
 
         do {
                 se = pick_next_entity(cfs_rq);
+                /*
+                 * If se was a buddy, clear it so that it will have to earn
+                 * the favour again.
+                 */
+                __clear_buddies(cfs_rq, se);
                 set_next_entity(cfs_rq, se);
                 cfs_rq = group_cfs_rq(se);
         } while (cfs_rq);
diff --git a/kernel/sched_features.h b/kernel/sched_features.h
index da5d93b5d2c6..76f61756e677 100644
--- a/kernel/sched_features.h
+++ b/kernel/sched_features.h
@@ -1,5 +1,6 @@
 SCHED_FEAT(NEW_FAIR_SLEEPERS, 1)
-SCHED_FEAT(NORMALIZED_SLEEPER, 1)
+SCHED_FEAT(NORMALIZED_SLEEPER, 0)
+SCHED_FEAT(ADAPTIVE_GRAN, 1)
 SCHED_FEAT(WAKEUP_PREEMPT, 1)
 SCHED_FEAT(START_DEBIT, 1)
 SCHED_FEAT(AFFINE_WAKEUPS, 1)
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 954e1a81b796..c79dc7844012 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -3,6 +3,40 @@
  * policies)
  */
 
+static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
+{
+        return container_of(rt_se, struct task_struct, rt);
+}
+
+#ifdef CONFIG_RT_GROUP_SCHED
+
+static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
+{
+        return rt_rq->rq;
+}
+
+static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
+{
+        return rt_se->rt_rq;
+}
+
+#else /* CONFIG_RT_GROUP_SCHED */
+
+static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
+{
+        return container_of(rt_rq, struct rq, rt);
+}
+
+static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
+{
+        struct task_struct *p = rt_task_of(rt_se);
+        struct rq *rq = task_rq(p);
+
+        return &rq->rt;
+}
+
+#endif /* CONFIG_RT_GROUP_SCHED */
+
 #ifdef CONFIG_SMP
 
 static inline int rt_overloaded(struct rq *rq)
@@ -37,25 +71,69 @@ static inline void rt_clear_overload(struct rq *rq)
         cpumask_clear_cpu(rq->cpu, rq->rd->rto_mask);
 }
 
-static void update_rt_migration(struct rq *rq)
+static void update_rt_migration(struct rt_rq *rt_rq)
 {
-        if (rq->rt.rt_nr_migratory && (rq->rt.rt_nr_running > 1)) {
-                if (!rq->rt.overloaded) {
-                        rt_set_overload(rq);
-                        rq->rt.overloaded = 1;
+        if (rt_rq->rt_nr_migratory && (rt_rq->rt_nr_running > 1)) {
+                if (!rt_rq->overloaded) {
+                        rt_set_overload(rq_of_rt_rq(rt_rq));
+                        rt_rq->overloaded = 1;
                 }
-        } else if (rq->rt.overloaded) {
-                rt_clear_overload(rq);
-                rq->rt.overloaded = 0;
+        } else if (rt_rq->overloaded) {
+                rt_clear_overload(rq_of_rt_rq(rt_rq));
+                rt_rq->overloaded = 0;
         }
 }
-#endif /* CONFIG_SMP */
 
-static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
+static void inc_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+        if (rt_se->nr_cpus_allowed > 1)
+                rt_rq->rt_nr_migratory++;
+
+        update_rt_migration(rt_rq);
+}
+
+static void dec_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+        if (rt_se->nr_cpus_allowed > 1)
+                rt_rq->rt_nr_migratory--;
+
+        update_rt_migration(rt_rq);
+}
+
+static void enqueue_pushable_task(struct rq *rq, struct task_struct *p)
+{
+        plist_del(&p->pushable_tasks, &rq->rt.pushable_tasks);
+        plist_node_init(&p->pushable_tasks, p->prio);
+        plist_add(&p->pushable_tasks, &rq->rt.pushable_tasks);
+}
+
+static void dequeue_pushable_task(struct rq *rq, struct task_struct *p)
+{
+        plist_del(&p->pushable_tasks, &rq->rt.pushable_tasks);
+}
+
+#else
+
+static inline void enqueue_pushable_task(struct rq *rq, struct task_struct *p)
 {
-        return container_of(rt_se, struct task_struct, rt);
 }
 
+static inline void dequeue_pushable_task(struct rq *rq, struct task_struct *p)
+{
+}
+
+static inline
+void inc_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+}
+
+static inline
+void dec_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+}
+
+#endif /* CONFIG_SMP */
+
 static inline int on_rt_rq(struct sched_rt_entity *rt_se)
 {
         return !list_empty(&rt_se->run_list);
@@ -79,16 +157,6 @@ static inline u64 sched_rt_period(struct rt_rq *rt_rq)
 #define for_each_leaf_rt_rq(rt_rq, rq) \
         list_for_each_entry_rcu(rt_rq, &rq->leaf_rt_rq_list, leaf_rt_rq_list)
 
-static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
-{
-        return rt_rq->rq;
-}
-
-static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
-{
-        return rt_se->rt_rq;
-}
-
 #define for_each_sched_rt_entity(rt_se) \
         for (; rt_se; rt_se = rt_se->parent)
 
@@ -108,7 +176,7 @@ static void sched_rt_rq_enqueue(struct rt_rq *rt_rq)
         if (rt_rq->rt_nr_running) {
                 if (rt_se && !on_rt_rq(rt_se))
                         enqueue_rt_entity(rt_se);
-                if (rt_rq->highest_prio < curr->prio)
+                if (rt_rq->highest_prio.curr < curr->prio)
                         resched_task(curr);
         }
 }
@@ -176,19 +244,6 @@ static inline u64 sched_rt_period(struct rt_rq *rt_rq)
 #define for_each_leaf_rt_rq(rt_rq, rq) \
         for (rt_rq = &rq->rt; rt_rq; rt_rq = NULL)
 
-static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
-{
-        return container_of(rt_rq, struct rq, rt);
-}
-
-static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
-{
-        struct task_struct *p = rt_task_of(rt_se);
-        struct rq *rq = task_rq(p);
-
-        return &rq->rt;
-}
-
 #define for_each_sched_rt_entity(rt_se) \
         for (; rt_se; rt_se = NULL)
 
@@ -473,7 +528,7 @@ static inline int rt_se_prio(struct sched_rt_entity *rt_se)
         struct rt_rq *rt_rq = group_rt_rq(rt_se);
 
         if (rt_rq)
-                return rt_rq->highest_prio;
+                return rt_rq->highest_prio.curr;
 #endif
 
         return rt_task_of(rt_se)->prio;
@@ -547,91 +602,174 @@ static void update_curr_rt(struct rq *rq)
         }
 }
 
-static inline
-void inc_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+#if defined CONFIG_SMP
+
+static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu);
+
+static inline int next_prio(struct rq *rq)
 {
-        WARN_ON(!rt_prio(rt_se_prio(rt_se)));
-        rt_rq->rt_nr_running++;
-#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
-        if (rt_se_prio(rt_se) < rt_rq->highest_prio) {
-#ifdef CONFIG_SMP
-                struct rq *rq = rq_of_rt_rq(rt_rq);
-#endif
+        struct task_struct *next = pick_next_highest_task_rt(rq, rq->cpu);
+
+        if (next && rt_prio(next->prio))
+                return next->prio;
+        else
+                return MAX_RT_PRIO;
+}
+
+static void
+inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
+{
+        struct rq *rq = rq_of_rt_rq(rt_rq);
+
+        if (prio < prev_prio) {
+
+                /*
+                 * If the new task is higher in priority than anything on the
+                 * run-queue, we know that the previous high becomes our
+                 * next-highest.
+                 */
+                rt_rq->highest_prio.next = prev_prio;
 
-                rt_rq->highest_prio = rt_se_prio(rt_se);
-#ifdef CONFIG_SMP
                 if (rq->online)
-                        cpupri_set(&rq->rd->cpupri, rq->cpu,
-                                   rt_se_prio(rt_se));
-#endif
-        }
-#endif
-#ifdef CONFIG_SMP
-        if (rt_se->nr_cpus_allowed > 1) {
-                struct rq *rq = rq_of_rt_rq(rt_rq);
+                        cpupri_set(&rq->rd->cpupri, rq->cpu, prio);
 
-                rq->rt.rt_nr_migratory++;
-        }
+        } else if (prio == rt_rq->highest_prio.curr)
+                /*
+                 * If the next task is equal in priority to the highest on
+                 * the run-queue, then we implicitly know that the next highest
+                 * task cannot be any lower than current
+                 */
+                rt_rq->highest_prio.next = prio;
+        else if (prio < rt_rq->highest_prio.next)
+                /*
+                 * Otherwise, we need to recompute next-highest
+                 */
+                rt_rq->highest_prio.next = next_prio(rq);
+}
 
-        update_rt_migration(rq_of_rt_rq(rt_rq));
-#endif
-#ifdef CONFIG_RT_GROUP_SCHED
-        if (rt_se_boosted(rt_se))
-                rt_rq->rt_nr_boosted++;
+static void
+dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
+{
+        struct rq *rq = rq_of_rt_rq(rt_rq);
 
-        if (rt_rq->tg)
-                start_rt_bandwidth(&rt_rq->tg->rt_bandwidth);
-#else
-        start_rt_bandwidth(&def_rt_bandwidth);
-#endif
+        if (rt_rq->rt_nr_running && (prio <= rt_rq->highest_prio.next))
+                rt_rq->highest_prio.next = next_prio(rq);
+
+        if (rq->online && rt_rq->highest_prio.curr != prev_prio)
+                cpupri_set(&rq->rd->cpupri, rq->cpu, rt_rq->highest_prio.curr);
 }
 
+#else /* CONFIG_SMP */
+
 static inline
-void dec_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
-{
-#ifdef CONFIG_SMP
-        int highest_prio = rt_rq->highest_prio;
-#endif
+void inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio) {}
+static inline
+void dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio) {}
+
+#endif /* CONFIG_SMP */
 
-        WARN_ON(!rt_prio(rt_se_prio(rt_se)));
-        WARN_ON(!rt_rq->rt_nr_running);
-        rt_rq->rt_nr_running--;
 #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
+static void
+inc_rt_prio(struct rt_rq *rt_rq, int prio)
+{
+        int prev_prio = rt_rq->highest_prio.curr;
+
+        if (prio < prev_prio)
+                rt_rq->highest_prio.curr = prio;
+
+        inc_rt_prio_smp(rt_rq, prio, prev_prio);
+}
+
+static void
+dec_rt_prio(struct rt_rq *rt_rq, int prio)
+{
+        int prev_prio = rt_rq->highest_prio.curr;
+
         if (rt_rq->rt_nr_running) {
-                struct rt_prio_array *array;
 
-                WARN_ON(rt_se_prio(rt_se) < rt_rq->highest_prio);
-                if (rt_se_prio(rt_se) == rt_rq->highest_prio) {
-                        /* recalculate */
-                        array = &rt_rq->active;
-                        rt_rq->highest_prio =
+                WARN_ON(prio < prev_prio);
+
+                /*
+                 * This may have been our highest task, and therefore
+                 * we may have some recomputation to do
+                 */
+                if (prio == prev_prio) {
+                        struct rt_prio_array *array = &rt_rq->active;
+
+                        rt_rq->highest_prio.curr =
                                 sched_find_first_bit(array->bitmap);
-                } /* otherwise leave rq->highest prio alone */
+                }
+
         } else
-                rt_rq->highest_prio = MAX_RT_PRIO;
-#endif
-#ifdef CONFIG_SMP
-        if (rt_se->nr_cpus_allowed > 1) {
-                struct rq *rq = rq_of_rt_rq(rt_rq);
-                rq->rt.rt_nr_migratory--;
-        }
+                rt_rq->highest_prio.curr = MAX_RT_PRIO;
 
-        if (rt_rq->highest_prio != highest_prio) {
-                struct rq *rq = rq_of_rt_rq(rt_rq);
+        dec_rt_prio_smp(rt_rq, prio, prev_prio);
+}
 
-                if (rq->online)
-                        cpupri_set(&rq->rd->cpupri, rq->cpu,
-                                   rt_rq->highest_prio);
-        }
+#else
+
+static inline void inc_rt_prio(struct rt_rq *rt_rq, int prio) {}
+static inline void dec_rt_prio(struct rt_rq *rt_rq, int prio) {}
+
+#endif /* CONFIG_SMP || CONFIG_RT_GROUP_SCHED */
 
-        update_rt_migration(rq_of_rt_rq(rt_rq));
-#endif /* CONFIG_SMP */
 #ifdef CONFIG_RT_GROUP_SCHED
+
+static void
+inc_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+        if (rt_se_boosted(rt_se))
+                rt_rq->rt_nr_boosted++;
+
+        if (rt_rq->tg)
+                start_rt_bandwidth(&rt_rq->tg->rt_bandwidth);
+}
+
+static void
+dec_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
         if (rt_se_boosted(rt_se))
                 rt_rq->rt_nr_boosted--;
 
         WARN_ON(!rt_rq->rt_nr_running && rt_rq->rt_nr_boosted);
-#endif
+}
+
+#else /* CONFIG_RT_GROUP_SCHED */
+
+static void
+inc_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+        start_rt_bandwidth(&def_rt_bandwidth);
+}
+
+static inline
+void dec_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq) {}
+
+#endif /* CONFIG_RT_GROUP_SCHED */
+
+static inline
+void inc_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+        int prio = rt_se_prio(rt_se);
+
+        WARN_ON(!rt_prio(prio));
+        rt_rq->rt_nr_running++;
+
+        inc_rt_prio(rt_rq, prio);
+        inc_rt_migration(rt_se, rt_rq);
+        inc_rt_group(rt_se, rt_rq);
+}
+
+static inline
+void dec_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+{
+        WARN_ON(!rt_prio(rt_se_prio(rt_se)));
+        WARN_ON(!rt_rq->rt_nr_running);
+        rt_rq->rt_nr_running--;
+
+        dec_rt_prio(rt_rq, rt_se_prio(rt_se));
+        dec_rt_migration(rt_se, rt_rq);
+        dec_rt_group(rt_se, rt_rq);
 }
 
 static void __enqueue_rt_entity(struct sched_rt_entity *rt_se)
@@ -718,6 +856,9 @@ static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup)
 
         enqueue_rt_entity(rt_se);
 
+        if (!task_current(rq, p) && p->rt.nr_cpus_allowed > 1)
+                enqueue_pushable_task(rq, p);
+
         inc_cpu_load(rq, p->se.load.weight);
 }
 
@@ -728,6 +869,8 @@ static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int sleep)
         update_curr_rt(rq);
         dequeue_rt_entity(rt_se);
 
+        dequeue_pushable_task(rq, p);
+
         dec_cpu_load(rq, p->se.load.weight);
 }
 
@@ -878,7 +1021,7 @@ static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,
         return next;
 }
 
-static struct task_struct *pick_next_task_rt(struct rq *rq)
+static struct task_struct *_pick_next_task_rt(struct rq *rq)
 {
         struct sched_rt_entity *rt_se;
         struct task_struct *p;
@@ -900,6 +1043,18 @@ static struct task_struct *pick_next_task_rt(struct rq *rq)
 
         p = rt_task_of(rt_se);
         p->se.exec_start = rq->clock;
+
+        return p;
+}
+
+static struct task_struct *pick_next_task_rt(struct rq *rq)
+{
+        struct task_struct *p = _pick_next_task_rt(rq);
+
+        /* The running task is never eligible for pushing */
+        if (p)
+                dequeue_pushable_task(rq, p);
+
         return p;
 }
 
@@ -907,6 +1062,13 @@ static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
 {
         update_curr_rt(rq);
         p->se.exec_start = 0;
+
+        /*
+         * The previous task needs to be made eligible for pushing
+         * if it is still active
+         */
+        if (p->se.on_rq && p->rt.nr_cpus_allowed > 1)
+                enqueue_pushable_task(rq, p);
 }
 
 #ifdef CONFIG_SMP
@@ -968,8 +1130,8 @@ static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
         if ((this_cpu != -1) && cpu_isset(this_cpu, *mask))
                 return this_cpu;
 
-        first = first_cpu(*mask);
-        if (first != NR_CPUS)
+        first = cpumask_first(mask);
+        if (first < nr_cpu_ids)
                 return first;
 
         return -1;
@@ -1072,7 +1234,7 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
                 }
 
                 /* If this rq is still suitable use it. */
-                if (lowest_rq->rt.highest_prio > task->prio)
+                if (lowest_rq->rt.highest_prio.curr > task->prio)
                         break;
 
                 /* try again */
@@ -1083,6 +1245,31 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
         return lowest_rq;
 }
 
+static inline int has_pushable_tasks(struct rq *rq)
+{
+        return !plist_head_empty(&rq->rt.pushable_tasks);
+}
+
+static struct task_struct *pick_next_pushable_task(struct rq *rq)
+{
+        struct task_struct *p;
+
+        if (!has_pushable_tasks(rq))
+                return NULL;
+
+        p = plist_first_entry(&rq->rt.pushable_tasks,
+                              struct task_struct, pushable_tasks);
+
+        BUG_ON(rq->cpu != task_cpu(p));
+        BUG_ON(task_current(rq, p));
+        BUG_ON(p->rt.nr_cpus_allowed <= 1);
+
+        BUG_ON(!p->se.on_rq);
+        BUG_ON(!rt_task(p));
+
+        return p;
+}
+
 /*
  * If the current CPU has more than one RT task, see if the non
  * running task can migrate over to a CPU that is running a task
@@ -1092,13 +1279,11 @@ static int push_rt_task(struct rq *rq)
 {
         struct task_struct *next_task;
         struct rq *lowest_rq;
-        int ret = 0;
-        int paranoid = RT_MAX_TRIES;
 
         if (!rq->rt.overloaded)
                 return 0;
 
-        next_task = pick_next_highest_task_rt(rq, -1);
+        next_task = pick_next_pushable_task(rq);
         if (!next_task)
                 return 0;
 
@@ -1127,16 +1312,34 @@ static int push_rt_task(struct rq *rq)
                 struct task_struct *task;
                 /*
                  * find lock_lowest_rq releases rq->lock
-                 * so it is possible that next_task has changed.
-                 * If it has, then try again.
+                 * so it is possible that next_task has migrated.
+                 *
+                 * We need to make sure that the task is still on the same
+                 * run-queue and is also still the next task eligible for
+                 * pushing.
                  */
-                task = pick_next_highest_task_rt(rq, -1);
-                if (unlikely(task != next_task) && task && paranoid--) {
-                        put_task_struct(next_task);
-                        next_task = task;
-                        goto retry;
+                task = pick_next_pushable_task(rq);
+                if (task_cpu(next_task) == rq->cpu && task == next_task) {
+                        /*
+                         * If we get here, the task hasnt moved at all, but
+                         * it has failed to push.  We will not try again,
+                         * since the other cpus will pull from us when they
+                         * are ready.
+                         */
+                        dequeue_pushable_task(rq, next_task);
+                        goto out;
                 }
-                goto out;
+
+                if (!task)
+                        /* No more tasks, just exit */
+                        goto out;
+
+                /*
+                 * Something has shifted, try again.
+                 */
+                put_task_struct(next_task);
+                next_task = task;
+                goto retry;
         }
 
         deactivate_task(rq, next_task, 0);
@@ -1147,23 +1350,12 @@ static int push_rt_task(struct rq *rq)
 
         double_unlock_balance(rq, lowest_rq);
 
-        ret = 1;
 out:
         put_task_struct(next_task);
 
-        return ret;
+        return 1;
 }
 
-/*
- * TODO: Currently we just use the second highest prio task on
- *       the queue, and stop when it can't migrate (or there's
- *       no more RT tasks).  There may be a case where a lower
- *       priority RT task has a different affinity than the
- *       higher RT task. In this case the lower RT task could
- *       possibly be able to migrate where as the higher priority
- *       RT task could not.  We currently ignore this issue.
- *       Enhancements are welcome!
- */
 static void push_rt_tasks(struct rq *rq)
 {
         /* push_rt_task will return true if it moved an RT */
@@ -1174,33 +1366,35 @@ static void push_rt_tasks(struct rq *rq)
 static int pull_rt_task(struct rq *this_rq)
 {
         int this_cpu = this_rq->cpu, ret = 0, cpu;
-        struct task_struct *p, *next;
+        struct task_struct *p;
         struct rq *src_rq;
 
         if (likely(!rt_overloaded(this_rq)))
                 return 0;
 
-        next = pick_next_task_rt(this_rq);
-
         for_each_cpu(cpu, this_rq->rd->rto_mask) {
                 if (this_cpu == cpu)
                         continue;
 
                 src_rq = cpu_rq(cpu);
+
+                /*
+                 * Don't bother taking the src_rq->lock if the next highest
+                 * task is known to be lower-priority than our current task.
+                 * This may look racy, but if this value is about to go
+                 * logically higher, the src_rq will push this task away.
+                 * And if its going logically lower, we do not care
+                 */
+                if (src_rq->rt.highest_prio.next >=
+                    this_rq->rt.highest_prio.curr)
+                        continue;
+
                 /*
                  * We can potentially drop this_rq's lock in
                  * double_lock_balance, and another CPU could
-                 * steal our next task - hence we must cause
-                 * the caller to recalculate the next task
-                 * in that case:
+                 * alter this_rq
                  */
-                if (double_lock_balance(this_rq, src_rq)) {
-                        struct task_struct *old_next = next;
-
-                        next = pick_next_task_rt(this_rq);
-                        if (next != old_next)
-                                ret = 1;
-                }
+                double_lock_balance(this_rq, src_rq);
 
                 /*
                  * Are there still pullable RT tasks?
@@ -1214,7 +1408,7 @@ static int pull_rt_task(struct rq *this_rq)
                  * Do we have an RT task that preempts
                  * the to-be-scheduled task?
                  */
-                if (p && (!next || (p->prio < next->prio))) {
+                if (p && (p->prio < this_rq->rt.highest_prio.curr)) {
                         WARN_ON(p == src_rq->curr);
                         WARN_ON(!p->se.on_rq);
 
@@ -1224,12 +1418,9 @@ static int pull_rt_task(struct rq *this_rq)
                          * This is just that p is wakeing up and hasn't
                          * had a chance to schedule. We only pull
                          * p if it is lower in priority than the
-                         * current task on the run queue or
-                         * this_rq next task is lower in prio than
-                         * the current task on that rq.
+                         * current task on the run queue
                          */
-                        if (p->prio < src_rq->curr->prio ||
-                            (next && next->prio < src_rq->curr->prio))
+                        if (p->prio < src_rq->curr->prio)
                                 goto skip;
 
                         ret = 1;
@@ -1242,13 +1433,7 @@ static int pull_rt_task(struct rq *this_rq)
                          * case there's an even higher prio task
                          * in another runqueue. (low likelyhood
                          * but possible)
-                         *
-                         * Update next so that we won't pick a task
-                         * on another cpu with a priority lower (or equal)
-                         * than the one we just picked.
                          */
-                        next = p;
-
                 }
  skip:
                 double_unlock_balance(this_rq, src_rq);
@@ -1260,24 +1445,27 @@ static int pull_rt_task(struct rq *this_rq)
 static void pre_schedule_rt(struct rq *rq, struct task_struct *prev)
 {
         /* Try to pull RT tasks here if we lower this rq's prio */
-        if (unlikely(rt_task(prev)) && rq->rt.highest_prio > prev->prio)
+        if (unlikely(rt_task(prev)) && rq->rt.highest_prio.curr > prev->prio)
                 pull_rt_task(rq);
 }
 
+/*
+ * assumes rq->lock is held
+ */
+static int needs_post_schedule_rt(struct rq *rq)
+{
+        return has_pushable_tasks(rq);
+}
+
 static void post_schedule_rt(struct rq *rq)
 {
         /*
-         * If we have more than one rt_task queued, then
-         * see if we can push the other rt_tasks off to other CPUS.
-         * Note we may release the rq lock, and since
-         * the lock was owned by prev, we need to release it
-         * first via finish_lock_switch and then reaquire it here.
+         * This is only called if needs_post_schedule_rt() indicates that
+         * we need to push tasks away
          */
-        if (unlikely(rq->rt.overloaded)) {
-                spin_lock_irq(&rq->lock);
-                push_rt_tasks(rq);
-                spin_unlock_irq(&rq->lock);
-        }
+        spin_lock_irq(&rq->lock);
+        push_rt_tasks(rq);
+        spin_unlock_irq(&rq->lock);
 }
 
 /*
@@ -1288,7 +1476,8 @@ static void task_wake_up_rt(struct rq *rq, struct task_struct *p)
 {
         if (!task_running(rq, p) &&
             !test_tsk_need_resched(rq->curr) &&
-            rq->rt.overloaded)
+            has_pushable_tasks(rq) &&
+            p->rt.nr_cpus_allowed > 1)
                 push_rt_tasks(rq);
 }
 
@@ -1324,6 +1513,24 @@ static void set_cpus_allowed_rt(struct task_struct *p,
         if (p->se.on_rq && (weight != p->rt.nr_cpus_allowed)) {
                 struct rq *rq = task_rq(p);
 
+                if (!task_current(rq, p)) {
+                        /*
+                         * Make sure we dequeue this task from the pushable list
+                         * before going further.  It will either remain off of
+                         * the list because we are no longer pushable, or it
+                         * will be requeued.
+                         */
+                        if (p->rt.nr_cpus_allowed > 1)
+                                dequeue_pushable_task(rq, p);
+
+                        /*
+                         * Requeue if our weight is changing and still > 1
+                         */
+                        if (weight > 1)
+                                enqueue_pushable_task(rq, p);
+
+                }
+
                 if ((p->rt.nr_cpus_allowed <= 1) && (weight > 1)) {
                         rq->rt.rt_nr_migratory++;
                 } else if ((p->rt.nr_cpus_allowed > 1) && (weight <= 1)) {
@@ -1331,7 +1538,7 @@ static void set_cpus_allowed_rt(struct task_struct *p,
                         rq->rt.rt_nr_migratory--;
                 }
 
-                update_rt_migration(rq);
+                update_rt_migration(&rq->rt);
         }
 
         cpumask_copy(&p->cpus_allowed, new_mask);
@@ -1346,7 +1553,7 @@ static void rq_online_rt(struct rq *rq)
 
         __enable_runtime(rq);
 
-        cpupri_set(&rq->rd->cpupri, rq->cpu, rq->rt.highest_prio);
+        cpupri_set(&rq->rd->cpupri, rq->cpu, rq->rt.highest_prio.curr);
 }
 
 /* Assumes rq->lock is held */
@@ -1438,7 +1645,7 @@ static void prio_changed_rt(struct rq *rq, struct task_struct *p,
                  * can release the rq lock and p could migrate.
                  * Only reschedule if p is still on the same runqueue.
                  */
-                if (p->prio > rq->rt.highest_prio && rq->curr == p)
+                if (p->prio > rq->rt.highest_prio.curr && rq->curr == p)
                         resched_task(p);
 #else
                 /* For UP simply resched on drop of prio */
@@ -1509,6 +1716,9 @@ static void set_curr_task_rt(struct rq *rq)
         struct task_struct *p = rq->curr;
 
         p->se.exec_start = rq->clock;
+
+        /* The running task is never eligible for pushing */
+        dequeue_pushable_task(rq, p);
 }
 
 static const struct sched_class rt_sched_class = {
@@ -1531,6 +1741,7 @@ static const struct sched_class rt_sched_class = {
         .rq_online              = rq_online_rt,
         .rq_offline             = rq_offline_rt,
         .pre_schedule           = pre_schedule_rt,
+        .needs_post_schedule    = needs_post_schedule_rt,
         .post_schedule          = post_schedule_rt,
         .task_wake_up           = task_wake_up_rt,
         .switched_from          = switched_from_rt,
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index f2773b5d1226..32d2bd4061b0 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -4,7 +4,7 @@
  * bump this up when changing the output format or the meaning of an existing
  * format, so that tools can adapt (or abort)
  */
-#define SCHEDSTAT_VERSION 14
+#define SCHEDSTAT_VERSION 15
 
 static int show_schedstat(struct seq_file *seq, void *v)
 {
@@ -26,9 +26,8 @@ static int show_schedstat(struct seq_file *seq, void *v)
 
                 /* runqueue-specific stats */
                 seq_printf(seq,
-                    "cpu%d %u %u %u %u %u %u %u %u %u %llu %llu %lu",
-                    cpu, rq->yld_both_empty,
-                    rq->yld_act_empty, rq->yld_exp_empty, rq->yld_count,
+                    "cpu%d %u %u %u %u %u %u %llu %llu %lu",
+                    cpu, rq->yld_count,
                     rq->sched_switch, rq->sched_count, rq->sched_goidle,
                     rq->ttwu_count, rq->ttwu_local,
                     rq->rq_cpu_time,
@@ -296,20 +295,21 @@ sched_info_switch(struct task_struct *prev, struct task_struct *next)
 static inline void account_group_user_time(struct task_struct *tsk,
                                            cputime_t cputime)
 {
-        struct signal_struct *sig;
+        struct thread_group_cputimer *cputimer;
 
         /* tsk == current, ensure it is safe to use ->signal */
         if (unlikely(tsk->exit_state))
                 return;
 
-        sig = tsk->signal;
-        if (sig->cputime.totals) {
-                struct task_cputime *times;
+        cputimer = &tsk->signal->cputimer;
 
-                times = per_cpu_ptr(sig->cputime.totals, get_cpu());
-                times->utime = cputime_add(times->utime, cputime);
-                put_cpu_no_resched();
-        }
+        if (!cputimer->running)
+                return;
+
+        spin_lock(&cputimer->lock);
+        cputimer->cputime.utime =
+                cputime_add(cputimer->cputime.utime, cputime);
+        spin_unlock(&cputimer->lock);
 }
 
 /**
@@ -325,20 +325,21 @@ static inline void account_group_user_time(struct task_struct *tsk,
 static inline void account_group_system_time(struct task_struct *tsk,
                                              cputime_t cputime)
 {
-        struct signal_struct *sig;
+        struct thread_group_cputimer *cputimer;
 
         /* tsk == current, ensure it is safe to use ->signal */
         if (unlikely(tsk->exit_state))
                 return;
 
-        sig = tsk->signal;
-        if (sig->cputime.totals) {
-                struct task_cputime *times;
+        cputimer = &tsk->signal->cputimer;
 
-                times = per_cpu_ptr(sig->cputime.totals, get_cpu());
-                times->stime = cputime_add(times->stime, cputime);
-                put_cpu_no_resched();
-        }
+        if (!cputimer->running)
+                return;
+
+        spin_lock(&cputimer->lock);
+        cputimer->cputime.stime =
+                cputime_add(cputimer->cputime.stime, cputime);
+        spin_unlock(&cputimer->lock);
 }
 
 /**
@@ -354,6 +355,7 @@ static inline void account_group_system_time(struct task_struct *tsk,
 static inline void account_group_exec_runtime(struct task_struct *tsk,
                                               unsigned long long ns)
 {
+        struct thread_group_cputimer *cputimer;
         struct signal_struct *sig;
 
         sig = tsk->signal;
@@ -362,11 +364,12 @@ static inline void account_group_exec_runtime(struct task_struct *tsk,
         if (unlikely(!sig))
                 return;
 
-        if (sig->cputime.totals) {
-                struct task_cputime *times;
+        cputimer = &sig->cputimer;
 
-                times = per_cpu_ptr(sig->cputime.totals, get_cpu());
-                times->sum_exec_runtime += ns;
-                put_cpu_no_resched();
-        }
+        if (!cputimer->running)
+                return;
+
+        spin_lock(&cputimer->lock);
+        cputimer->cputime.sum_exec_runtime += ns;
+        spin_unlock(&cputimer->lock);
 }
diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index ad64fcb731f2..57d4b13b631d 100644
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -8,6 +8,7 @@
 
 #include <linux/seccomp.h>
 #include <linux/sched.h>
+#include <linux/compat.h>
 
 /* #define SECCOMP_DEBUG 1 */
 #define NR_SECCOMP_MODES 1
@@ -22,7 +23,7 @@ static int mode1_syscalls[] = {
         0, /* null terminated */
 };
 
-#ifdef TIF_32BIT
+#ifdef CONFIG_COMPAT
 static int mode1_syscalls_32[] = {
         __NR_seccomp_read_32, __NR_seccomp_write_32, __NR_seccomp_exit_32, __NR_seccomp_sigreturn_32,
         0, /* null terminated */
@@ -37,8 +38,8 @@ void __secure_computing(int this_syscall)
         switch (mode) {
         case 1:
                 syscall = mode1_syscalls;
-#ifdef TIF_32BIT
-                if (test_thread_flag(TIF_32BIT))
+#ifdef CONFIG_COMPAT
+                if (is_compat_task())
                         syscall = mode1_syscalls_32;
 #endif
                 do {
diff --git a/kernel/signal.c b/kernel/signal.c
index e73759783dc8..1c8814481a11 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -909,7 +909,9 @@ static void print_fatal_signal(struct pt_regs *regs, int signr)
         }
 #endif
         printk("\n");
+        preempt_disable();
         show_regs(regs);
+        preempt_enable();
 }
 
 static int __init setup_print_fatal_signals(char *str)
@@ -1365,7 +1367,6 @@ int do_notify_parent(struct task_struct *tsk, int sig)
         struct siginfo info;
         unsigned long flags;
         struct sighand_struct *psig;
-        struct task_cputime cputime;
         int ret = sig;
 
         BUG_ON(sig == -1);
@@ -1395,9 +1396,10 @@ int do_notify_parent(struct task_struct *tsk, int sig)
         info.si_uid = __task_cred(tsk)->uid;
         rcu_read_unlock();
 
-        thread_group_cputime(tsk, &cputime);
-        info.si_utime = cputime_to_jiffies(cputime.utime);
-        info.si_stime = cputime_to_jiffies(cputime.stime);
+        info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
+                                tsk->signal->utime));
+        info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
+                                tsk->signal->stime));
 
         info.si_status = tsk->exit_code & 0x7f;
         if (tsk->exit_code & 0x80)
@@ -1573,7 +1575,15 @@ static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
         read_lock(&tasklist_lock);
         if (may_ptrace_stop()) {
                 do_notify_parent_cldstop(current, CLD_TRAPPED);
+                /*
+                 * Don't want to allow preemption here, because
+                 * sys_ptrace() needs this task to be inactive.
+                 *
+                 * XXX: implement read_unlock_no_resched().
+                 */
+                preempt_disable();
                 read_unlock(&tasklist_lock);
+                preempt_enable_no_resched();
                 schedule();
         } else {
                 /*
diff --git a/kernel/smp.c b/kernel/smp.c
index 5cfa0e5e3e88..bbedbb7efe32 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -18,6 +18,7 @@ __cacheline_aligned_in_smp DEFINE_SPINLOCK(call_function_lock);
 enum {
         CSD_FLAG_WAIT           = 0x01,
         CSD_FLAG_ALLOC          = 0x02,
+        CSD_FLAG_LOCK           = 0x04,
 };
 
 struct call_function_data {
@@ -186,6 +187,9 @@ void generic_smp_call_function_single_interrupt(void)
                         if (data_flags & CSD_FLAG_WAIT) {
                                 smp_wmb();
                                 data->flags &= ~CSD_FLAG_WAIT;
+                        } else if (data_flags & CSD_FLAG_LOCK) {
+                                smp_wmb();
+                                data->flags &= ~CSD_FLAG_LOCK;
                         } else if (data_flags & CSD_FLAG_ALLOC)
                                 kfree(data);
                 }
@@ -196,6 +200,8 @@ void generic_smp_call_function_single_interrupt(void)
         }
 }
 
+static DEFINE_PER_CPU(struct call_single_data, csd_data);
+
 /*
  * smp_call_function_single - Run a function on a specific CPU
  * @func: The function to run. This must be fast and non-blocking.
@@ -224,14 +230,38 @@ int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
                 func(info);
                 local_irq_restore(flags);
         } else if ((unsigned)cpu < nr_cpu_ids && cpu_online(cpu)) {
-                struct call_single_data *data = NULL;
+                struct call_single_data *data;
 
                 if (!wait) {
+                        /*
+                         * We are calling a function on a single CPU
+                         * and we are not going to wait for it to finish.
+                         * We first try to allocate the data, but if we
+                         * fail, we fall back to use a per cpu data to pass
+                         * the information to that CPU. Since all callers
+                         * of this code will use the same data, we must
+                         * synchronize the callers to prevent a new caller
+                         * from corrupting the data before the callee
+                         * can access it.
+                         *
+                         * The CSD_FLAG_LOCK is used to let us know when
+                         * the IPI handler is done with the data.
+                         * The first caller will set it, and the callee
+                         * will clear it. The next caller must wait for
+                         * it to clear before we set it again. This
+                         * will make sure the callee is done with the
+                         * data before a new caller will use it.
+                         */
                         data = kmalloc(sizeof(*data), GFP_ATOMIC);
                         if (data)
                                 data->flags = CSD_FLAG_ALLOC;
-                }
-                if (!data) {
+                        else {
+                                data = &per_cpu(csd_data, me);
+                                while (data->flags & CSD_FLAG_LOCK)
+                                        cpu_relax();
+                                data->flags = CSD_FLAG_LOCK;
+                        }
+                } else {
                         data = &d;
                         data->flags = CSD_FLAG_WAIT;
                 }
diff --git a/kernel/softirq.c b/kernel/softirq.c
index bdbe9de9cd8d..9041ea7948fe 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -626,6 +626,7 @@ static int ksoftirqd(void * __bind_cpu)
                         preempt_enable_no_resched();
                         cond_resched();
                         preempt_disable();
+                        rcu_qsctr_inc((long)__bind_cpu);
                 }
                 preempt_enable();
                 set_current_state(TASK_INTERRUPTIBLE);
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index d9188c66278a..85d5a2455103 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -16,6 +16,7 @@
 #include <linux/lockdep.h>
 #include <linux/notifier.h>
 #include <linux/module.h>
+#include <linux/sysctl.h>
 
 #include <asm/irq_regs.h>
 
@@ -88,6 +89,14 @@ void touch_all_softlockup_watchdogs(void)
 }
 EXPORT_SYMBOL(touch_all_softlockup_watchdogs);
 
+int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
+                             struct file *filp, void __user *buffer,
+                             size_t *lenp, loff_t *ppos)
+{
+        touch_all_softlockup_watchdogs();
+        return proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos);
+}
+
 /*
  * This callback runs from the timer interrupt, and checks
  * whether the watchdog thread has hung or not:
diff --git a/kernel/sys.c b/kernel/sys.c
index e7dc0e10a485..37f458e6882a 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -559,7 +559,7 @@ error:
         abort_creds(new);
         return retval;
 }
-  
+
 /*
  * change the user struct in a credentials set to match the new UID
  */
@@ -571,6 +571,11 @@ static int set_user(struct cred *new)
         if (!new_user)
                 return -EAGAIN;
 
+        if (!task_can_switch_user(new_user, current)) {
+                free_uid(new_user);
+                return -EINVAL;
+        }
+
         if (atomic_read(&new_user->processes) >=
                                 current->signal->rlim[RLIMIT_NPROC].rlim_cur &&
                         new_user != INIT_USER) {
@@ -631,10 +636,11 @@ SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
                         goto error;
         }
 
-        retval = -EAGAIN;
-        if (new->uid != old->uid && set_user(new) < 0)
-                goto error;
-
+        if (new->uid != old->uid) {
+                retval = set_user(new);
+                if (retval < 0)
+                        goto error;
+        }
         if (ruid != (uid_t) -1 ||
             (euid != (uid_t) -1 && euid != old->uid))
                 new->suid = new->euid;
@@ -680,9 +686,10 @@ SYSCALL_DEFINE1(setuid, uid_t, uid)
         retval = -EPERM;
         if (capable(CAP_SETUID)) {
                 new->suid = new->uid = uid;
-                if (uid != old->uid && set_user(new) < 0) {
-                        retval = -EAGAIN;
-                        goto error;
+                if (uid != old->uid) {
+                        retval = set_user(new);
+                        if (retval < 0)
+                                goto error;
                 }
         } else if (uid != old->uid && uid != new->suid) {
                 goto error;
@@ -734,11 +741,13 @@ SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
                         goto error;
         }
 
-        retval = -EAGAIN;
         if (ruid != (uid_t) -1) {
                 new->uid = ruid;
-                if (ruid != old->uid && set_user(new) < 0)
-                        goto error;
+                if (ruid != old->uid) {
+                        retval = set_user(new);
+                        if (retval < 0)
+                                goto error;
+                }
         }
         if (euid != (uid_t) -1)
                 new->euid = euid;
@@ -1525,22 +1534,14 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
                 return -EINVAL;
         if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
                 return -EFAULT;
+        if (new_rlim.rlim_cur > new_rlim.rlim_max)
+                return -EINVAL;
         old_rlim = current->signal->rlim + resource;
         if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
             !capable(CAP_SYS_RESOURCE))
                 return -EPERM;
-
-        if (resource == RLIMIT_NOFILE) {
-                if (new_rlim.rlim_max == RLIM_INFINITY)
-                        new_rlim.rlim_max = sysctl_nr_open;
-                if (new_rlim.rlim_cur == RLIM_INFINITY)
-                        new_rlim.rlim_cur = sysctl_nr_open;
-                if (new_rlim.rlim_max > sysctl_nr_open)
-                        return -EPERM;
-        }
-
-        if (new_rlim.rlim_cur > new_rlim.rlim_max)
-                return -EINVAL;
+        if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > sysctl_nr_open)
+                return -EPERM;
 
         retval = security_task_setrlimit(resource, &new_rlim);
         if (retval)
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 368d1638ee78..c5ef44ff850f 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -101,6 +101,7 @@ static int two = 2;
 
 static int zero;
 static int one = 1;
+static unsigned long one_ul = 1;
 static int one_hundred = 100;
 
 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
@@ -809,7 +810,7 @@ static struct ctl_table kern_table[] = {
                 .data           = &softlockup_thresh,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
-                .proc_handler   = &proc_dointvec_minmax,
+                .proc_handler   = &proc_dosoftlockup_thresh,
                 .strategy       = &sysctl_intvec,
                 .extra1         = &neg_one,
                 .extra2         = &sixty,
@@ -974,7 +975,7 @@ static struct ctl_table vm_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &dirty_background_bytes_handler,
                 .strategy       = &sysctl_intvec,
-                .extra1         = &one,
+                .extra1         = &one_ul,
         },
         {
                 .ctl_name       = VM_DIRTY_RATIO,
@@ -995,7 +996,7 @@ static struct ctl_table vm_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &dirty_bytes_handler,
                 .strategy       = &sysctl_intvec,
-                .extra1         = &one,
+                .extra1         = &one_ul,
         },
         {
                 .procname       = "dirty_writeback_centisecs",
diff --git a/kernel/sysctl_check.c b/kernel/sysctl_check.c
index fafeb48f27c0..b38423ca711a 100644
--- a/kernel/sysctl_check.c
+++ b/kernel/sysctl_check.c
@@ -219,6 +219,7 @@ static const struct trans_ctl_table trans_net_ipv4_conf_vars_table[] = {
         { NET_IPV4_CONF_ARP_IGNORE,             "arp_ignore" },
         { NET_IPV4_CONF_PROMOTE_SECONDARIES,    "promote_secondaries" },
         { NET_IPV4_CONF_ARP_ACCEPT,             "arp_accept" },
+        { NET_IPV4_CONF_ARP_NOTIFY,             "arp_notify" },
         {}
 };
 
diff --git a/kernel/time/Makefile b/kernel/time/Makefile
index 905b0b50792d..0b0a6366c9d4 100644
--- a/kernel/time/Makefile
+++ b/kernel/time/Makefile
@@ -1,4 +1,4 @@
-obj-y += timekeeping.o ntp.o clocksource.o jiffies.o timer_list.o
+obj-y += timekeeping.o ntp.o clocksource.o jiffies.o timer_list.o timecompare.o
 
 obj-$(CONFIG_GENERIC_CLOCKEVENTS_BUILD)         += clockevents.o
 obj-$(CONFIG_GENERIC_CLOCKEVENTS)               += tick-common.o
diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
index ea2f48af83cf..d13be216a790 100644
--- a/kernel/time/clockevents.c
+++ b/kernel/time/clockevents.c
@@ -68,6 +68,17 @@ void clockevents_set_mode(struct clock_event_device *dev,
         if (dev->mode != mode) {
                 dev->set_mode(mode, dev);
                 dev->mode = mode;
+
+                /*
+                 * A nsec2cyc multiplicator of 0 is invalid and we'd crash
+                 * on it, so fix it up and emit a warning:
+                 */
+                if (mode == CLOCK_EVT_MODE_ONESHOT) {
+                        if (unlikely(!dev->mult)) {
+                                dev->mult = 1;
+                                WARN_ON(1);
+                        }
+                }
         }
 }
 
@@ -168,15 +179,6 @@ void clockevents_register_device(struct clock_event_device *dev)
         BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
         BUG_ON(!dev->cpumask);
 
-        /*
-         * A nsec2cyc multiplicator of 0 is invalid and we'd crash
-         * on it, so fix it up and emit a warning:
-         */
-        if (unlikely(!dev->mult)) {
-                dev->mult = 1;
-                WARN_ON(1);
-        }
-
         spin_lock(&clockevents_lock);
 
         list_add(&dev->list, &clockevent_devices);
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index ca89e1593f08..c46c931a7fe7 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -31,6 +31,82 @@
 #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
 #include <linux/tick.h>
 
+void timecounter_init(struct timecounter *tc,
+                      const struct cyclecounter *cc,
+                      u64 start_tstamp)
+{
+        tc->cc = cc;
+        tc->cycle_last = cc->read(cc);
+        tc->nsec = start_tstamp;
+}
+EXPORT_SYMBOL(timecounter_init);
+
+/**
+ * timecounter_read_delta - get nanoseconds since last call of this function
+ * @tc:         Pointer to time counter
+ *
+ * When the underlying cycle counter runs over, this will be handled
+ * correctly as long as it does not run over more than once between
+ * calls.
+ *
+ * The first call to this function for a new time counter initializes
+ * the time tracking and returns an undefined result.
+ */
+static u64 timecounter_read_delta(struct timecounter *tc)
+{
+        cycle_t cycle_now, cycle_delta;
+        u64 ns_offset;
+
+        /* read cycle counter: */
+        cycle_now = tc->cc->read(tc->cc);
+
+        /* calculate the delta since the last timecounter_read_delta(): */
+        cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask;
+
+        /* convert to nanoseconds: */
+        ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta);
+
+        /* update time stamp of timecounter_read_delta() call: */
+        tc->cycle_last = cycle_now;
+
+        return ns_offset;
+}
+
+u64 timecounter_read(struct timecounter *tc)
+{
+        u64 nsec;
+
+        /* increment time by nanoseconds since last call */
+        nsec = timecounter_read_delta(tc);
+        nsec += tc->nsec;
+        tc->nsec = nsec;
+
+        return nsec;
+}
+EXPORT_SYMBOL(timecounter_read);
+
+u64 timecounter_cyc2time(struct timecounter *tc,
+                         cycle_t cycle_tstamp)
+{
+        u64 cycle_delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask;
+        u64 nsec;
+
+        /*
+         * Instead of always treating cycle_tstamp as more recent
+         * than tc->cycle_last, detect when it is too far in the
+         * future and treat it as old time stamp instead.
+         */
+        if (cycle_delta > tc->cc->mask / 2) {
+                cycle_delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask;
+                nsec = tc->nsec - cyclecounter_cyc2ns(tc->cc, cycle_delta);
+        } else {
+                nsec = cyclecounter_cyc2ns(tc->cc, cycle_delta) + tc->nsec;
+        }
+
+        return nsec;
+}
+EXPORT_SYMBOL(timecounter_cyc2time);
+
 /* XXX - Would like a better way for initializing curr_clocksource */
 extern struct clocksource clocksource_jiffies;
 
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index f5f793d92415..7fc64375ff43 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -1,71 +1,129 @@
 /*
- * linux/kernel/time/ntp.c
- *
  * NTP state machine interfaces and logic.
  *
  * This code was mainly moved from kernel/timer.c and kernel/time.c
  * Please see those files for relevant copyright info and historical
  * changelogs.
  */
-
-#include <linux/mm.h>
-#include <linux/time.h>
-#include <linux/timex.h>
-#include <linux/jiffies.h>
-#include <linux/hrtimer.h>
 #include <linux/capability.h>
-#include <linux/math64.h>
 #include <linux/clocksource.h>
 #include <linux/workqueue.h>
-#include <asm/timex.h>
+#include <linux/hrtimer.h>
+#include <linux/jiffies.h>
+#include <linux/math64.h>
+#include <linux/timex.h>
+#include <linux/time.h>
+#include <linux/mm.h>
 
 /*
- * Timekeeping variables
+ * NTP timekeeping variables:
  */
-unsigned long tick_usec = TICK_USEC;            /* USER_HZ period (usec) */
-unsigned long tick_nsec;                        /* ACTHZ period (nsec) */
-u64 tick_length;
-static u64 tick_length_base;
 
-static struct hrtimer leap_timer;
+/* USER_HZ period (usecs): */
+unsigned long                   tick_usec = TICK_USEC;
 
-#define MAX_TICKADJ             500             /* microsecs */
-#define MAX_TICKADJ_SCALED      (((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \
-                                  NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
+/* ACTHZ period (nsecs): */
+unsigned long                   tick_nsec;
+
+u64                             tick_length;
+static u64                      tick_length_base;
+
+static struct hrtimer           leap_timer;
+
+#define MAX_TICKADJ             500LL           /* usecs */
+#define MAX_TICKADJ_SCALED \
+        (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
 
 /*
  * phase-lock loop variables
  */
-/* TIME_ERROR prevents overwriting the CMOS clock */
-static int time_state = TIME_OK;        /* clock synchronization status */
-int time_status = STA_UNSYNC;           /* clock status bits            */
-static long time_tai;                   /* TAI offset (s)               */
-static s64 time_offset;                 /* time adjustment (ns)         */
-static long time_constant = 2;          /* pll time constant            */
-long time_maxerror = NTP_PHASE_LIMIT;   /* maximum error (us)           */
-long time_esterror = NTP_PHASE_LIMIT;   /* estimated error (us)         */
-static s64 time_freq;                   /* frequency offset (scaled ns/s)*/
-static long time_reftime;               /* time at last adjustment (s)  */
-long time_adjust;
-static long ntp_tick_adj;
 
+/*
+ * clock synchronization status
+ *
+ * (TIME_ERROR prevents overwriting the CMOS clock)
+ */
+static int                      time_state = TIME_OK;
+
+/* clock status bits:                                                   */
+int                             time_status = STA_UNSYNC;
+
+/* TAI offset (secs):                                                   */
+static long                     time_tai;
+
+/* time adjustment (nsecs):                                             */
+static s64                      time_offset;
+
+/* pll time constant:                                                   */
+static long                     time_constant = 2;
+
+/* maximum error (usecs):                                               */
+long                            time_maxerror = NTP_PHASE_LIMIT;
+
+/* estimated error (usecs):                                             */
+long                            time_esterror = NTP_PHASE_LIMIT;
+
+/* frequency offset (scaled nsecs/secs):                                */
+static s64                      time_freq;
+
+/* time at last adjustment (secs):                                      */
+static long                     time_reftime;
+
+long                            time_adjust;
+
+/* constant (boot-param configurable) NTP tick adjustment (upscaled)    */
+static s64                      ntp_tick_adj;
+
+/*
+ * NTP methods:
+ */
+
+/*
+ * Update (tick_length, tick_length_base, tick_nsec), based
+ * on (tick_usec, ntp_tick_adj, time_freq):
+ */
 static void ntp_update_frequency(void)
 {
-        u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
-                                << NTP_SCALE_SHIFT;
-        second_length += (s64)ntp_tick_adj << NTP_SCALE_SHIFT;
-        second_length += time_freq;
+        u64 second_length;
+        u64 new_base;
+
+        second_length            = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
+                                                << NTP_SCALE_SHIFT;
+
+        second_length           += ntp_tick_adj;
+        second_length           += time_freq;
 
-        tick_length_base = second_length;
+        tick_nsec                = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
+        new_base                 = div_u64(second_length, NTP_INTERVAL_FREQ);
 
-        tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
-        tick_length_base = div_u64(tick_length_base, NTP_INTERVAL_FREQ);
+        /*
+         * Don't wait for the next second_overflow, apply
+         * the change to the tick length immediately:
+         */
+        tick_length             += new_base - tick_length_base;
+        tick_length_base         = new_base;
+}
+
+static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
+{
+        time_status &= ~STA_MODE;
+
+        if (secs < MINSEC)
+                return 0;
+
+        if (!(time_status & STA_FLL) && (secs <= MAXSEC))
+                return 0;
+
+        time_status |= STA_MODE;
+
+        return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
 }
 
 static void ntp_update_offset(long offset)
 {
-        long mtemp;
         s64 freq_adj;
+        s64 offset64;
+        long secs;
 
         if (!(time_status & STA_PLL))
                 return;
@@ -84,24 +142,23 @@ static void ntp_update_offset(long offset)
          * Select how the frequency is to be controlled
          * and in which mode (PLL or FLL).
          */
-        if (time_status & STA_FREQHOLD || time_reftime == 0)
-                time_reftime = xtime.tv_sec;
-        mtemp = xtime.tv_sec - time_reftime;
+        secs = xtime.tv_sec - time_reftime;
+        if (unlikely(time_status & STA_FREQHOLD))
+                secs = 0;
+
         time_reftime = xtime.tv_sec;
 
-        freq_adj = (s64)offset * mtemp;
-        freq_adj <<= NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant);
-        time_status &= ~STA_MODE;
-        if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) {
-                freq_adj += div_s64((s64)offset << (NTP_SCALE_SHIFT - SHIFT_FLL),
-                                    mtemp);
-                time_status |= STA_MODE;
-        }
-        freq_adj += time_freq;
-        freq_adj = min(freq_adj, MAXFREQ_SCALED);
-        time_freq = max(freq_adj, -MAXFREQ_SCALED);
+        offset64    = offset;
+        freq_adj    = (offset64 * secs) <<
+                        (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
 
-        time_offset = div_s64((s64)offset << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
+        freq_adj    += ntp_update_offset_fll(offset64, secs);
+
+        freq_adj    = min(freq_adj + time_freq, MAXFREQ_SCALED);
+
+        time_freq   = max(freq_adj, -MAXFREQ_SCALED);
+
+        time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
 }
 
 /**
@@ -111,15 +168,15 @@ static void ntp_update_offset(long offset)
  */
 void ntp_clear(void)
 {
-        time_adjust = 0;                /* stop active adjtime() */
-        time_status |= STA_UNSYNC;
-        time_maxerror = NTP_PHASE_LIMIT;
-        time_esterror = NTP_PHASE_LIMIT;
+        time_adjust     = 0;            /* stop active adjtime() */
+        time_status     |= STA_UNSYNC;
+        time_maxerror   = NTP_PHASE_LIMIT;
+        time_esterror   = NTP_PHASE_LIMIT;
 
         ntp_update_frequency();
 
-        tick_length = tick_length_base;
-        time_offset = 0;
+        tick_length     = tick_length_base;
+        time_offset     = 0;
 }
 
 /*
@@ -140,8 +197,8 @@ static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
                 xtime.tv_sec--;
                 wall_to_monotonic.tv_sec++;
                 time_state = TIME_OOP;
-                printk(KERN_NOTICE "Clock: "
-                       "inserting leap second 23:59:60 UTC\n");
+                printk(KERN_NOTICE
+                        "Clock: inserting leap second 23:59:60 UTC\n");
                 hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
                 res = HRTIMER_RESTART;
                 break;
@@ -150,8 +207,8 @@ static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
                 time_tai--;
                 wall_to_monotonic.tv_sec--;
                 time_state = TIME_WAIT;
-                printk(KERN_NOTICE "Clock: "
-                       "deleting leap second 23:59:59 UTC\n");
+                printk(KERN_NOTICE
+                        "Clock: deleting leap second 23:59:59 UTC\n");
                 break;
         case TIME_OOP:
                 time_tai++;
@@ -179,7 +236,7 @@ static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
  */
 void second_overflow(void)
 {
-        s64 time_adj;
+        s64 delta;
 
         /* Bump the maxerror field */
         time_maxerror += MAXFREQ / NSEC_PER_USEC;
@@ -192,24 +249,30 @@ void second_overflow(void)
          * Compute the phase adjustment for the next second. The offset is
          * reduced by a fixed factor times the time constant.
          */
-        tick_length = tick_length_base;
-        time_adj = shift_right(time_offset, SHIFT_PLL + time_constant);
-        time_offset -= time_adj;
-        tick_length += time_adj;
-
-        if (unlikely(time_adjust)) {
-                if (time_adjust > MAX_TICKADJ) {
-                        time_adjust -= MAX_TICKADJ;
-                        tick_length += MAX_TICKADJ_SCALED;
-                } else if (time_adjust < -MAX_TICKADJ) {
-                        time_adjust += MAX_TICKADJ;
-                        tick_length -= MAX_TICKADJ_SCALED;
-                } else {
-                        tick_length += (s64)(time_adjust * NSEC_PER_USEC /
-                                        NTP_INTERVAL_FREQ) << NTP_SCALE_SHIFT;
-                        time_adjust = 0;
-                }
+        tick_length      = tick_length_base;
+
+        delta            = shift_right(time_offset, SHIFT_PLL + time_constant);
+        time_offset     -= delta;
+        tick_length     += delta;
+
+        if (!time_adjust)
+                return;
+
+        if (time_adjust > MAX_TICKADJ) {
+                time_adjust -= MAX_TICKADJ;
+                tick_length += MAX_TICKADJ_SCALED;
+                return;
         }
+
+        if (time_adjust < -MAX_TICKADJ) {
+                time_adjust += MAX_TICKADJ;
+                tick_length -= MAX_TICKADJ_SCALED;
+                return;
+        }
+
+        tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
+                                                         << NTP_SCALE_SHIFT;
+        time_adjust = 0;
 }
 
 #ifdef CONFIG_GENERIC_CMOS_UPDATE
@@ -233,12 +296,13 @@ static void sync_cmos_clock(struct work_struct *work)
          * This code is run on a timer.  If the clock is set, that timer
          * may not expire at the correct time.  Thus, we adjust...
          */
-        if (!ntp_synced())
+        if (!ntp_synced()) {
                 /*
                  * Not synced, exit, do not restart a timer (if one is
                  * running, let it run out).
                  */
                 return;
+        }
 
         getnstimeofday(&now);
         if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
@@ -270,7 +334,116 @@ static void notify_cmos_timer(void)
 static inline void notify_cmos_timer(void) { }
 #endif
 
-/* adjtimex mainly allows reading (and writing, if superuser) of
+/*
+ * Start the leap seconds timer:
+ */
+static inline void ntp_start_leap_timer(struct timespec *ts)
+{
+        long now = ts->tv_sec;
+
+        if (time_status & STA_INS) {
+                time_state = TIME_INS;
+                now += 86400 - now % 86400;
+                hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
+
+                return;
+        }
+
+        if (time_status & STA_DEL) {
+                time_state = TIME_DEL;
+                now += 86400 - (now + 1) % 86400;
+                hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
+        }
+}
+
+/*
+ * Propagate a new txc->status value into the NTP state:
+ */
+static inline void process_adj_status(struct timex *txc, struct timespec *ts)
+{
+        if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
+                time_state = TIME_OK;
+                time_status = STA_UNSYNC;
+        }
+
+        /*
+         * If we turn on PLL adjustments then reset the
+         * reference time to current time.
+         */
+        if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
+                time_reftime = xtime.tv_sec;
+
+        /* only set allowed bits */
+        time_status &= STA_RONLY;
+        time_status |= txc->status & ~STA_RONLY;
+
+        switch (time_state) {
+        case TIME_OK:
+                ntp_start_leap_timer(ts);
+                break;
+        case TIME_INS:
+        case TIME_DEL:
+                time_state = TIME_OK;
+                ntp_start_leap_timer(ts);
+        case TIME_WAIT:
+                if (!(time_status & (STA_INS | STA_DEL)))
+                        time_state = TIME_OK;
+                break;
+        case TIME_OOP:
+                hrtimer_restart(&leap_timer);
+                break;
+        }
+}
+/*
+ * Called with the xtime lock held, so we can access and modify
+ * all the global NTP state:
+ */
+static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts)
+{
+        if (txc->modes & ADJ_STATUS)
+                process_adj_status(txc, ts);
+
+        if (txc->modes & ADJ_NANO)
+                time_status |= STA_NANO;
+
+        if (txc->modes & ADJ_MICRO)
+                time_status &= ~STA_NANO;
+
+        if (txc->modes & ADJ_FREQUENCY) {
+                time_freq = txc->freq * PPM_SCALE;
+                time_freq = min(time_freq, MAXFREQ_SCALED);
+                time_freq = max(time_freq, -MAXFREQ_SCALED);
+        }
+
+        if (txc->modes & ADJ_MAXERROR)
+                time_maxerror = txc->maxerror;
+
+        if (txc->modes & ADJ_ESTERROR)
+                time_esterror = txc->esterror;
+
+        if (txc->modes & ADJ_TIMECONST) {
+                time_constant = txc->constant;
+                if (!(time_status & STA_NANO))
+                        time_constant += 4;
+                time_constant = min(time_constant, (long)MAXTC);
+                time_constant = max(time_constant, 0l);
+        }
+
+        if (txc->modes & ADJ_TAI && txc->constant > 0)
+                time_tai = txc->constant;
+
+        if (txc->modes & ADJ_OFFSET)
+                ntp_update_offset(txc->offset);
+
+        if (txc->modes & ADJ_TICK)
+                tick_usec = txc->tick;
+
+        if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
+                ntp_update_frequency();
+}
+
+/*
+ * adjtimex mainly allows reading (and writing, if superuser) of
  * kernel time-keeping variables. used by xntpd.
  */
 int do_adjtimex(struct timex *txc)
@@ -291,11 +464,14 @@ int do_adjtimex(struct timex *txc)
                  if (txc->modes && !capable(CAP_SYS_TIME))
                         return -EPERM;
 
-                /* if the quartz is off by more than 10% something is VERY wrong! */
+                /*
+                 * if the quartz is off by more than 10% then
+                 * something is VERY wrong!
+                 */
                 if (txc->modes & ADJ_TICK &&
                     (txc->tick <  900000/USER_HZ ||
                      txc->tick > 1100000/USER_HZ))
-                                return -EINVAL;
+                        return -EINVAL;
 
                 if (txc->modes & ADJ_STATUS && time_state != TIME_OK)
                         hrtimer_cancel(&leap_timer);
@@ -305,7 +481,6 @@ int do_adjtimex(struct timex *txc)
 
         write_seqlock_irq(&xtime_lock);
 
-        /* If there are input parameters, then process them */
         if (txc->modes & ADJ_ADJTIME) {
                 long save_adjust = time_adjust;
 
@@ -315,98 +490,24 @@ int do_adjtimex(struct timex *txc)
                         ntp_update_frequency();
                 }
                 txc->offset = save_adjust;
-                goto adj_done;
-        }
-        if (txc->modes) {
-                long sec;
-
-                if (txc->modes & ADJ_STATUS) {
-                        if ((time_status & STA_PLL) &&
-                            !(txc->status & STA_PLL)) {
-                                time_state = TIME_OK;
-                                time_status = STA_UNSYNC;
-                        }
-                        /* only set allowed bits */
-                        time_status &= STA_RONLY;
-                        time_status |= txc->status & ~STA_RONLY;
-
-                        switch (time_state) {
-                        case TIME_OK:
-                        start_timer:
-                                sec = ts.tv_sec;
-                                if (time_status & STA_INS) {
-                                        time_state = TIME_INS;
-                                        sec += 86400 - sec % 86400;
-                                        hrtimer_start(&leap_timer, ktime_set(sec, 0), HRTIMER_MODE_ABS);
-                                } else if (time_status & STA_DEL) {
-                                        time_state = TIME_DEL;
-                                        sec += 86400 - (sec + 1) % 86400;
-                                        hrtimer_start(&leap_timer, ktime_set(sec, 0), HRTIMER_MODE_ABS);
-                                }
-                                break;
-                        case TIME_INS:
-                        case TIME_DEL:
-                                time_state = TIME_OK;
-                                goto start_timer;
-                                break;
-                        case TIME_WAIT:
-                                if (!(time_status & (STA_INS | STA_DEL)))
-                                        time_state = TIME_OK;
-                                break;
-                        case TIME_OOP:
-                                hrtimer_restart(&leap_timer);
-                                break;
-                        }
-                }
-
-                if (txc->modes & ADJ_NANO)
-                        time_status |= STA_NANO;
-                if (txc->modes & ADJ_MICRO)
-                        time_status &= ~STA_NANO;
-
-                if (txc->modes & ADJ_FREQUENCY) {
-                        time_freq = (s64)txc->freq * PPM_SCALE;
-                        time_freq = min(time_freq, MAXFREQ_SCALED);
-                        time_freq = max(time_freq, -MAXFREQ_SCALED);
-                }
-
-                if (txc->modes & ADJ_MAXERROR)
-                        time_maxerror = txc->maxerror;
-                if (txc->modes & ADJ_ESTERROR)
-                        time_esterror = txc->esterror;
-
-                if (txc->modes & ADJ_TIMECONST) {
-                        time_constant = txc->constant;
-                        if (!(time_status & STA_NANO))
-                                time_constant += 4;
-                        time_constant = min(time_constant, (long)MAXTC);
-                        time_constant = max(time_constant, 0l);
-                }
-
-                if (txc->modes & ADJ_TAI && txc->constant > 0)
-                        time_tai = txc->constant;
-
-                if (txc->modes & ADJ_OFFSET)
-                        ntp_update_offset(txc->offset);
-                if (txc->modes & ADJ_TICK)
-                        tick_usec = txc->tick;
+        } else {
 
-                if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
-                        ntp_update_frequency();
-        }
+                /* If there are input parameters, then process them: */
+                if (txc->modes)
+                        process_adjtimex_modes(txc, &ts);
 
-        txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
+                txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
                                   NTP_SCALE_SHIFT);
-        if (!(time_status & STA_NANO))
-                txc->offset /= NSEC_PER_USEC;
+                if (!(time_status & STA_NANO))
+                        txc->offset /= NSEC_PER_USEC;
+        }
 
-adj_done:
         result = time_state;    /* mostly `TIME_OK' */
         if (time_status & (STA_UNSYNC|STA_CLOCKERR))
                 result = TIME_ERROR;
 
         txc->freq          = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
-                                         (s64)PPM_SCALE_INV, NTP_SCALE_SHIFT);
+                                         PPM_SCALE_INV, NTP_SCALE_SHIFT);
         txc->maxerror      = time_maxerror;
         txc->esterror      = time_esterror;
         txc->status        = time_status;
@@ -425,6 +526,7 @@ adj_done:
         txc->calcnt        = 0;
         txc->errcnt        = 0;
         txc->stbcnt        = 0;
+
         write_sequnlock_irq(&xtime_lock);
 
         txc->time.tv_sec = ts.tv_sec;
@@ -440,6 +542,8 @@ adj_done:
 static int __init ntp_tick_adj_setup(char *str)
 {
         ntp_tick_adj = simple_strtol(str, NULL, 0);
+        ntp_tick_adj <<= NTP_SCALE_SHIFT;
+
         return 1;
 }
 
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 63e05d423a09..21a5ca849514 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -274,6 +274,21 @@ out_bc:
 }
 
 /*
+ * Transfer the do_timer job away from a dying cpu.
+ *
+ * Called with interrupts disabled.
+ */
+static void tick_handover_do_timer(int *cpup)
+{
+        if (*cpup == tick_do_timer_cpu) {
+                int cpu = cpumask_first(cpu_online_mask);
+
+                tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
+                        TICK_DO_TIMER_NONE;
+        }
+}
+
+/*
  * Shutdown an event device on a given cpu:
  *
  * This is called on a life CPU, when a CPU is dead. So we cannot
@@ -297,13 +312,6 @@ static void tick_shutdown(unsigned int *cpup)
                 clockevents_exchange_device(dev, NULL);
                 td->evtdev = NULL;
         }
-        /* Transfer the do_timer job away from this cpu */
-        if (*cpup == tick_do_timer_cpu) {
-                int cpu = cpumask_first(cpu_online_mask);
-
-                tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
-                        TICK_DO_TIMER_NONE;
-        }
         spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 
@@ -357,6 +365,10 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason,
                 tick_broadcast_oneshot_control(reason);
                 break;
 
+        case CLOCK_EVT_NOTIFY_CPU_DYING:
+                tick_handover_do_timer(dev);
+                break;
+
         case CLOCK_EVT_NOTIFY_CPU_DEAD:
                 tick_shutdown_broadcast_oneshot(dev);
                 tick_shutdown_broadcast(dev);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 1b6c05bd0d0a..d3f1ef4d5cbe 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -134,7 +134,7 @@ __setup("nohz=", setup_tick_nohz);
  * value. We do this unconditionally on any cpu, as we don't know whether the
  * cpu, which has the update task assigned is in a long sleep.
  */
-void tick_nohz_update_jiffies(void)
+static void tick_nohz_update_jiffies(void)
 {
         int cpu = smp_processor_id();
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
diff --git a/kernel/time/timecompare.c b/kernel/time/timecompare.c
new file mode 100644
index 000000000000..71e7f1a19156
--- /dev/null
+++ b/kernel/time/timecompare.c
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2009 Intel Corporation.
+ * Author: Patrick Ohly <patrick.ohly@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/timecompare.h>
+#include <linux/module.h>
+#include <linux/math64.h>
+
+/*
+ * fixed point arithmetic scale factor for skew
+ *
+ * Usually one would measure skew in ppb (parts per billion, 1e9), but
+ * using a factor of 2 simplifies the math.
+ */
+#define TIMECOMPARE_SKEW_RESOLUTION (((s64)1)<<30)
+
+ktime_t timecompare_transform(struct timecompare *sync,
+                              u64 source_tstamp)
+{
+        u64 nsec;
+
+        nsec = source_tstamp + sync->offset;
+        nsec += (s64)(source_tstamp - sync->last_update) * sync->skew /
+                TIMECOMPARE_SKEW_RESOLUTION;
+
+        return ns_to_ktime(nsec);
+}
+EXPORT_SYMBOL(timecompare_transform);
+
+int timecompare_offset(struct timecompare *sync,
+                       s64 *offset,
+                       u64 *source_tstamp)
+{
+        u64 start_source = 0, end_source = 0;
+        struct {
+                s64 offset;
+                s64 duration_target;
+        } buffer[10], sample, *samples;
+        int counter = 0, i;
+        int used;
+        int index;
+        int num_samples = sync->num_samples;
+
+        if (num_samples > sizeof(buffer)/sizeof(buffer[0])) {
+                samples = kmalloc(sizeof(*samples) * num_samples, GFP_ATOMIC);
+                if (!samples) {
+                        samples = buffer;
+                        num_samples = sizeof(buffer)/sizeof(buffer[0]);
+                }
+        } else {
+                samples = buffer;
+        }
+
+        /* run until we have enough valid samples, but do not try forever */
+        i = 0;
+        counter = 0;
+        while (1) {
+                u64 ts;
+                ktime_t start, end;
+
+                start = sync->target();
+                ts = timecounter_read(sync->source);
+                end = sync->target();
+
+                if (!i)
+                        start_source = ts;
+
+                /* ignore negative durations */
+                sample.duration_target = ktime_to_ns(ktime_sub(end, start));
+                if (sample.duration_target >= 0) {
+                        /*
+                         * assume symetric delay to and from source:
+                         * average target time corresponds to measured
+                         * source time
+                         */
+                        sample.offset =
+                                ktime_to_ns(ktime_add(end, start)) / 2 -
+                                ts;
+
+                        /* simple insertion sort based on duration */
+                        index = counter - 1;
+                        while (index >= 0) {
+                                if (samples[index].duration_target <
+                                    sample.duration_target)
+                                        break;
+                                samples[index + 1] = samples[index];
+                                index--;
+                        }
+                        samples[index + 1] = sample;
+                        counter++;
+                }
+
+                i++;
+                if (counter >= num_samples || i >= 100000) {
+                        end_source = ts;
+                        break;
+                }
+        }
+
+        *source_tstamp = (end_source + start_source) / 2;
+
+        /* remove outliers by only using 75% of the samples */
+        used = counter * 3 / 4;
+        if (!used)
+                used = counter;
+        if (used) {
+                /* calculate average */
+                s64 off = 0;
+                for (index = 0; index < used; index++)
+                        off += samples[index].offset;
+                *offset = div_s64(off, used);
+        }
+
+        if (samples && samples != buffer)
+                kfree(samples);
+
+        return used;
+}
+EXPORT_SYMBOL(timecompare_offset);
+
+void __timecompare_update(struct timecompare *sync,
+                          u64 source_tstamp)
+{
+        s64 offset;
+        u64 average_time;
+
+        if (!timecompare_offset(sync, &offset, &average_time))
+                return;
+
+        if (!sync->last_update) {
+                sync->last_update = average_time;
+                sync->offset = offset;
+                sync->skew = 0;
+        } else {
+                s64 delta_nsec = average_time - sync->last_update;
+
+                /* avoid division by negative or small deltas */
+                if (delta_nsec >= 10000) {
+                        s64 delta_offset_nsec = offset - sync->offset;
+                        s64 skew; /* delta_offset_nsec *
+                                     TIMECOMPARE_SKEW_RESOLUTION /
+                                     delta_nsec */
+                        u64 divisor;
+
+                        /* div_s64() is limited to 32 bit divisor */
+                        skew = delta_offset_nsec * TIMECOMPARE_SKEW_RESOLUTION;
+                        divisor = delta_nsec;
+                        while (unlikely(divisor >= ((s64)1) << 32)) {
+                                /* divide both by 2; beware, right shift
+                                   of negative value has undefined
+                                   behavior and can only be used for
+                                   the positive divisor */
+                                skew = div_s64(skew, 2);
+                                divisor >>= 1;
+                        }
+                        skew = div_s64(skew, divisor);
+
+                        /*
+                         * Calculate new overall skew as 4/16 the
+                         * old value and 12/16 the new one. This is
+                         * a rather arbitrary tradeoff between
+                         * only using the latest measurement (0/16 and
+                         * 16/16) and even more weight on past measurements.
+                         */
+#define TIMECOMPARE_NEW_SKEW_PER_16 12
+                        sync->skew =
+                                div_s64((16 - TIMECOMPARE_NEW_SKEW_PER_16) *
+                                        sync->skew +
+                                        TIMECOMPARE_NEW_SKEW_PER_16 * skew,
+                                        16);
+                        sync->last_update = average_time;
+                        sync->offset = offset;
+                }
+        }
+}
+EXPORT_SYMBOL(__timecompare_update);
diff --git a/kernel/timer.c b/kernel/timer.c
index 13dd64fe143d..9b77fc9a9ac8 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -589,11 +589,14 @@ static struct tvec_base *lock_timer_base(struct timer_list *timer,
         }
 }
 
-int __mod_timer(struct timer_list *timer, unsigned long expires)
+static inline int
+__mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
 {
         struct tvec_base *base, *new_base;
         unsigned long flags;
-        int ret = 0;
+        int ret;
+
+        ret = 0;
 
         timer_stats_timer_set_start_info(timer);
         BUG_ON(!timer->function);
@@ -603,6 +606,9 @@ int __mod_timer(struct timer_list *timer, unsigned long expires)
         if (timer_pending(timer)) {
                 detach_timer(timer, 0);
                 ret = 1;
+        } else {
+                if (pending_only)
+                        goto out_unlock;
         }
 
         debug_timer_activate(timer);
@@ -629,42 +635,28 @@ int __mod_timer(struct timer_list *timer, unsigned long expires)
 
         timer->expires = expires;
         internal_add_timer(base, timer);
+
+out_unlock:
         spin_unlock_irqrestore(&base->lock, flags);
 
         return ret;
 }
 
-EXPORT_SYMBOL(__mod_timer);
-
 /**
- * add_timer_on - start a timer on a particular CPU
- * @timer: the timer to be added
- * @cpu: the CPU to start it on
+ * mod_timer_pending - modify a pending timer's timeout
+ * @timer: the pending timer to be modified
+ * @expires: new timeout in jiffies
  *
- * This is not very scalable on SMP. Double adds are not possible.
+ * mod_timer_pending() is the same for pending timers as mod_timer(),
+ * but will not re-activate and modify already deleted timers.
+ *
+ * It is useful for unserialized use of timers.
  */
-void add_timer_on(struct timer_list *timer, int cpu)
+int mod_timer_pending(struct timer_list *timer, unsigned long expires)
 {
-        struct tvec_base *base = per_cpu(tvec_bases, cpu);
-        unsigned long flags;
-
-        timer_stats_timer_set_start_info(timer);
-        BUG_ON(timer_pending(timer) || !timer->function);
-        spin_lock_irqsave(&base->lock, flags);
-        timer_set_base(timer, base);
-        debug_timer_activate(timer);
-        internal_add_timer(base, timer);
-        /*
-         * Check whether the other CPU is idle and needs to be
-         * triggered to reevaluate the timer wheel when nohz is
-         * active. We are protected against the other CPU fiddling
-         * with the timer by holding the timer base lock. This also
-         * makes sure that a CPU on the way to idle can not evaluate
-         * the timer wheel.
-         */
-        wake_up_idle_cpu(cpu);
-        spin_unlock_irqrestore(&base->lock, flags);
+        return __mod_timer(timer, expires, true);
 }
+EXPORT_SYMBOL(mod_timer_pending);
 
 /**
  * mod_timer - modify a timer's timeout
@@ -688,9 +680,6 @@ void add_timer_on(struct timer_list *timer, int cpu)
  */
 int mod_timer(struct timer_list *timer, unsigned long expires)
 {
-        BUG_ON(!timer->function);
-
-        timer_stats_timer_set_start_info(timer);
         /*
          * This is a common optimization triggered by the
          * networking code - if the timer is re-modified
@@ -699,12 +688,62 @@ int mod_timer(struct timer_list *timer, unsigned long expires)
         if (timer->expires == expires && timer_pending(timer))
                 return 1;
 
-        return __mod_timer(timer, expires);
+        return __mod_timer(timer, expires, false);
 }
-
 EXPORT_SYMBOL(mod_timer);
 
 /**
+ * add_timer - start a timer
+ * @timer: the timer to be added
+ *
+ * The kernel will do a ->function(->data) callback from the
+ * timer interrupt at the ->expires point in the future. The
+ * current time is 'jiffies'.
+ *
+ * The timer's ->expires, ->function (and if the handler uses it, ->data)
+ * fields must be set prior calling this function.
+ *
+ * Timers with an ->expires field in the past will be executed in the next
+ * timer tick.
+ */
+void add_timer(struct timer_list *timer)
+{
+        BUG_ON(timer_pending(timer));
+        mod_timer(timer, timer->expires);
+}
+EXPORT_SYMBOL(add_timer);
+
+/**
+ * add_timer_on - start a timer on a particular CPU
+ * @timer: the timer to be added
+ * @cpu: the CPU to start it on
+ *
+ * This is not very scalable on SMP. Double adds are not possible.
+ */
+void add_timer_on(struct timer_list *timer, int cpu)
+{
+        struct tvec_base *base = per_cpu(tvec_bases, cpu);
+        unsigned long flags;
+
+        timer_stats_timer_set_start_info(timer);
+        BUG_ON(timer_pending(timer) || !timer->function);
+        spin_lock_irqsave(&base->lock, flags);
+        timer_set_base(timer, base);
+        debug_timer_activate(timer);
+        internal_add_timer(base, timer);
+        /*
+         * Check whether the other CPU is idle and needs to be
+         * triggered to reevaluate the timer wheel when nohz is
+         * active. We are protected against the other CPU fiddling
+         * with the timer by holding the timer base lock. This also
+         * makes sure that a CPU on the way to idle can not evaluate
+         * the timer wheel.
+         */
+        wake_up_idle_cpu(cpu);
+        spin_unlock_irqrestore(&base->lock, flags);
+}
+
+/**
  * del_timer - deactive a timer.
  * @timer: the timer to be deactivated
  *
@@ -733,7 +772,6 @@ int del_timer(struct timer_list *timer)
 
         return ret;
 }
-
 EXPORT_SYMBOL(del_timer);
 
 #ifdef CONFIG_SMP
@@ -767,7 +805,6 @@ out:
 
         return ret;
 }
-
 EXPORT_SYMBOL(try_to_del_timer_sync);
 
 /**
@@ -796,7 +833,6 @@ int del_timer_sync(struct timer_list *timer)
                 cpu_relax();
         }
 }
-
 EXPORT_SYMBOL(del_timer_sync);
 #endif
 
@@ -1268,7 +1304,7 @@ signed long __sched schedule_timeout(signed long timeout)
         expire = timeout + jiffies;
 
         setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
-        __mod_timer(&timer, expire);
+        __mod_timer(&timer, expire, false);
         schedule();
         del_singleshot_timer_sync(&timer);
 
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index e2a4ff6fc3a6..34e707e5ab87 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -52,6 +52,7 @@ config FUNCTION_TRACER
         depends on HAVE_FUNCTION_TRACER
         depends on DEBUG_KERNEL
         select FRAME_POINTER
+        select KALLSYMS
         select TRACING
         select CONTEXT_SWITCH_TRACER
         help
@@ -238,6 +239,7 @@ config STACK_TRACER
         depends on DEBUG_KERNEL
         select FUNCTION_TRACER
         select STACKTRACE
+        select KALLSYMS
         help
           This special tracer records the maximum stack footprint of the
           kernel and displays it in debugfs/tracing/stack_trace.
@@ -302,4 +304,27 @@ config FTRACE_STARTUP_TEST
           functioning properly. It will do tests on all the configured
           tracers of ftrace.
 
+config MMIOTRACE
+        bool "Memory mapped IO tracing"
+        depends on HAVE_MMIOTRACE_SUPPORT && DEBUG_KERNEL && PCI
+        select TRACING
+        help
+          Mmiotrace traces Memory Mapped I/O access and is meant for
+          debugging and reverse engineering. It is called from the ioremap
+          implementation and works via page faults. Tracing is disabled by
+          default and can be enabled at run-time.
+
+          See Documentation/tracers/mmiotrace.txt.
+          If you are not helping to develop drivers, say N.
+
+config MMIOTRACE_TEST
+        tristate "Test module for mmiotrace"
+        depends on MMIOTRACE && m
+        help
+          This is a dumb module for testing mmiotrace. It is very dangerous
+          as it will write garbage to IO memory starting at a given address.
+          However, it should be safe to use on e.g. unused portion of VRAM.
+
+          Say N, unless you absolutely know what you are doing.
+
 endmenu
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 2f32969c09df..fdf913dfc7e8 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -17,6 +17,7 @@
 #include <linux/clocksource.h>
 #include <linux/kallsyms.h>
 #include <linux/seq_file.h>
+#include <linux/suspend.h>
 #include <linux/debugfs.h>
 #include <linux/hardirq.h>
 #include <linux/kthread.h>
@@ -1736,9 +1737,12 @@ static void clear_ftrace_pid(struct pid *pid)
 {
         struct task_struct *p;
 
+        rcu_read_lock();
         do_each_pid_task(pid, PIDTYPE_PID, p) {
                 clear_tsk_trace_trace(p);
         } while_each_pid_task(pid, PIDTYPE_PID, p);
+        rcu_read_unlock();
+
         put_pid(pid);
 }
 
@@ -1746,9 +1750,11 @@ static void set_ftrace_pid(struct pid *pid)
 {
         struct task_struct *p;
 
+        rcu_read_lock();
         do_each_pid_task(pid, PIDTYPE_PID, p) {
                 set_tsk_trace_trace(p);
         } while_each_pid_task(pid, PIDTYPE_PID, p);
+        rcu_read_unlock();
 }
 
 static void clear_ftrace_pid_task(struct pid **pid)
@@ -1965,6 +1971,7 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 
 static atomic_t ftrace_graph_active;
+static struct notifier_block ftrace_suspend_notifier;
 
 int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)
 {
@@ -2026,7 +2033,7 @@ free:
 static int start_graph_tracing(void)
 {
         struct ftrace_ret_stack **ret_stack_list;
-        int ret;
+        int ret, cpu;
 
         ret_stack_list = kmalloc(FTRACE_RETSTACK_ALLOC_SIZE *
                                 sizeof(struct ftrace_ret_stack *),
@@ -2035,6 +2042,10 @@ static int start_graph_tracing(void)
         if (!ret_stack_list)
                 return -ENOMEM;
 
+        /* The cpu_boot init_task->ret_stack will never be freed */
+        for_each_online_cpu(cpu)
+                ftrace_graph_init_task(idle_task(cpu));
+
         do {
                 ret = alloc_retstack_tasklist(ret_stack_list);
         } while (ret == -EAGAIN);
@@ -2043,6 +2054,27 @@ static int start_graph_tracing(void)
         return ret;
 }
 
+/*
+ * Hibernation protection.
+ * The state of the current task is too much unstable during
+ * suspend/restore to disk. We want to protect against that.
+ */
+static int
+ftrace_suspend_notifier_call(struct notifier_block *bl, unsigned long state,
+                                                        void *unused)
+{
+        switch (state) {
+        case PM_HIBERNATION_PREPARE:
+                pause_graph_tracing();
+                break;
+
+        case PM_POST_HIBERNATION:
+                unpause_graph_tracing();
+                break;
+        }
+        return NOTIFY_DONE;
+}
+
 int register_ftrace_graph(trace_func_graph_ret_t retfunc,
                         trace_func_graph_ent_t entryfunc)
 {
@@ -2050,6 +2082,9 @@ int register_ftrace_graph(trace_func_graph_ret_t retfunc,
 
         mutex_lock(&ftrace_sysctl_lock);
 
+        ftrace_suspend_notifier.notifier_call = ftrace_suspend_notifier_call;
+        register_pm_notifier(&ftrace_suspend_notifier);
+
         atomic_inc(&ftrace_graph_active);
         ret = start_graph_tracing();
         if (ret) {
@@ -2075,6 +2110,7 @@ void unregister_ftrace_graph(void)
         ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
         ftrace_graph_entry = ftrace_graph_entry_stub;
         ftrace_shutdown(FTRACE_STOP_FUNC_RET);
+        unregister_pm_notifier(&ftrace_suspend_notifier);
 
         mutex_unlock(&ftrace_sysctl_lock);
 }
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 8b0daf0662ef..bd38c5cfd8ad 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -246,7 +246,7 @@ static inline int test_time_stamp(u64 delta)
         return 0;
 }
 
-#define BUF_PAGE_SIZE (PAGE_SIZE - sizeof(struct buffer_data_page))
+#define BUF_PAGE_SIZE (PAGE_SIZE - offsetof(struct buffer_data_page, data))
 
 /*
  * head_page == tail_page && head == tail then buffer is empty.
@@ -1025,12 +1025,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                 }
 
                 if (next_page == head_page) {
-                        if (!(buffer->flags & RB_FL_OVERWRITE)) {
-                                /* reset write */
-                                if (tail <= BUF_PAGE_SIZE)
-                                        local_set(&tail_page->write, tail);
+                        if (!(buffer->flags & RB_FL_OVERWRITE))
                                 goto out_unlock;
-                        }
 
                         /* tail_page has not moved yet? */
                         if (tail_page == cpu_buffer->tail_page) {
@@ -1105,6 +1101,10 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
         return event;
 
  out_unlock:
+        /* reset write */
+        if (tail <= BUF_PAGE_SIZE)
+                local_set(&tail_page->write, tail);
+
         __raw_spin_unlock(&cpu_buffer->lock);
         local_irq_restore(flags);
         return NULL;
@@ -2174,6 +2174,9 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
 
         cpu_buffer->overrun = 0;
         cpu_buffer->entries = 0;
+
+        cpu_buffer->write_stamp = 0;
+        cpu_buffer->read_stamp = 0;
 }
 
 /**
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index c580233add95..17bb88d86ac2 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -40,7 +40,7 @@
 
 #define TRACE_BUFFER_FLAGS      (RB_FL_OVERWRITE)
 
-unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
+unsigned long __read_mostly     tracing_max_latency;
 unsigned long __read_mostly     tracing_thresh;
 
 /*
@@ -3736,7 +3736,7 @@ static struct notifier_block trace_die_notifier = {
  * it if we decide to change what log level the ftrace dump
  * should be at.
  */
-#define KERN_TRACE              KERN_INFO
+#define KERN_TRACE              KERN_EMERG
 
 static void
 trace_printk_seq(struct trace_seq *s)
@@ -3770,6 +3770,7 @@ void ftrace_dump(void)
         dump_ran = 1;
 
         /* No turning back! */
+        tracing_off();
         ftrace_kill();
 
         for_each_tracing_cpu(cpu) {
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 7c2e326bbc8b..62a78d943534 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -380,6 +380,7 @@ static void stop_irqsoff_tracer(struct trace_array *tr)
 
 static void __irqsoff_tracer_init(struct trace_array *tr)
 {
+        tracing_max_latency = 0;
         irqsoff_trace = tr;
         /* make sure that the tracer is visible */
         smp_wmb();
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index fffcb069f1dc..80e503ef6136 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -9,6 +9,7 @@
 #include <linux/kernel.h>
 #include <linux/mmiotrace.h>
 #include <linux/pci.h>
+#include <asm/atomic.h>
 
 #include "trace.h"
 
@@ -19,6 +20,7 @@ struct header_iter {
 static struct trace_array *mmio_trace_array;
 static bool overrun_detected;
 static unsigned long prev_overruns;
+static atomic_t dropped_count;
 
 static void mmio_reset_data(struct trace_array *tr)
 {
@@ -121,11 +123,11 @@ static void mmio_close(struct trace_iterator *iter)
 
 static unsigned long count_overruns(struct trace_iterator *iter)
 {
-        unsigned long cnt = 0;
+        unsigned long cnt = atomic_xchg(&dropped_count, 0);
         unsigned long over = ring_buffer_overruns(iter->tr->buffer);
 
         if (over > prev_overruns)
-                cnt = over - prev_overruns;
+                cnt += over - prev_overruns;
         prev_overruns = over;
         return cnt;
 }
@@ -310,8 +312,10 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
 
         event   = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
                                            &irq_flags);
-        if (!event)
+        if (!event) {
+                atomic_inc(&dropped_count);
                 return;
+        }
         entry   = ring_buffer_event_data(event);
         tracing_generic_entry_update(&entry->ent, 0, preempt_count());
         entry->ent.type                 = TRACE_MMIO_RW;
@@ -338,8 +342,10 @@ static void __trace_mmiotrace_map(struct trace_array *tr,
 
         event   = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
                                            &irq_flags);
-        if (!event)
+        if (!event) {
+                atomic_inc(&dropped_count);
                 return;
+        }
         entry   = ring_buffer_event_data(event);
         tracing_generic_entry_update(&entry->ent, 0, preempt_count());
         entry->ent.type                 = TRACE_MMIO_MAP;
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 43586b689e31..42ae1e77b6b3 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -333,6 +333,7 @@ static void stop_wakeup_tracer(struct trace_array *tr)
 
 static int wakeup_tracer_init(struct trace_array *tr)
 {
+        tracing_max_latency = 0;
         wakeup_trace = tr;
         start_wakeup_tracer(tr);
         return 0;
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 88c8eb70f54a..bc8e80a86bca 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -23,10 +23,20 @@ static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
 {
         struct ring_buffer_event *event;
         struct trace_entry *entry;
+        unsigned int loops = 0;
 
         while ((event = ring_buffer_consume(tr->buffer, cpu, NULL))) {
                 entry = ring_buffer_event_data(event);
 
+                /*
+                 * The ring buffer is a size of trace_buf_size, if
+                 * we loop more than the size, there's something wrong
+                 * with the ring buffer.
+                 */
+                if (loops++ > trace_buf_size) {
+                        printk(KERN_CONT ".. bad ring buffer ");
+                        goto failed;
+                }
                 if (!trace_valid_entry(entry)) {
                         printk(KERN_CONT ".. invalid entry %d ",
                                 entry->type);
@@ -57,11 +67,20 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
 
         cnt = ring_buffer_entries(tr->buffer);
 
+        /*
+         * The trace_test_buffer_cpu runs a while loop to consume all data.
+         * If the calling tracer is broken, and is constantly filling
+         * the buffer, this will run forever, and hard lock the box.
+         * We disable the ring buffer while we do this test to prevent
+         * a hard lock up.
+         */
+        tracing_off();
         for_each_possible_cpu(cpu) {
                 ret = trace_test_buffer_cpu(tr, cpu);
                 if (ret)
                         break;
         }
+        tracing_on();
         __raw_spin_unlock(&ftrace_max_lock);
         local_irq_restore(flags);
 
diff --git a/kernel/tsacct.c b/kernel/tsacct.c
index 43f891b05a4b..00d59d048edf 100644
--- a/kernel/tsacct.c
+++ b/kernel/tsacct.c
@@ -122,8 +122,10 @@ void acct_update_integrals(struct task_struct *tsk)
         if (likely(tsk->mm)) {
                 cputime_t time, dtime;
                 struct timeval value;
+                unsigned long flags;
                 u64 delta;
 
+                local_irq_save(flags);
                 time = tsk->stime + tsk->utime;
                 dtime = cputime_sub(time, tsk->acct_timexpd);
                 jiffies_to_timeval(cputime_to_jiffies(dtime), &value);
@@ -131,10 +133,12 @@ void acct_update_integrals(struct task_struct *tsk)
                 delta = delta * USEC_PER_SEC + value.tv_usec;
 
                 if (delta == 0)
-                        return;
+                        goto out;
                 tsk->acct_timexpd = time;
                 tsk->acct_rss_mem1 += delta * get_mm_rss(tsk->mm);
                 tsk->acct_vm_mem1 += delta * tsk->mm->total_vm;
+        out:
+                local_irq_restore(flags);
         }
 }
 
diff --git a/kernel/user.c b/kernel/user.c
index 477b6660f447..850e0ba41c1e 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -20,7 +20,7 @@
 
 struct user_namespace init_user_ns = {
         .kref = {
-                .refcount       = ATOMIC_INIT(1),
+                .refcount       = ATOMIC_INIT(2),
         },
         .creator = &root_user,
 };
@@ -72,6 +72,7 @@ static void uid_hash_insert(struct user_struct *up, struct hlist_head *hashent)
 static void uid_hash_remove(struct user_struct *up)
 {
         hlist_del_init(&up->uidhash_node);
+        put_user_ns(up->user_ns);
 }
 
 static struct user_struct *uid_hash_find(uid_t uid, struct hlist_head *hashent)
@@ -285,14 +286,12 @@ int __init uids_sysfs_init(void)
 /* work function to remove sysfs directory for a user and free up
  * corresponding structures.
  */
-static void remove_user_sysfs_dir(struct work_struct *w)
+static void cleanup_user_struct(struct work_struct *w)
 {
         struct user_struct *up = container_of(w, struct user_struct, work);
         unsigned long flags;
         int remove_user = 0;
 
-        if (up->user_ns != &init_user_ns)
-                return;
         /* Make uid_hash_remove() + sysfs_remove_file() + kobject_del()
          * atomic.
          */
@@ -311,9 +310,11 @@ static void remove_user_sysfs_dir(struct work_struct *w)
         if (!remove_user)
                 goto done;
 
-        kobject_uevent(&up->kobj, KOBJ_REMOVE);
-        kobject_del(&up->kobj);
-        kobject_put(&up->kobj);
+        if (up->user_ns == &init_user_ns) {
+                kobject_uevent(&up->kobj, KOBJ_REMOVE);
+                kobject_del(&up->kobj);
+                kobject_put(&up->kobj);
+        }
 
         sched_destroy_user(up);
         key_put(up->uid_keyring);
@@ -334,8 +335,7 @@ static void free_user(struct user_struct *up, unsigned long flags)
         atomic_inc(&up->__count);
         spin_unlock_irqrestore(&uidhash_lock, flags);
 
-        put_user_ns(up->user_ns);
-        INIT_WORK(&up->work, remove_user_sysfs_dir);
+        INIT_WORK(&up->work, cleanup_user_struct);
         schedule_work(&up->work);
 }
 
@@ -357,12 +357,29 @@ static void free_user(struct user_struct *up, unsigned long flags)
         sched_destroy_user(up);
         key_put(up->uid_keyring);
         key_put(up->session_keyring);
-        put_user_ns(up->user_ns);
         kmem_cache_free(uid_cachep, up);
 }
 
 #endif
 
+#if defined(CONFIG_RT_GROUP_SCHED) && defined(CONFIG_USER_SCHED)
+/*
+ * We need to check if a setuid can take place. This function should be called
+ * before successfully completing the setuid.
+ */
+int task_can_switch_user(struct user_struct *up, struct task_struct *tsk)
+{
+
+        return sched_rt_can_attach(up->tg, tsk);
+
+}
+#else
+int task_can_switch_user(struct user_struct *up, struct task_struct *tsk)
+{
+        return 1;
+}
+#endif
+
 /*
  * Locate the user_struct for the passed UID.  If found, take a ref on it.  The
  * caller must undo that ref with free_uid().
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index 79084311ee57..076c7c8215b0 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -60,12 +60,25 @@ int create_user_ns(struct cred *new)
         return 0;
 }
 
-void free_user_ns(struct kref *kref)
+/*
+ * Deferred destructor for a user namespace.  This is required because
+ * free_user_ns() may be called with uidhash_lock held, but we need to call
+ * back to free_uid() which will want to take the lock again.
+ */
+static void free_user_ns_work(struct work_struct *work)
 {
-        struct user_namespace *ns;
-
-        ns = container_of(kref, struct user_namespace, kref);
+        struct user_namespace *ns =
+                container_of(work, struct user_namespace, destroyer);
         free_uid(ns->creator);
         kfree(ns);
 }
+
+void free_user_ns(struct kref *kref)
+{
+        struct user_namespace *ns =
+                container_of(kref, struct user_namespace, kref);
+
+        INIT_WORK(&ns->destroyer, free_user_ns_work);
+        schedule_work(&ns->destroyer);
+}
 EXPORT_SYMBOL(free_user_ns);
diff --git a/kernel/wait.c b/kernel/wait.c
index cd87131f2fc2..42a2dbc181c8 100644
--- a/kernel/wait.c
+++ b/kernel/wait.c
@@ -91,6 +91,15 @@ prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
 }
 EXPORT_SYMBOL(prepare_to_wait_exclusive);
 
+/*
+ * finish_wait - clean up after waiting in a queue
+ * @q: waitqueue waited on
+ * @wait: wait descriptor
+ *
+ * Sets current thread back to running state and removes
+ * the wait descriptor from the given waitqueue if still
+ * queued.
+ */
 void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
 {
         unsigned long flags;
@@ -117,6 +126,39 @@ void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
 }
 EXPORT_SYMBOL(finish_wait);
 
+/*
+ * abort_exclusive_wait - abort exclusive waiting in a queue
+ * @q: waitqueue waited on
+ * @wait: wait descriptor
+ * @state: runstate of the waiter to be woken
+ * @key: key to identify a wait bit queue or %NULL
+ *
+ * Sets current thread back to running state and removes
+ * the wait descriptor from the given waitqueue if still
+ * queued.
+ *
+ * Wakes up the next waiter if the caller is concurrently
+ * woken up through the queue.
+ *
+ * This prevents waiter starvation where an exclusive waiter
+ * aborts and is woken up concurrently and noone wakes up
+ * the next waiter.
+ */
+void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,
+                        unsigned int mode, void *key)
+{
+        unsigned long flags;
+
+        __set_current_state(TASK_RUNNING);
+        spin_lock_irqsave(&q->lock, flags);
+        if (!list_empty(&wait->task_list))
+                list_del_init(&wait->task_list);
+        else if (waitqueue_active(q))
+                __wake_up_common(q, mode, 1, 0, key);
+        spin_unlock_irqrestore(&q->lock, flags);
+}
+EXPORT_SYMBOL(abort_exclusive_wait);
+
 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
 {
         int ret = default_wake_function(wait, mode, sync, key);
@@ -177,17 +219,20 @@ int __sched
 __wait_on_bit_lock(wait_queue_head_t *wq, struct wait_bit_queue *q,
                         int (*action)(void *), unsigned mode)
 {
-        int ret = 0;
-
         do {
+                int ret;
+
                 prepare_to_wait_exclusive(wq, &q->wait, mode);
-                if (test_bit(q->key.bit_nr, q->key.flags)) {
-                        if ((ret = (*action)(q->key.flags)))
-                                break;
-                }
+                if (!test_bit(q->key.bit_nr, q->key.flags))
+                        continue;
+                ret = action(q->key.flags);
+                if (!ret)
+                        continue;
+                abort_exclusive_wait(wq, &q->wait, mode, &q->key);
+                return ret;
         } while (test_and_set_bit(q->key.bit_nr, q->key.flags));
         finish_wait(wq, &q->wait);
-        return ret;
+        return 0;
 }
 EXPORT_SYMBOL(__wait_on_bit_lock);
 
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 2f445833ae37..1f0c509b40d3 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -971,6 +971,8 @@ undo:
 }
 
 #ifdef CONFIG_SMP
+static struct workqueue_struct *work_on_cpu_wq __read_mostly;
+
 struct work_for_cpu {
         struct work_struct work;
         long (*fn)(void *);
@@ -991,8 +993,8 @@ static void do_work_for_cpu(struct work_struct *w)
  * @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.
+ * This will return the value @fn returns.
+ * It is up to the caller to ensure that the cpu doesn't go offline.
  */
 long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
 {
@@ -1001,14 +1003,8 @@ long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
         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();
+        queue_work_on(cpu, work_on_cpu_wq, &wfc.work);
+        flush_work(&wfc.work);
 
         return wfc.ret;
 }
@@ -1025,4 +1021,8 @@ void __init init_workqueues(void)
         hotcpu_notifier(workqueue_cpu_callback, 0);
         keventd_wq = create_workqueue("events");
         BUG_ON(!keventd_wq);
+#ifdef CONFIG_SMP
+        work_on_cpu_wq = create_workqueue("work_on_cpu");
+        BUG_ON(!work_on_cpu_wq);
+#endif
 }