55 files changed, 3199 insertions, 1485 deletions
diff --git a/kernel/async.c b/kernel/async.c
index f565891f2c9b..968ef9457d4e 100644
--- a/kernel/async.c
+++ b/kernel/async.c
@@ -49,6 +49,7 @@ asynchronous and synchronous parts of the kernel.
 */
 #include <linux/async.h>
+#include <linux/bug.h>
 #include <linux/module.h>
 #include <linux/wait.h>
 #include <linux/sched.h>
@@ -387,20 +388,11 @@ static int async_manager_thread(void *unused)
 static int __init async_init(void)
 {
-        if (async_enabled)
+        async_enabled =
-                if (IS_ERR(kthread_run(async_manager_thread, NULL,
+                !IS_ERR(kthread_run(async_manager_thread, NULL, "async/mgr"));
-                                       "async/mgr")))
-                        async_enabled = 0;
-        return 0;
-}
-static int __init setup_async(char *str)
+        WARN_ON(!async_enabled);
-{
+        return 0;
-        async_enabled = 1;
-        return 1;
 }
-__setup("fastboot", setup_async);
 core_initcall(async_init);
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 9edb5c4b79b4..c500ca7239b2 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1071,7 +1071,8 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
                mutex_unlock(&cgroup_mutex);
        }
-        return simple_set_mnt(mnt, sb);
+        simple_set_mnt(mnt, sb);
+        return 0;
 free_cg_links:
        free_cg_links(&tmp_cg_links);
@@ -1627,7 +1628,7 @@ static struct inode_operations cgroup_dir_inode_operations = {
 static int cgroup_create_file(struct dentry *dentry, int mode,
                                struct super_block *sb)
 {
-        static struct dentry_operations cgroup_dops = {
+        static const struct dentry_operations cgroup_dops = {
                .d_iput = cgroup_diput,
        };
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 79e40f00dcb8..395b6974dc8d 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -281,7 +281,7 @@ int __ref cpu_down(unsigned int cpu)
                goto out;
        }
-        cpu_clear(cpu, cpu_active_map);
+        set_cpu_active(cpu, false);
        /*
         * Make sure the all cpus did the reschedule and are not
@@ -296,7 +296,7 @@ int __ref cpu_down(unsigned int cpu)
        err = _cpu_down(cpu, 0);
        if (cpu_online(cpu))
-                cpu_set(cpu, cpu_active_map);
+                set_cpu_active(cpu, true);
 out:
        cpu_maps_update_done();
@@ -333,7 +333,7 @@ static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
                goto out_notify;
        BUG_ON(!cpu_online(cpu));
-        cpu_set(cpu, cpu_active_map);
+        set_cpu_active(cpu, true);
        /* Now call notifier in preparation. */
        raw_notifier_call_chain(&cpu_chain, CPU_ONLINE | mod, hcpu);
diff --git a/kernel/exit.c b/kernel/exit.c
index efd30ccf3858..167e1e3ad7c6 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -980,12 +980,9 @@ static void check_stack_usage(void)
 {
        static DEFINE_SPINLOCK(low_water_lock);
        static int lowest_to_date = THREAD_SIZE;
-        unsigned long *n = end_of_stack(current);
        unsigned long free;
-        while (*n == 0)
+        free = stack_not_used(current);
-                n++;
-        free = (unsigned long)n - (unsigned long)end_of_stack(current);
        if (free >= lowest_to_date)
                return;
diff --git a/kernel/fork.c b/kernel/fork.c
index 4854c2c4a82e..47c15840a381 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -61,6 +61,7 @@
 #include <linux/proc_fs.h>
 #include <linux/blkdev.h>
 #include <trace/sched.h>
+#include <linux/magic.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
@@ -212,6 +213,8 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)
 {
        struct task_struct *tsk;
        struct thread_info *ti;
+        unsigned long *stackend;
        int err;
        prepare_to_copy(orig);
@@ -237,6 +240,8 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)
                goto out;
        setup_thread_stack(tsk, orig);
+        stackend = end_of_stack(tsk);
+        *stackend = STACK_END_MAGIC;    /* for overflow detection */
 #ifdef CONFIG_CC_STACKPROTECTOR
        tsk->stack_canary = get_random_int();
@@ -279,7 +284,7 @@ static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
        mm->free_area_cache = oldmm->mmap_base;
        mm->cached_hole_size = ~0UL;
        mm->map_count = 0;
-        cpus_clear(mm->cpu_vm_mask);
+        cpumask_clear(mm_cpumask(mm));
        mm->mm_rb = RB_ROOT;
        rb_link = &mm->mm_rb.rb_node;
        rb_parent = NULL;
diff --git a/kernel/futex.c b/kernel/futex.c
index 438701adce23..6b50a024bca2 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -114,7 +114,9 @@ struct futex_q {
 };
 /*
- * Split the global futex_lock into every hash list lock.
+ * Hash buckets are shared by all the futex_keys that hash to the same
+ * location.  Each key may have multiple futex_q structures, one for each task
+ * waiting on a futex.
 */
 struct futex_hash_bucket {
        spinlock_t lock;
@@ -189,8 +191,7 @@ static void drop_futex_key_refs(union futex_key *key)
 /**
 * get_futex_key - Get parameters which are the keys for a futex.
 * @uaddr: virtual address of the futex
- * @shared: NULL for a PROCESS_PRIVATE futex,
+ * @fshared: 0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
- *      &current->mm->mmap_sem for a PROCESS_SHARED futex
 * @key: address where result is stored.
 *
 * Returns a negative error code or 0
@@ -200,9 +201,7 @@ static void drop_futex_key_refs(union futex_key *key)
 * offset_within_page).  For private mappings, it's (uaddr, current->mm).
 * We can usually work out the index without swapping in the page.
 *
- * fshared is NULL for PROCESS_PRIVATE futexes
+ * lock_page() might sleep, the caller should not hold a spinlock.
- * For other futexes, it points to &current->mm->mmap_sem and
- * caller must have taken the reader lock. but NOT any spinlocks.
 */
 static int get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key)
 {
@@ -299,41 +298,6 @@ static int get_futex_value_locked(u32 *dest, u32 __user *from)
        return ret ? -EFAULT : 0;
 }
-/*
- * Fault handling.
- */
-static int futex_handle_fault(unsigned long address, int attempt)
-{
-        struct vm_area_struct * vma;
-        struct mm_struct *mm = current->mm;
-        int ret = -EFAULT;
-        if (attempt > 2)
-                return ret;
-        down_read(&mm->mmap_sem);
-        vma = find_vma(mm, address);
-        if (vma && address >= vma->vm_start &&
-            (vma->vm_flags & VM_WRITE)) {
-                int fault;
-                fault = handle_mm_fault(mm, vma, address, 1);
-                if (unlikely((fault & VM_FAULT_ERROR))) {
-#if 0
-                        /* XXX: let's do this when we verify it is OK */
-                        if (ret & VM_FAULT_OOM)
-                                ret = -ENOMEM;
-#endif
-                } else {
-                        ret = 0;
-                        if (fault & VM_FAULT_MAJOR)
-                                current->maj_flt++;
-                        else
-                                current->min_flt++;
-                }
-        }
-        up_read(&mm->mmap_sem);
-        return ret;
-}
 /*
 * PI code:
@@ -589,10 +553,9 @@ static void wake_futex(struct futex_q *q)
         * The waiting task can free the futex_q as soon as this is written,
         * without taking any locks.  This must come last.
         *
-         * A memory barrier is required here to prevent the following store
+         * A memory barrier is required here to prevent the following store to
-         * to lock_ptr from getting ahead of the wakeup. Clearing the lock
+         * lock_ptr from getting ahead of the wakeup. Clearing the lock at the
-         * at the end of wake_up_all() does not prevent this store from
+         * end of wake_up() does not prevent this store from moving.
-         * moving.
         */
        smp_wmb();
        q->lock_ptr = NULL;
@@ -692,9 +655,16 @@ double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
        }
 }
+static inline void
+double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
+{
+        spin_unlock(&hb1->lock);
+        if (hb1 != hb2)
+                spin_unlock(&hb2->lock);
+}
 /*
- * Wake up all waiters hashed on the physical page that is mapped
+ * Wake up waiters matching bitset queued on this futex (uaddr).
- * to this virtual address:
 */
 static int futex_wake(u32 __user *uaddr, int fshared, int nr_wake, u32 bitset)
 {
@@ -750,9 +720,9 @@ futex_wake_op(u32 __user *uaddr1, int fshared, u32 __user *uaddr2,
        struct futex_hash_bucket *hb1, *hb2;
        struct plist_head *head;
        struct futex_q *this, *next;
-        int ret, op_ret, attempt = 0;
+        int ret, op_ret;
-retryfull:
+retry:
        ret = get_futex_key(uaddr1, fshared, &key1);
        if (unlikely(ret != 0))
                goto out;
@@ -763,16 +733,13 @@ retryfull:
        hb1 = hash_futex(&key1);
        hb2 = hash_futex(&key2);
-retry:
        double_lock_hb(hb1, hb2);
+retry_private:
        op_ret = futex_atomic_op_inuser(op, uaddr2);
        if (unlikely(op_ret < 0)) {
                u32 dummy;
-                spin_unlock(&hb1->lock);
+                double_unlock_hb(hb1, hb2);
-                if (hb1 != hb2)
-                        spin_unlock(&hb2->lock);
 #ifndef CONFIG_MMU
                /*
@@ -788,26 +755,16 @@ retry:
                        goto out_put_keys;
                }
-                /*
-                 * futex_atomic_op_inuser needs to both read and write
-                 * *(int __user *)uaddr2, but we can't modify it
-                 * non-atomically.  Therefore, if get_user below is not
-                 * enough, we need to handle the fault ourselves, while
-                 * still holding the mmap_sem.
-                 */
-                if (attempt++) {
-                        ret = futex_handle_fault((unsigned long)uaddr2,
-                                                 attempt);
-                        if (ret)
-                                goto out_put_keys;
-                        goto retry;
-                }
                ret = get_user(dummy, uaddr2);
                if (ret)
-                        return ret;
+                        goto out_put_keys;
+                if (!fshared)
+                        goto retry_private;
-                goto retryfull;
+                put_futex_key(fshared, &key2);
+                put_futex_key(fshared, &key1);
+                goto retry;
        }
        head = &hb1->chain;
@@ -834,9 +791,7 @@ retry:
                ret += op_ret;
        }
-        spin_unlock(&hb1->lock);
+        double_unlock_hb(hb1, hb2);
-        if (hb1 != hb2)
-                spin_unlock(&hb2->lock);
 out_put_keys:
        put_futex_key(fshared, &key2);
 out_put_key1:
@@ -869,6 +824,7 @@ retry:
        hb1 = hash_futex(&key1);
        hb2 = hash_futex(&key2);
+retry_private:
        double_lock_hb(hb1, hb2);
        if (likely(cmpval != NULL)) {
@@ -877,16 +833,18 @@ retry:
                ret = get_futex_value_locked(&curval, uaddr1);
                if (unlikely(ret)) {
-                        spin_unlock(&hb1->lock);
+                        double_unlock_hb(hb1, hb2);
-                        if (hb1 != hb2)
-                                spin_unlock(&hb2->lock);
                        ret = get_user(curval, uaddr1);
+                        if (ret)
+                                goto out_put_keys;
-                        if (!ret)
+                        if (!fshared)
-                                goto retry;
+                                goto retry_private;
-                        goto out_put_keys;
+                        put_futex_key(fshared, &key2);
+                        put_futex_key(fshared, &key1);
+                        goto retry;
                }
                if (curval != *cmpval) {
                        ret = -EAGAIN;
@@ -923,9 +881,7 @@ retry:
        }
 out_unlock:
-        spin_unlock(&hb1->lock);
+        double_unlock_hb(hb1, hb2);
-        if (hb1 != hb2)
-                spin_unlock(&hb2->lock);
        /* drop_futex_key_refs() must be called outside the spinlocks. */
        while (--drop_count >= 0)
@@ -1063,7 +1019,7 @@ static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
        struct futex_pi_state *pi_state = q->pi_state;
        struct task_struct *oldowner = pi_state->owner;
        u32 uval, curval, newval;
-        int ret, attempt = 0;
+        int ret;
        /* Owner died? */
        if (!pi_state->owner)
@@ -1076,11 +1032,9 @@ static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
         * in the user space variable. This must be atomic as we have
         * to preserve the owner died bit here.
         *
-         * Note: We write the user space value _before_ changing the
+         * Note: We write the user space value _before_ changing the pi_state
-         * pi_state because we can fault here. Imagine swapped out
+         * because we can fault here. Imagine swapped out pages or a fork
-         * pages or a fork, which was running right before we acquired
+         * that marked all the anonymous memory readonly for cow.
-         * mmap_sem, that marked all the anonymous memory readonly for
-         * cow.
         *
         * Modifying pi_state _before_ the user space value would
         * leave the pi_state in an inconsistent state when we fault
@@ -1136,7 +1090,7 @@ retry:
 handle_fault:
        spin_unlock(q->lock_ptr);
-        ret = futex_handle_fault((unsigned long)uaddr, attempt++);
+        ret = get_user(uval, uaddr);
        spin_lock(q->lock_ptr);
@@ -1185,10 +1139,11 @@ retry:
        if (unlikely(ret != 0))
                goto out;
+retry_private:
        hb = queue_lock(&q);
        /*
-         * Access the page AFTER the futex is queued.
+         * Access the page AFTER the hash-bucket is locked.
         * Order is important:
         *
         *   Userspace waiter: val = var; if (cond(val)) futex_wait(&var, val);
@@ -1204,20 +1159,23 @@ retry:
         * a wakeup when *uaddr != val on entry to the syscall.  This is
         * rare, but normal.
         *
-         * for shared futexes, we hold the mmap semaphore, so the mapping
+         * For shared futexes, we hold the mmap semaphore, so the mapping
         * cannot have changed since we looked it up in get_futex_key.
         */
        ret = get_futex_value_locked(&uval, uaddr);
        if (unlikely(ret)) {
                queue_unlock(&q, hb);
-                put_futex_key(fshared, &q.key);
                ret = get_user(uval, uaddr);
+                if (ret)
+                        goto out_put_key;
-                if (!ret)
+                if (!fshared)
-                        goto retry;
+                        goto retry_private;
-                goto out;
+                put_futex_key(fshared, &q.key);
+                goto retry;
        }
        ret = -EWOULDBLOCK;
        if (unlikely(uval != val)) {
@@ -1248,16 +1206,13 @@ retry:
                if (!abs_time)
                        schedule();
                else {
-                        unsigned long slack;
-                        slack = current->timer_slack_ns;
-                        if (rt_task(current))
-                                slack = 0;
                        hrtimer_init_on_stack(&t.timer,
                                              clockrt ? CLOCK_REALTIME :
                                              CLOCK_MONOTONIC,
                                              HRTIMER_MODE_ABS);
                        hrtimer_init_sleeper(&t, current);
-                        hrtimer_set_expires_range_ns(&t.timer, *abs_time, slack);
+                        hrtimer_set_expires_range_ns(&t.timer, *abs_time,
+                                                     current->timer_slack_ns);
                        hrtimer_start_expires(&t.timer, HRTIMER_MODE_ABS);
                        if (!hrtimer_active(&t.timer))
@@ -1354,7 +1309,7 @@ static int futex_lock_pi(u32 __user *uaddr, int fshared,
        struct futex_hash_bucket *hb;
        u32 uval, newval, curval;
        struct futex_q q;
-        int ret, lock_taken, ownerdied = 0, attempt = 0;
+        int ret, lock_taken, ownerdied = 0;
        if (refill_pi_state_cache())
                return -ENOMEM;
@@ -1374,7 +1329,7 @@ retry:
        if (unlikely(ret != 0))
                goto out;
-retry_unlocked:
+retry_private:
        hb = queue_lock(&q);
 retry_locked:
@@ -1458,6 +1413,7 @@ retry_locked:
                         * exit to complete.
                         */
                        queue_unlock(&q, hb);
+                        put_futex_key(fshared, &q.key);
                        cond_resched();
                        goto retry;
@@ -1564,6 +1520,13 @@ retry_locked:
                }
        }
+        /*
+         * If fixup_pi_state_owner() faulted and was unable to handle the
+         * fault, unlock it and return the fault to userspace.
+         */
+        if (ret && (rt_mutex_owner(&q.pi_state->pi_mutex) == current))
+                rt_mutex_unlock(&q.pi_state->pi_mutex);
        /* Unqueue and drop the lock */
        unqueue_me_pi(&q);
@@ -1591,22 +1554,18 @@ uaddr_faulted:
         */
        queue_unlock(&q, hb);
-        if (attempt++) {
-                ret = futex_handle_fault((unsigned long)uaddr, attempt);
-                if (ret)
-                        goto out_put_key;
-                goto retry_unlocked;
-        }
        ret = get_user(uval, uaddr);
-        if (!ret)
+        if (ret)
-                goto retry;
+                goto out_put_key;
-        if (to)
+        if (!fshared)
-                destroy_hrtimer_on_stack(&to->timer);
+                goto retry_private;
-        return ret;
+        put_futex_key(fshared, &q.key);
+        goto retry;
 }
 /*
 * Userspace attempted a TID -> 0 atomic transition, and failed.
 * This is the in-kernel slowpath: we look up the PI state (if any),
@@ -1619,7 +1578,7 @@ static int futex_unlock_pi(u32 __user *uaddr, int fshared)
        u32 uval;
        struct plist_head *head;
        union futex_key key = FUTEX_KEY_INIT;
-        int ret, attempt = 0;
+        int ret;
 retry:
        if (get_user(uval, uaddr))
@@ -1635,7 +1594,6 @@ retry:
                goto out;
        hb = hash_futex(&key);
-retry_unlocked:
        spin_lock(&hb->lock);
        /*
@@ -1700,14 +1658,7 @@ pi_faulted:
         * we have to drop the mmap_sem in order to call get_user().
         */
        spin_unlock(&hb->lock);
+        put_futex_key(fshared, &key);
-        if (attempt++) {
-                ret = futex_handle_fault((unsigned long)uaddr, attempt);
-                if (ret)
-                        goto out;
-                uval = 0;
-                goto retry_unlocked;
-        }
        ret = get_user(uval, uaddr);
        if (!ret)
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index 4dd5b1edac98..3394f8f52964 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -4,3 +4,4 @@ obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
 obj-$(CONFIG_NUMA_MIGRATE_IRQ_DESC) += numa_migrate.o
+obj-$(CONFIG_PM_SLEEP) += pm.o
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 7de11bd64dfe..c687ba4363f2 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -46,7 +46,10 @@ void dynamic_irq_init(unsigned int irq)
        desc->irq_count = 0;
        desc->irqs_unhandled = 0;
 #ifdef CONFIG_SMP
-        cpumask_setall(&desc->affinity);
+        cpumask_setall(desc->affinity);
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        cpumask_clear(desc->pending_mask);
+#endif
 #endif
        spin_unlock_irqrestore(&desc->lock, flags);
 }
@@ -78,6 +81,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 +294,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);
        }
 }
@@ -476,7 +481,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.*/
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 3aba8d12f328..9ebf77968871 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -17,6 +17,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/rculist.h>
 #include <linux/hash.h>
+#include <linux/bootmem.h>
 #include "internals.h"
@@ -69,6 +70,7 @@ int nr_irqs = NR_IRQS;
 EXPORT_SYMBOL_GPL(nr_irqs);
 #ifdef CONFIG_SPARSE_IRQ
 static struct irq_desc irq_desc_init = {
        .irq        = -1,
        .status     = IRQ_DISABLED,
@@ -76,26 +78,25 @@ static struct irq_desc irq_desc_init = {
        .handle_irq = handle_bad_irq,
        .depth      = 1,
        .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
-#ifdef CONFIG_SMP
-        .affinity   = CPU_MASK_ALL
-#endif
 };
 void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr)
 {
-        unsigned long bytes;
-        char *ptr;
        int node;
+        void *ptr;
-        /* Compute how many bytes we need per irq and allocate them */
-        bytes = nr * sizeof(unsigned int);
        node = cpu_to_node(cpu);
-        ptr = kzalloc_node(bytes, GFP_ATOMIC, node);
+        ptr = kzalloc_node(nr * sizeof(*desc->kstat_irqs), GFP_ATOMIC, node);
-        printk(KERN_DEBUG "  alloc kstat_irqs on cpu %d node %d\n", cpu, node);
-        if (ptr)
+        /*
-                desc->kstat_irqs = (unsigned int *)ptr;
+         * 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)
@@ -113,6 +114,10 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
                printk(KERN_ERR "can not alloc kstat_irqs\n");
                BUG_ON(1);
        }
+        if (!init_alloc_desc_masks(desc, cpu, false)) {
+                printk(KERN_ERR "can not alloc irq_desc cpumasks\n");
+                BUG_ON(1);
+        }
        arch_init_chip_data(desc, cpu);
 }
@@ -121,7 +126,7 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
 */
 DEFINE_SPINLOCK(sparse_irq_lock);
-struct irq_desc *irq_desc_ptrs[NR_IRQS] __read_mostly;
+struct irq_desc **irq_desc_ptrs __read_mostly;
 static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_smp = {
        [0 ... NR_IRQS_LEGACY-1] = {
@@ -131,14 +136,10 @@ static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_sm
                .handle_irq = handle_bad_irq,
                .depth      = 1,
                .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
-#ifdef CONFIG_SMP
-                .affinity   = CPU_MASK_ALL
-#endif
        }
 };
-/* FIXME: use bootmem alloc ...*/
+static unsigned int *kstat_irqs_legacy;
-static unsigned int kstat_irqs_legacy[NR_IRQS_LEGACY][NR_CPUS];
 int __init early_irq_init(void)
 {
@@ -148,18 +149,30 @@ int __init early_irq_init(void)
        init_irq_default_affinity();
+         /* initialize nr_irqs based on nr_cpu_ids */
+        arch_probe_nr_irqs();
+        printk(KERN_INFO "NR_IRQS:%d nr_irqs:%d\n", NR_IRQS, nr_irqs);
        desc = irq_desc_legacy;
        legacy_count = ARRAY_SIZE(irq_desc_legacy);
+        /* allocate irq_desc_ptrs array based on nr_irqs */
+        irq_desc_ptrs = alloc_bootmem(nr_irqs * sizeof(void *));
+        /* allocate based on nr_cpu_ids */
+        /* FIXME: invert kstat_irgs, and it'd be a per_cpu_alloc'd thing */
+        kstat_irqs_legacy = alloc_bootmem(NR_IRQS_LEGACY * nr_cpu_ids *
+                                          sizeof(int));
        for (i = 0; i < legacy_count; i++) {
                desc[i].irq = i;
-                desc[i].kstat_irqs = kstat_irqs_legacy[i];
+                desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
                lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
+                init_alloc_desc_masks(&desc[i], 0, true);
                irq_desc_ptrs[i] = desc + i;
        }
-        for (i = legacy_count; i < NR_IRQS; i++)
+        for (i = legacy_count; i < nr_irqs; i++)
                irq_desc_ptrs[i] = NULL;
        return arch_early_irq_init();
@@ -167,7 +180,10 @@ int __init early_irq_init(void)
 struct irq_desc *irq_to_desc(unsigned int irq)
 {
-        return (irq < NR_IRQS) ? irq_desc_ptrs[irq] : NULL;
+        if (irq_desc_ptrs && irq < nr_irqs)
+                return irq_desc_ptrs[irq];
+        return NULL;
 }
 struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
@@ -176,10 +192,9 @@ struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
        unsigned long flags;
        int node;
-        if (irq >= NR_IRQS) {
+        if (irq >= nr_irqs) {
-                printk(KERN_WARNING "irq >= NR_IRQS in irq_to_desc_alloc: %d %d\n",
+                WARN(1, "irq (%d) >= nr_irqs (%d) in irq_to_desc_alloc\n",
-                                irq, NR_IRQS);
+                        irq, nr_irqs);
-                WARN_ON(1);
                return NULL;
        }
@@ -221,12 +236,10 @@ struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
                .handle_irq = handle_bad_irq,
                .depth = 1,
                .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
-#ifdef CONFIG_SMP
-                .affinity = CPU_MASK_ALL
-#endif
        }
 };
+static unsigned int kstat_irqs_all[NR_IRQS][NR_CPUS];
 int __init early_irq_init(void)
 {
        struct irq_desc *desc;
@@ -235,12 +248,16 @@ int __init early_irq_init(void)
        init_irq_default_affinity();
+        printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);
        desc = irq_desc;
        count = ARRAY_SIZE(irq_desc);
-        for (i = 0; i < count; i++)
+        for (i = 0; i < count; i++) {
                desc[i].irq = i;
+                init_alloc_desc_masks(&desc[i], 0, true);
+                desc[i].kstat_irqs = kstat_irqs_all[i];
+        }
        return arch_early_irq_init();
 }
@@ -255,6 +272,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.
@@ -328,6 +350,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();
@@ -347,6 +371,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
@@ -467,12 +496,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..01ce20eab38f 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -12,11 +12,21 @@ extern void compat_irq_chip_set_default_handler(struct irq_desc *desc);
 extern int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
                unsigned long flags);
+extern void __disable_irq(struct irq_desc *desc, unsigned int irq, bool susp);
+extern void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume);
 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;
+#ifdef CONFIG_SPARSE_IRQ
+/* irq_desc_ptrs allocated at boot time */
+extern struct irq_desc **irq_desc_ptrs;
+#else
+/* irq_desc_ptrs is a fixed size array */
 extern struct irq_desc *irq_desc_ptrs[NR_IRQS];
+#endif
 #ifdef CONFIG_PROC_FS
 extern void register_irq_proc(unsigned int irq, struct irq_desc *desc);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 291f03664552..1516ab77355c 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -90,14 +90,14 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
 #ifdef CONFIG_GENERIC_PENDING_IRQ
        if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
-                cpumask_copy(&desc->affinity, cpumask);
+                cpumask_copy(desc->affinity, cpumask);
                desc->chip->set_affinity(irq, cpumask);
        } else {
                desc->status |= IRQ_MOVE_PENDING;
-                cpumask_copy(&desc->pending_mask, cpumask);
+                cpumask_copy(desc->pending_mask, cpumask);
        }
 #else
-        cpumask_copy(&desc->affinity, cpumask);
+        cpumask_copy(desc->affinity, cpumask);
        desc->chip->set_affinity(irq, cpumask);
 #endif
        desc->status |= IRQ_AFFINITY_SET;
@@ -109,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;
@@ -119,21 +119,21 @@ int do_irq_select_affinity(unsigned int irq, struct irq_desc *desc)
         * one of the targets is online.
         */
        if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
-                if (cpumask_any_and(&desc->affinity, cpu_online_mask)
+                if (cpumask_any_and(desc->affinity, cpu_online_mask)
                    < nr_cpu_ids)
                        goto set_affinity;
                else
                        desc->status &= ~IRQ_AFFINITY_SET;
        }
-        cpumask_and(&desc->affinity, cpu_online_mask, irq_default_affinity);
+        cpumask_and(desc->affinity, cpu_online_mask, irq_default_affinity);
 set_affinity:
-        desc->chip->set_affinity(irq, &desc->affinity);
+        desc->chip->set_affinity(irq, desc->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);
 }
@@ -149,19 +149,33 @@ 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;
 }
 #endif
+void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
+{
+        if (suspend) {
+                if (!desc->action || (desc->action->flags & IRQF_TIMER))
+                        return;
+                desc->status |= IRQ_SUSPENDED;
+        }
+        if (!desc->depth++) {
+                desc->status |= IRQ_DISABLED;
+                desc->chip->disable(irq);
+        }
+}
 /**
 *      disable_irq_nosync - disable an irq without waiting
 *      @irq: Interrupt to disable
@@ -182,10 +196,7 @@ void disable_irq_nosync(unsigned int irq)
                return;
        spin_lock_irqsave(&desc->lock, flags);
-        if (!desc->depth++) {
+        __disable_irq(desc, irq, false);
-                desc->status |= IRQ_DISABLED;
-                desc->chip->disable(irq);
-        }
        spin_unlock_irqrestore(&desc->lock, flags);
 }
 EXPORT_SYMBOL(disable_irq_nosync);
@@ -215,15 +226,21 @@ void disable_irq(unsigned int irq)
 }
 EXPORT_SYMBOL(disable_irq);
-static void __enable_irq(struct irq_desc *desc, unsigned int irq)
+void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
 {
+        if (resume)
+                desc->status &= ~IRQ_SUSPENDED;
        switch (desc->depth) {
        case 0:
+ err_out:
                WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
                break;
        case 1: {
                unsigned int status = desc->status & ~IRQ_DISABLED;
+                if (desc->status & IRQ_SUSPENDED)
+                        goto err_out;
                /* Prevent probing on this irq: */
                desc->status = status | IRQ_NOPROBE;
                check_irq_resend(desc, irq);
@@ -253,7 +270,7 @@ void enable_irq(unsigned int irq)
                return;
        spin_lock_irqsave(&desc->lock, flags);
-        __enable_irq(desc, irq);
+        __enable_irq(desc, irq, false);
        spin_unlock_irqrestore(&desc->lock, flags);
 }
 EXPORT_SYMBOL(enable_irq);
@@ -389,9 +406,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;
@@ -423,8 +440,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_ptr = &desc->action;
-        old = *p;
+        old = *old_ptr;
        if (old) {
                /*
                 * Can't share interrupts unless both agree to and are
@@ -447,8 +464,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_ptr = &old->next;
-                        old = *p;
+                        old = *old_ptr;
                } while (old);
                shared = 1;
        }
@@ -488,7 +505,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)
@@ -499,7 +516,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;
@@ -511,7 +528,7 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
         */
        if (shared && (desc->status & IRQ_SPURIOUS_DISABLED)) {
                desc->status &= ~IRQ_SPURIOUS_DISABLED;
-                __enable_irq(desc, irq);
+                __enable_irq(desc, irq, false);
        }
        spin_unlock_irqrestore(&desc->lock, flags);
@@ -549,90 +566,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
+ * Internal function to unregister an irqaction - used to free
- *      @irq: Interrupt line to free
+ * regular and special interrupts that are part of the architecture.
- *      @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)
+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) {
+                if (!action) {
-                        struct irqaction **pp = p;
+                        WARN(1, "Trying to free already-free IRQ %d\n", irq);
+                        spin_unlock_irqrestore(&desc->lock, flags);
-                        p = &action->next;
+                        return NULL;
-                        if (action->dev_id != dev_id)
+                }
-                                continue;
-                        /* Found it - now remove it from the list of entries */
+                if (action->dev_id == dev_id)
-                        *pp = action->next;
+                        break;
+                action_ptr = &action->next;
+        }
-                        /* Currently used only by UML, might disappear one day.*/
+        /* Found it - now remove it from the list of entries: */
+        *action_ptr = action->next;
+        /* Currently used only by UML, might disappear one day: */
 #ifdef CONFIG_IRQ_RELEASE_METHOD
-                        if (desc->chip->release)
+        if (desc->chip->release)
-                                desc->chip->release(irq, dev_id);
+                desc->chip->release(irq, dev_id);
 #endif
-                        if (!desc->action) {
+        /* If this was the last handler, shut down the IRQ line: */
-                                desc->status |= IRQ_DISABLED;
+        if (!desc->action) {
-                                if (desc->chip->shutdown)
+                desc->status |= IRQ_DISABLED;
-                                        desc->chip->shutdown(irq);
+                if (desc->chip->shutdown)
-                                else
+                        desc->chip->shutdown(irq);
-                                        desc->chip->disable(irq);
+                else
-                        }
+                        desc->chip->disable(irq);
-                        spin_unlock_irqrestore(&desc->lock, flags);
+        }
-                        unregister_handler_proc(irq, action);
+        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
+         * It's a shared IRQ -- the driver ought to be prepared for an IRQ
-                spin_unlock_irqrestore(&desc->lock, flags);
+         * event to happen even now it's being freed, so let's make sure that
-                return;
+         * 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);
@@ -679,11 +723,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))
+        if ((irqflags & (IRQF_SHARED|IRQF_DISABLED)) ==
-                        == (IRQF_SHARED|IRQF_DISABLED))
+                                        (IRQF_SHARED|IRQF_DISABLED)) {
-                pr_warning("IRQ %d/%s: IRQF_DISABLED is not "
+                pr_warning(
-                                "guaranteed on shared IRQs\n",
+                  "IRQ %d/%s: IRQF_DISABLED is not guaranteed on shared IRQs\n",
-                                irq, devname);
+                        irq, devname);
+        }
 #ifdef CONFIG_LOCKDEP
        /*
@@ -709,15 +754,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/migration.c b/kernel/irq/migration.c
index bd72329e630c..e05ad9be43b7 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -18,7 +18,7 @@ void move_masked_irq(int irq)
        desc->status &= ~IRQ_MOVE_PENDING;
-        if (unlikely(cpumask_empty(&desc->pending_mask)))
+        if (unlikely(cpumask_empty(desc->pending_mask)))
                return;
        if (!desc->chip->set_affinity)
@@ -38,13 +38,13 @@ void move_masked_irq(int irq)
         * For correct operation this depends on the caller
         * masking the irqs.
         */
-        if (likely(cpumask_any_and(&desc->pending_mask, cpu_online_mask)
+        if (likely(cpumask_any_and(desc->pending_mask, cpu_online_mask)
                   < nr_cpu_ids)) {
-                cpumask_and(&desc->affinity,
+                cpumask_and(desc->affinity,
-                            &desc->pending_mask, cpu_online_mask);
+                            desc->pending_mask, cpu_online_mask);
-                desc->chip->set_affinity(irq, &desc->affinity);
+                desc->chip->set_affinity(irq, desc->affinity);
        }
-        cpumask_clear(&desc->pending_mask);
+        cpumask_clear(desc->pending_mask);
 }
 void move_native_irq(int irq)
diff --git a/kernel/irq/numa_migrate.c b/kernel/irq/numa_migrate.c
index acd88356ac76..243d6121e50e 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) {
+        if (desc->kstat_irqs != old_desc->kstat_irqs)
-                /* Compute how many bytes we need per irq and allocate them */
+                memcpy(desc->kstat_irqs, old_desc->kstat_irqs,
-                bytes = nr * sizeof(unsigned int);
+                         nr * sizeof(*desc->kstat_irqs));
-                memcpy(desc->kstat_irqs, old_desc->kstat_irqs, bytes);
-        }
 }
 static void free_kstat_irqs(struct irq_desc *old_desc, struct irq_desc *desc)
@@ -38,15 +33,22 @@ static void free_kstat_irqs(struct irq_desc *old_desc, struct irq_desc *desc)
        old_desc->kstat_irqs = NULL;
 }
-static void init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
+static bool init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
                 struct irq_desc *desc, int cpu)
 {
        memcpy(desc, old_desc, sizeof(struct irq_desc));
+        if (!init_alloc_desc_masks(desc, cpu, false)) {
+                printk(KERN_ERR "irq %d: can not get new irq_desc cpumask "
+                                "for migration.\n", irq);
+                return false;
+        }
        spin_lock_init(&desc->lock);
        desc->cpu = cpu;
        lockdep_set_class(&desc->lock, &irq_desc_lock_class);
        init_copy_kstat_irqs(old_desc, desc, cpu, nr_cpu_ids);
+        init_copy_desc_masks(old_desc, desc);
        arch_init_copy_chip_data(old_desc, desc, cpu);
+        return true;
 }
 static void free_one_irq_desc(struct irq_desc *old_desc, struct irq_desc *desc)
@@ -76,12 +78,18 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
        node = cpu_to_node(cpu);
        desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
        if (!desc) {
-                printk(KERN_ERR "irq %d: can not get new irq_desc for migration.\n", irq);
+                printk(KERN_ERR "irq %d: can not get new irq_desc "
+                                "for migration.\n", irq);
+                /* still use old one */
+                desc = old_desc;
+                goto out_unlock;
+        }
+        if (!init_copy_one_irq_desc(irq, old_desc, desc, cpu)) {
                /* still use old one */
+                kfree(desc);
                desc = old_desc;
                goto out_unlock;
        }
-        init_copy_one_irq_desc(irq, old_desc, desc, cpu);
        irq_desc_ptrs[irq] = desc;
        spin_unlock_irqrestore(&sparse_irq_lock, flags);
diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
new file mode 100644
index 000000000000..638d8bedec14
--- /dev/null
+++ b/kernel/irq/pm.c
@@ -0,0 +1,79 @@
+/*
+ * linux/kernel/irq/pm.c
+ *
+ * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ * This file contains power management functions related to interrupts.
+ */
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include "internals.h"
+/**
+ * suspend_device_irqs - disable all currently enabled interrupt lines
+ *
+ * During system-wide suspend or hibernation device interrupts need to be
+ * disabled at the chip level and this function is provided for this purpose.
+ * It disables all interrupt lines that are enabled at the moment and sets the
+ * IRQ_SUSPENDED flag for them.
+ */
+void suspend_device_irqs(void)
+{
+        struct irq_desc *desc;
+        int irq;
+        for_each_irq_desc(irq, desc) {
+                unsigned long flags;
+                spin_lock_irqsave(&desc->lock, flags);
+                __disable_irq(desc, irq, true);
+                spin_unlock_irqrestore(&desc->lock, flags);
+        }
+        for_each_irq_desc(irq, desc)
+                if (desc->status & IRQ_SUSPENDED)
+                        synchronize_irq(irq);
+}
+EXPORT_SYMBOL_GPL(suspend_device_irqs);
+/**
+ * resume_device_irqs - enable interrupt lines disabled by suspend_device_irqs()
+ *
+ * Enable all interrupt lines previously disabled by suspend_device_irqs() that
+ * have the IRQ_SUSPENDED flag set.
+ */
+void resume_device_irqs(void)
+{
+        struct irq_desc *desc;
+        int irq;
+        for_each_irq_desc(irq, desc) {
+                unsigned long flags;
+                if (!(desc->status & IRQ_SUSPENDED))
+                        continue;
+                spin_lock_irqsave(&desc->lock, flags);
+                __enable_irq(desc, irq, true);
+                spin_unlock_irqrestore(&desc->lock, flags);
+        }
+}
+EXPORT_SYMBOL_GPL(resume_device_irqs);
+/**
+ * check_wakeup_irqs - check if any wake-up interrupts are pending
+ */
+int check_wakeup_irqs(void)
+{
+        struct irq_desc *desc;
+        int irq;
+        for_each_irq_desc(irq, desc)
+                if ((desc->status & IRQ_WAKEUP) && (desc->status & IRQ_PENDING))
+                        return -EBUSY;
+        return 0;
+}
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index aae3f742bcec..692363dd591f 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -20,11 +20,11 @@ static struct proc_dir_entry *root_irq_dir;
 static int irq_affinity_proc_show(struct seq_file *m, void *v)
 {
        struct irq_desc *desc = irq_to_desc((long)m->private);
-        const struct cpumask *mask = &desc->affinity;
+        const struct cpumask *mask = desc->affinity;
 #ifdef CONFIG_GENERIC_PENDING_IRQ
        if (desc->status & IRQ_MOVE_PENDING)
-                mask = &desc->pending_mask;
+                mask = desc->pending_mask;
 #endif
        seq_cpumask(m, mask);
        seq_putc(m, '\n');
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/kexec.c b/kernel/kexec.c
index 483899578259..93eed85fe017 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -1130,7 +1130,7 @@ void crash_save_cpu(struct pt_regs *regs, int cpu)
                return;
        memset(&prstatus, 0, sizeof(prstatus));
        prstatus.pr_pid = current->pid;
-        elf_core_copy_regs(&prstatus.pr_reg, regs);
+        elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
        buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS,
                              &prstatus, sizeof(prstatus));
        final_note(buf);
@@ -1450,11 +1450,7 @@ int kernel_kexec(void)
                error = device_suspend(PMSG_FREEZE);
                if (error)
                        goto Resume_console;
-                error = disable_nonboot_cpus();
-                if (error)
-                        goto Resume_devices;
                device_pm_lock();
-                local_irq_disable();
                /* At this point, device_suspend() has been called,
                 * but *not* device_power_down(). We *must*
                 * device_power_down() now.  Otherwise, drivers for
@@ -1464,12 +1460,15 @@ int kernel_kexec(void)
                 */
                error = device_power_down(PMSG_FREEZE);
                if (error)
-                        goto Enable_irqs;
+                        goto Resume_devices;
+                error = disable_nonboot_cpus();
+                if (error)
+                        goto Enable_cpus;
+                local_irq_disable();
                /* Suspend system devices */
                error = sysdev_suspend(PMSG_FREEZE);
                if (error)
-                        goto Power_up_devices;
+                        goto Enable_irqs;
        } else
 #endif
        {
@@ -1483,13 +1482,13 @@ 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();
-                device_pm_unlock();
+ Enable_cpus:
                enable_nonboot_cpus();
+                device_power_up(PMSG_RESTORE);
 Resume_devices:
+                device_pm_unlock();
                device_resume(PMSG_RESTORE);
 Resume_console:
                resume_console();
diff --git a/kernel/kmod.c b/kernel/kmod.c
index a27a5f64443d..f0c8f545180d 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -167,7 +167,7 @@ static int ____call_usermodehelper(void *data)
        }
        /* We can run anywhere, unlike our parent keventd(). */
-        set_cpus_allowed_ptr(current, CPU_MASK_ALL_PTR);
+        set_cpus_allowed_ptr(current, cpu_all_mask);
        /*
         * Our parent is keventd, which runs with elevated scheduling priority.
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 4fbc456f393d..84bbadd4d021 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -110,7 +110,7 @@ static void create_kthread(struct kthread_create_info *create)
                 */
                sched_setscheduler(create->result, SCHED_NORMAL, &param);
                set_user_nice(create->result, KTHREAD_NICE_LEVEL);
-                set_cpus_allowed_ptr(create->result, CPU_MASK_ALL_PTR);
+                set_cpus_allowed_ptr(create->result, cpu_all_mask);
        }
        complete(&create->done);
 }
@@ -240,7 +240,7 @@ int kthreadd(void *unused)
        set_task_comm(tsk, "kthreadd");
        ignore_signals(tsk);
        set_user_nice(tsk, KTHREAD_NICE_LEVEL);
-        set_cpus_allowed_ptr(tsk, CPU_MASK_ALL_PTR);
+        set_cpus_allowed_ptr(tsk, cpu_all_mask);
        current->flags |= PF_NOFREEZE | PF_FREEZER_NOSIG;
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/lockdep.c b/kernel/lockdep.c
index 06b0c3568f0b..3673a3f44d9d 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -41,6 +41,7 @@
 #include <linux/utsname.h>
 #include <linux/hash.h>
 #include <linux/ftrace.h>
+#include <linux/stringify.h>
 #include <asm/sections.h>
@@ -310,12 +311,14 @@ EXPORT_SYMBOL(lockdep_on);
 #if VERBOSE
 # define HARDIRQ_VERBOSE        1
 # define SOFTIRQ_VERBOSE        1
+# define RECLAIM_VERBOSE        1
 #else
 # define HARDIRQ_VERBOSE        0
 # define SOFTIRQ_VERBOSE        0
+# define RECLAIM_VERBOSE        0
 #endif
-#if VERBOSE || HARDIRQ_VERBOSE || SOFTIRQ_VERBOSE
+#if VERBOSE || HARDIRQ_VERBOSE || SOFTIRQ_VERBOSE || RECLAIM_VERBOSE
 /*
 * Quick filtering for interesting events:
 */
@@ -443,17 +446,18 @@ atomic_t nr_find_usage_backwards_recursions;
 * Locking printouts:
 */
+#define __USAGE(__STATE)                                                \
+        [LOCK_USED_IN_##__STATE] = "IN-"__stringify(__STATE)"-W",       \
+        [LOCK_ENABLED_##__STATE] = __stringify(__STATE)"-ON-W",         \
+        [LOCK_USED_IN_##__STATE##_READ] = "IN-"__stringify(__STATE)"-R",\
+        [LOCK_ENABLED_##__STATE##_READ] = __stringify(__STATE)"-ON-R",
 static const char *usage_str[] =
 {
-        [LOCK_USED] =                   "initial-use ",
+#define LOCKDEP_STATE(__STATE) __USAGE(__STATE)
-        [LOCK_USED_IN_HARDIRQ] =        "in-hardirq-W",
+#include "lockdep_states.h"
-        [LOCK_USED_IN_SOFTIRQ] =        "in-softirq-W",
+#undef LOCKDEP_STATE
-        [LOCK_ENABLED_SOFTIRQS] =       "softirq-on-W",
+        [LOCK_USED] = "INITIAL USE",
-        [LOCK_ENABLED_HARDIRQS] =       "hardirq-on-W",
-        [LOCK_USED_IN_HARDIRQ_READ] =   "in-hardirq-R",
-        [LOCK_USED_IN_SOFTIRQ_READ] =   "in-softirq-R",
-        [LOCK_ENABLED_SOFTIRQS_READ] =  "softirq-on-R",
-        [LOCK_ENABLED_HARDIRQS_READ] =  "hardirq-on-R",
 };
 const char * __get_key_name(struct lockdep_subclass_key *key, char *str)
@@ -461,46 +465,45 @@ const char * __get_key_name(struct lockdep_subclass_key *key, char *str)
        return kallsyms_lookup((unsigned long)key, NULL, NULL, NULL, str);
 }
-void
+static inline unsigned long lock_flag(enum lock_usage_bit bit)
-get_usage_chars(struct lock_class *class, char *c1, char *c2, char *c3, char *c4)
 {
-        *c1 = '.', *c2 = '.', *c3 = '.', *c4 = '.';
+        return 1UL << bit;
+}
-        if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
-                *c1 = '+';
-        else
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS)
-                        *c1 = '-';
-        if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
+static char get_usage_char(struct lock_class *class, enum lock_usage_bit bit)
-                *c2 = '+';
+{
-        else
+        char c = '.';
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS)
-                        *c2 = '-';
-        if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
+        if (class->usage_mask & lock_flag(bit + 2))
-                *c3 = '-';
+                c = '+';
-        if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) {
+        if (class->usage_mask & lock_flag(bit)) {
-                *c3 = '+';
+                c = '-';
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
+                if (class->usage_mask & lock_flag(bit + 2))
-                        *c3 = '?';
+                        c = '?';
        }
-        if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
+        return c;
-                *c4 = '-';
+}
-        if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) {
-                *c4 = '+';
+void get_usage_chars(struct lock_class *class, char usage[LOCK_USAGE_CHARS])
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
+{
-                        *c4 = '?';
+        int i = 0;
-        }
+#define LOCKDEP_STATE(__STATE)                                          \
+        usage[i++] = get_usage_char(class, LOCK_USED_IN_##__STATE);     \
+        usage[i++] = get_usage_char(class, LOCK_USED_IN_##__STATE##_READ);
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+        usage[i] = '\0';
 }
 static void print_lock_name(struct lock_class *class)
 {
-        char str[KSYM_NAME_LEN], c1, c2, c3, c4;
+        char str[KSYM_NAME_LEN], usage[LOCK_USAGE_CHARS];
        const char *name;
-        get_usage_chars(class, &c1, &c2, &c3, &c4);
+        get_usage_chars(class, usage);
        name = class->name;
        if (!name) {
@@ -513,7 +516,7 @@ static void print_lock_name(struct lock_class *class)
                if (class->subclass)
                        printk("/%d", class->subclass);
        }
-        printk("){%c%c%c%c}", c1, c2, c3, c4);
+        printk("){%s}", usage);
 }
 static void print_lockdep_cache(struct lockdep_map *lock)
@@ -1263,9 +1266,49 @@ check_usage(struct task_struct *curr, struct held_lock *prev,
                        bit_backwards, bit_forwards, irqclass);
 }
-static int
+static const char *state_names[] = {
-check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
+#define LOCKDEP_STATE(__STATE) \
-                struct held_lock *next)
+        __stringify(__STATE),
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+static const char *state_rnames[] = {
+#define LOCKDEP_STATE(__STATE) \
+        __stringify(__STATE)"-READ",
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+static inline const char *state_name(enum lock_usage_bit bit)
+{
+        return (bit & 1) ? state_rnames[bit >> 2] : state_names[bit >> 2];
+}
+static int exclusive_bit(int new_bit)
+{
+        /*
+         * USED_IN
+         * USED_IN_READ
+         * ENABLED
+         * ENABLED_READ
+         *
+         * bit 0 - write/read
+         * bit 1 - used_in/enabled
+         * bit 2+  state
+         */
+        int state = new_bit & ~3;
+        int dir = new_bit & 2;
+        /*
+         * keep state, bit flip the direction and strip read.
+         */
+        return state | (dir ^ 2);
+}
+static int check_irq_usage(struct task_struct *curr, struct held_lock *prev,
+                           struct held_lock *next, enum lock_usage_bit bit)
 {
        /*
         * Prove that the new dependency does not connect a hardirq-safe
@@ -1273,38 +1316,34 @@ check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
         * the backwards-subgraph starting at <prev>, and the
         * forwards-subgraph starting at <next>:
         */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ,
+        if (!check_usage(curr, prev, next, bit,
-                                        LOCK_ENABLED_HARDIRQS, "hard"))
+                           exclusive_bit(bit), state_name(bit)))
                return 0;
+        bit++; /* _READ */
        /*
         * Prove that the new dependency does not connect a hardirq-safe-read
         * lock with a hardirq-unsafe lock - to achieve this we search
         * the backwards-subgraph starting at <prev>, and the
         * forwards-subgraph starting at <next>:
         */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ_READ,
+        if (!check_usage(curr, prev, next, bit,
-                                        LOCK_ENABLED_HARDIRQS, "hard-read"))
+                           exclusive_bit(bit), state_name(bit)))
                return 0;
-        /*
+        return 1;
-         * Prove that the new dependency does not connect a softirq-safe
+}
-         * lock with a softirq-unsafe lock - to achieve this we search
-         * the backwards-subgraph starting at <prev>, and the
+static int
-         * forwards-subgraph starting at <next>:
+check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
-         */
+                struct held_lock *next)
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ,
+{
-                                        LOCK_ENABLED_SOFTIRQS, "soft"))
+#define LOCKDEP_STATE(__STATE)                                          \
-                return 0;
+        if (!check_irq_usage(curr, prev, next, LOCK_USED_IN_##__STATE)) \
-        /*
-         * Prove that the new dependency does not connect a softirq-safe-read
-         * lock with a softirq-unsafe lock - to achieve this we search
-         * the backwards-subgraph starting at <prev>, and the
-         * forwards-subgraph starting at <next>:
-         */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ_READ,
-                                        LOCK_ENABLED_SOFTIRQS, "soft"))
                return 0;
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
        return 1;
 }
@@ -1933,7 +1972,7 @@ void print_irqtrace_events(struct task_struct *curr)
        print_ip_sym(curr->softirq_disable_ip);
 }
-static int hardirq_verbose(struct lock_class *class)
+static int HARDIRQ_verbose(struct lock_class *class)
 {
 #if HARDIRQ_VERBOSE
        return class_filter(class);
@@ -1941,7 +1980,7 @@ static int hardirq_verbose(struct lock_class *class)
        return 0;
 }
-static int softirq_verbose(struct lock_class *class)
+static int SOFTIRQ_verbose(struct lock_class *class)
 {
 #if SOFTIRQ_VERBOSE
        return class_filter(class);
@@ -1949,185 +1988,94 @@ static int softirq_verbose(struct lock_class *class)
        return 0;
 }
+static int RECLAIM_FS_verbose(struct lock_class *class)
+{
+#if RECLAIM_VERBOSE
+        return class_filter(class);
+#endif
+        return 0;
+}
 #define STRICT_READ_CHECKS      1
-static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
+static int (*state_verbose_f[])(struct lock_class *class) = {
-                enum lock_usage_bit new_bit)
+#define LOCKDEP_STATE(__STATE) \
+        __STATE##_verbose,
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+static inline int state_verbose(enum lock_usage_bit bit,
+                                struct lock_class *class)
 {
-        int ret = 1;
+        return state_verbose_f[bit >> 2](class);
+}
-        switch(new_bit) {
+typedef int (*check_usage_f)(struct task_struct *, struct held_lock *,
-        case LOCK_USED_IN_HARDIRQ:
+                             enum lock_usage_bit bit, const char *name);
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS))
-                        return 0;
+static int
-                if (!valid_state(curr, this, new_bit,
+mark_lock_irq(struct task_struct *curr, struct held_lock *this, int new_bit)
-                                 LOCK_ENABLED_HARDIRQS_READ))
+{
-                        return 0;
+        int excl_bit = exclusive_bit(new_bit);
-                /*
+        int read = new_bit & 1;
-                 * just marked it hardirq-safe, check that this lock
+        int dir = new_bit & 2;
-                 * took no hardirq-unsafe lock in the past:
-                 */
+        /*
-                if (!check_usage_forwards(curr, this,
+         * mark USED_IN has to look forwards -- to ensure no dependency
-                                          LOCK_ENABLED_HARDIRQS, "hard"))
+         * has ENABLED state, which would allow recursion deadlocks.
-                        return 0;
+         *
-#if STRICT_READ_CHECKS
+         * mark ENABLED has to look backwards -- to ensure no dependee
-                /*
+         * has USED_IN state, which, again, would allow  recursion deadlocks.
-                 * just marked it hardirq-safe, check that this lock
+         */
-                 * took no hardirq-unsafe-read lock in the past:
+        check_usage_f usage = dir ?
-                 */
+                check_usage_backwards : check_usage_forwards;
-                if (!check_usage_forwards(curr, this,
-                                LOCK_ENABLED_HARDIRQS_READ, "hard-read"))
+        /*
-                        return 0;
+         * Validate that this particular lock does not have conflicting
-#endif
+         * usage states.
-                if (hardirq_verbose(hlock_class(this)))
+         */
-                        ret = 2;
+        if (!valid_state(curr, this, new_bit, excl_bit))
-                break;
+                return 0;
-        case LOCK_USED_IN_SOFTIRQ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS))
+        /*
-                        return 0;
+         * Validate that the lock dependencies don't have conflicting usage
-                if (!valid_state(curr, this, new_bit,
+         * states.
-                                 LOCK_ENABLED_SOFTIRQS_READ))
+         */
-                        return 0;
+        if ((!read || !dir || STRICT_READ_CHECKS) &&
-                /*
+                        !usage(curr, this, excl_bit, state_name(new_bit)))
-                 * just marked it softirq-safe, check that this lock
+                return 0;
-                 * took no softirq-unsafe lock in the past:
-                 */
+        /*
-                if (!check_usage_forwards(curr, this,
+         * Check for read in write conflicts
-                                          LOCK_ENABLED_SOFTIRQS, "soft"))
+         */
-                        return 0;
+        if (!read) {
-#if STRICT_READ_CHECKS
+                if (!valid_state(curr, this, new_bit, excl_bit + 1))
-                /*
-                 * just marked it softirq-safe, check that this lock
-                 * took no softirq-unsafe-read lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                LOCK_ENABLED_SOFTIRQS_READ, "soft-read"))
-                        return 0;
-#endif
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_USED_IN_HARDIRQ_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS))
-                        return 0;
-                /*
-                 * just marked it hardirq-read-safe, check that this lock
-                 * took no hardirq-unsafe lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                          LOCK_ENABLED_HARDIRQS, "hard"))
-                        return 0;
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_USED_IN_SOFTIRQ_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS))
-                        return 0;
-                /*
-                 * just marked it softirq-read-safe, check that this lock
-                 * took no softirq-unsafe lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                          LOCK_ENABLED_SOFTIRQS, "soft"))
-                        return 0;
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_HARDIRQS:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
-                        return 0;
-                if (!valid_state(curr, this, new_bit,
-                                 LOCK_USED_IN_HARDIRQ_READ))
-                        return 0;
-                /*
-                 * just marked it hardirq-unsafe, check that no hardirq-safe
-                 * lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_HARDIRQ, "hard"))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it hardirq-unsafe, check that no
-                 * hardirq-safe-read lock in the system ever took
-                 * it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                   LOCK_USED_IN_HARDIRQ_READ, "hard-read"))
-                        return 0;
-#endif
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_SOFTIRQS:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
-                        return 0;
-                if (!valid_state(curr, this, new_bit,
-                                 LOCK_USED_IN_SOFTIRQ_READ))
-                        return 0;
-                /*
-                 * just marked it softirq-unsafe, check that no softirq-safe
-                 * lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_SOFTIRQ, "soft"))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it softirq-unsafe, check that no
-                 * softirq-safe-read lock in the system ever took
-                 * it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                   LOCK_USED_IN_SOFTIRQ_READ, "soft-read"))
-                        return 0;
-#endif
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_HARDIRQS_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it hardirq-read-unsafe, check that no
-                 * hardirq-safe lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_HARDIRQ, "hard"))
-                        return 0;
-#endif
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_SOFTIRQS_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
                        return 0;
-#if STRICT_READ_CHECKS
-                /*
+                if (STRICT_READ_CHECKS &&
-                 * just marked it softirq-read-unsafe, check that no
+                        !usage(curr, this, excl_bit + 1,
-                 * softirq-safe lock in the system ever took it in the past:
+                                state_name(new_bit + 1)))
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_SOFTIRQ, "soft"))
                        return 0;
-#endif
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        default:
-                WARN_ON(1);
-                break;
        }
-        return ret;
+        if (state_verbose(new_bit, hlock_class(this)))
+                return 2;
+        return 1;
 }
+enum mark_type {
+#define LOCKDEP_STATE(__STATE)  __STATE,
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
 /*
 * Mark all held locks with a usage bit:
 */
 static int
-mark_held_locks(struct task_struct *curr, int hardirq)
+mark_held_locks(struct task_struct *curr, enum mark_type mark)
 {
        enum lock_usage_bit usage_bit;
        struct held_lock *hlock;
@@ -2136,17 +2084,12 @@ mark_held_locks(struct task_struct *curr, int hardirq)
        for (i = 0; i < curr->lockdep_depth; i++) {
                hlock = curr->held_locks + i;
-                if (hardirq) {
+                usage_bit = 2 + (mark << 2); /* ENABLED */
-                        if (hlock->read)
+                if (hlock->read)
-                                usage_bit = LOCK_ENABLED_HARDIRQS_READ;
+                        usage_bit += 1; /* READ */
-                        else
-                                usage_bit = LOCK_ENABLED_HARDIRQS;
+                BUG_ON(usage_bit >= LOCK_USAGE_STATES);
-                } else {
-                        if (hlock->read)
-                                usage_bit = LOCK_ENABLED_SOFTIRQS_READ;
-                        else
-                                usage_bit = LOCK_ENABLED_SOFTIRQS;
-                }
                if (!mark_lock(curr, hlock, usage_bit))
                        return 0;
        }
@@ -2200,7 +2143,7 @@ void trace_hardirqs_on_caller(unsigned long ip)
         * We are going to turn hardirqs on, so set the
         * usage bit for all held locks:
         */
-        if (!mark_held_locks(curr, 1))
+        if (!mark_held_locks(curr, HARDIRQ))
                return;
        /*
         * If we have softirqs enabled, then set the usage
@@ -2208,7 +2151,7 @@ void trace_hardirqs_on_caller(unsigned long ip)
         * this bit from being set before)
         */
        if (curr->softirqs_enabled)
-                if (!mark_held_locks(curr, 0))
+                if (!mark_held_locks(curr, SOFTIRQ))
                        return;
        curr->hardirq_enable_ip = ip;
@@ -2288,7 +2231,7 @@ void trace_softirqs_on(unsigned long ip)
         * enabled too:
         */
        if (curr->hardirqs_enabled)
-                mark_held_locks(curr, 0);
+                mark_held_locks(curr, SOFTIRQ);
 }
 /*
@@ -2317,6 +2260,48 @@ void trace_softirqs_off(unsigned long ip)
                debug_atomic_inc(&redundant_softirqs_off);
 }
+static void __lockdep_trace_alloc(gfp_t gfp_mask, unsigned long flags)
+{
+        struct task_struct *curr = current;
+        if (unlikely(!debug_locks))
+                return;
+        /* no reclaim without waiting on it */
+        if (!(gfp_mask & __GFP_WAIT))
+                return;
+        /* this guy won't enter reclaim */
+        if ((curr->flags & PF_MEMALLOC) && !(gfp_mask & __GFP_NOMEMALLOC))
+                return;
+        /* We're only interested __GFP_FS allocations for now */
+        if (!(gfp_mask & __GFP_FS))
+                return;
+        if (DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags)))
+                return;
+        mark_held_locks(curr, RECLAIM_FS);
+}
+static void check_flags(unsigned long flags);
+void lockdep_trace_alloc(gfp_t gfp_mask)
+{
+        unsigned long flags;
+        if (unlikely(current->lockdep_recursion))
+                return;
+        raw_local_irq_save(flags);
+        check_flags(flags);
+        current->lockdep_recursion = 1;
+        __lockdep_trace_alloc(gfp_mask, flags);
+        current->lockdep_recursion = 0;
+        raw_local_irq_restore(flags);
+}
 static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock)
 {
        /*
@@ -2345,19 +2330,35 @@ static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock)
        if (!hlock->hardirqs_off) {
                if (hlock->read) {
                        if (!mark_lock(curr, hlock,
-                                        LOCK_ENABLED_HARDIRQS_READ))
+                                        LOCK_ENABLED_HARDIRQ_READ))
                                return 0;
                        if (curr->softirqs_enabled)
                                if (!mark_lock(curr, hlock,
-                                                LOCK_ENABLED_SOFTIRQS_READ))
+                                                LOCK_ENABLED_SOFTIRQ_READ))
                                        return 0;
                } else {
                        if (!mark_lock(curr, hlock,
-                                        LOCK_ENABLED_HARDIRQS))
+                                        LOCK_ENABLED_HARDIRQ))
                                return 0;
                        if (curr->softirqs_enabled)
                                if (!mark_lock(curr, hlock,
-                                                LOCK_ENABLED_SOFTIRQS))
+                                                LOCK_ENABLED_SOFTIRQ))
+                                        return 0;
+                }
+        }
+        /*
+         * We reuse the irq context infrastructure more broadly as a general
+         * context checking code. This tests GFP_FS recursion (a lock taken
+         * during reclaim for a GFP_FS allocation is held over a GFP_FS
+         * allocation).
+         */
+        if (!hlock->trylock && (curr->lockdep_reclaim_gfp & __GFP_FS)) {
+                if (hlock->read) {
+                        if (!mark_lock(curr, hlock, LOCK_USED_IN_RECLAIM_FS_READ))
+                                        return 0;
+                } else {
+                        if (!mark_lock(curr, hlock, LOCK_USED_IN_RECLAIM_FS))
                                        return 0;
                }
        }
@@ -2412,6 +2413,10 @@ static inline int separate_irq_context(struct task_struct *curr,
        return 0;
 }
+void lockdep_trace_alloc(gfp_t gfp_mask)
+{
+}
 #endif
 /*
@@ -2445,14 +2450,13 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this,
                return 0;
        switch (new_bit) {
-        case LOCK_USED_IN_HARDIRQ:
+#define LOCKDEP_STATE(__STATE)                  \
-        case LOCK_USED_IN_SOFTIRQ:
+        case LOCK_USED_IN_##__STATE:            \
-        case LOCK_USED_IN_HARDIRQ_READ:
+        case LOCK_USED_IN_##__STATE##_READ:     \
-        case LOCK_USED_IN_SOFTIRQ_READ:
+        case LOCK_ENABLED_##__STATE:            \
-        case LOCK_ENABLED_HARDIRQS:
+        case LOCK_ENABLED_##__STATE##_READ:
-        case LOCK_ENABLED_SOFTIRQS:
+#include "lockdep_states.h"
-        case LOCK_ENABLED_HARDIRQS_READ:
+#undef LOCKDEP_STATE
-        case LOCK_ENABLED_SOFTIRQS_READ:
                ret = mark_lock_irq(curr, this, new_bit);
                if (!ret)
                        return 0;
@@ -2966,6 +2970,16 @@ void lock_release(struct lockdep_map *lock, int nested,
 }
 EXPORT_SYMBOL_GPL(lock_release);
+void lockdep_set_current_reclaim_state(gfp_t gfp_mask)
+{
+        current->lockdep_reclaim_gfp = gfp_mask;
+}
+void lockdep_clear_current_reclaim_state(void)
+{
+        current->lockdep_reclaim_gfp = 0;
+}
 #ifdef CONFIG_LOCK_STAT
 static int
 print_lock_contention_bug(struct task_struct *curr, struct lockdep_map *lock,
diff --git a/kernel/lockdep_internals.h b/kernel/lockdep_internals.h
index 56b196932c08..a2cc7e9a6e84 100644
--- a/kernel/lockdep_internals.h
+++ b/kernel/lockdep_internals.h
@@ -7,6 +7,45 @@
 */
 /*
+ * Lock-class usage-state bits:
+ */
+enum lock_usage_bit {
+#define LOCKDEP_STATE(__STATE)          \
+        LOCK_USED_IN_##__STATE,         \
+        LOCK_USED_IN_##__STATE##_READ,  \
+        LOCK_ENABLED_##__STATE,         \
+        LOCK_ENABLED_##__STATE##_READ,
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+        LOCK_USED,
+        LOCK_USAGE_STATES
+};
+/*
+ * Usage-state bitmasks:
+ */
+#define __LOCKF(__STATE)        LOCKF_##__STATE = (1 << LOCK_##__STATE),
+enum {
+#define LOCKDEP_STATE(__STATE)                                          \
+        __LOCKF(USED_IN_##__STATE)                                      \
+        __LOCKF(USED_IN_##__STATE##_READ)                               \
+        __LOCKF(ENABLED_##__STATE)                                      \
+        __LOCKF(ENABLED_##__STATE##_READ)
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+        __LOCKF(USED)
+};
+#define LOCKF_ENABLED_IRQ (LOCKF_ENABLED_HARDIRQ | LOCKF_ENABLED_SOFTIRQ)
+#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ)
+#define LOCKF_ENABLED_IRQ_READ \
+                (LOCKF_ENABLED_HARDIRQ_READ | LOCKF_ENABLED_SOFTIRQ_READ)
+#define LOCKF_USED_IN_IRQ_READ \
+                (LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ)
+/*
 * MAX_LOCKDEP_ENTRIES is the maximum number of lock dependencies
 * we track.
 *
@@ -31,8 +70,10 @@
 extern struct list_head all_lock_classes;
 extern struct lock_chain lock_chains[];
-extern void
+#define LOCK_USAGE_CHARS (1+LOCK_USAGE_STATES/2)
-get_usage_chars(struct lock_class *class, char *c1, char *c2, char *c3, char *c4);
+extern void get_usage_chars(struct lock_class *class,
+                            char usage[LOCK_USAGE_CHARS]);
 extern const char * __get_key_name(struct lockdep_subclass_key *key, char *str);
diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
index 13716b813896..d7135aa2d2c4 100644
--- a/kernel/lockdep_proc.c
+++ b/kernel/lockdep_proc.c
@@ -84,7 +84,7 @@ static int l_show(struct seq_file *m, void *v)
 {
        struct lock_class *class = v;
        struct lock_list *entry;
-        char c1, c2, c3, c4;
+        char usage[LOCK_USAGE_CHARS];
        if (v == SEQ_START_TOKEN) {
                seq_printf(m, "all lock classes:\n");
@@ -100,8 +100,8 @@ static int l_show(struct seq_file *m, void *v)
        seq_printf(m, " BD:%5ld", lockdep_count_backward_deps(class));
 #endif
-        get_usage_chars(class, &c1, &c2, &c3, &c4);
+        get_usage_chars(class, usage);
-        seq_printf(m, " %c%c%c%c", c1, c2, c3, c4);
+        seq_printf(m, " %s", usage);
        seq_printf(m, ": ");
        print_name(m, class);
@@ -300,27 +300,27 @@ static int lockdep_stats_show(struct seq_file *m, void *v)
                        nr_uncategorized++;
                if (class->usage_mask & LOCKF_USED_IN_IRQ)
                        nr_irq_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_IRQS)
+                if (class->usage_mask & LOCKF_ENABLED_IRQ)
                        nr_irq_unsafe++;
                if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
                        nr_softirq_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS)
+                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ)
                        nr_softirq_unsafe++;
                if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
                        nr_hardirq_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS)
+                if (class->usage_mask & LOCKF_ENABLED_HARDIRQ)
                        nr_hardirq_unsafe++;
                if (class->usage_mask & LOCKF_USED_IN_IRQ_READ)
                        nr_irq_read_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_IRQS_READ)
+                if (class->usage_mask & LOCKF_ENABLED_IRQ_READ)
                        nr_irq_read_unsafe++;
                if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ)
                        nr_softirq_read_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
+                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ_READ)
                        nr_softirq_read_unsafe++;
                if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ)
                        nr_hardirq_read_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
+                if (class->usage_mask & LOCKF_ENABLED_HARDIRQ_READ)
                        nr_hardirq_read_unsafe++;
 #ifdef CONFIG_PROVE_LOCKING
@@ -601,6 +601,10 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
 static void seq_header(struct seq_file *m)
 {
        seq_printf(m, "lock_stat version 0.3\n");
+        if (unlikely(!debug_locks))
+                seq_printf(m, "*WARNING* lock debugging disabled!! - possibly due to a lockdep warning\n");
        seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
        seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s "
                        "%14s %14s\n",
diff --git a/kernel/lockdep_states.h b/kernel/lockdep_states.h
new file mode 100644
index 000000000000..995b0cc2b84c
--- /dev/null
+++ b/kernel/lockdep_states.h
@@ -0,0 +1,9 @@
+/*
+ * Lockdep states,
+ *
+ * please update XXX_LOCK_USAGE_STATES in include/linux/lockdep.h whenever
+ * you add one, or come up with a nice dynamic solution.
+ */
+LOCKDEP_STATE(HARDIRQ)
+LOCKDEP_STATE(SOFTIRQ)
+LOCKDEP_STATE(RECLAIM_FS)
diff --git a/kernel/module.c b/kernel/module.c
index 1196f5d11700..f77ac320d0b5 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -51,6 +51,7 @@
 #include <linux/tracepoint.h>
 #include <linux/ftrace.h>
 #include <linux/async.h>
+#include <linux/percpu.h>
 #if 0
 #define DEBUGP printk
@@ -366,6 +367,34 @@ static struct module *find_module(const char *name)
 }
 #ifdef CONFIG_SMP
+#ifdef CONFIG_HAVE_DYNAMIC_PER_CPU_AREA
+static void *percpu_modalloc(unsigned long size, unsigned long align,
+                             const char *name)
+{
+        void *ptr;
+        if (align > PAGE_SIZE) {
+                printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
+                       name, align, PAGE_SIZE);
+                align = PAGE_SIZE;
+        }
+        ptr = __alloc_reserved_percpu(size, align);
+        if (!ptr)
+                printk(KERN_WARNING
+                       "Could not allocate %lu bytes percpu data\n", size);
+        return ptr;
+}
+static void percpu_modfree(void *freeme)
+{
+        free_percpu(freeme);
+}
+#else /* ... !CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */
 /* Number of blocks used and allocated. */
 static unsigned int pcpu_num_used, pcpu_num_allocated;
 /* Size of each block.  -ve means used. */
@@ -480,21 +509,6 @@ static void percpu_modfree(void *freeme)
        }
 }
-static unsigned int find_pcpusec(Elf_Ehdr *hdr,
-                                 Elf_Shdr *sechdrs,
-                                 const char *secstrings)
-{
-        return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
-}
-static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
-{
-        int cpu;
-        for_each_possible_cpu(cpu)
-                memcpy(pcpudest + per_cpu_offset(cpu), from, size);
-}
 static int percpu_modinit(void)
 {
        pcpu_num_used = 2;
@@ -513,7 +527,26 @@ static int percpu_modinit(void)
        return 0;
 }
 __initcall(percpu_modinit);
+#endif /* CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */
+static unsigned int find_pcpusec(Elf_Ehdr *hdr,
+                                 Elf_Shdr *sechdrs,
+                                 const char *secstrings)
+{
+        return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
+}
+static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
+{
+        int cpu;
+        for_each_possible_cpu(cpu)
+                memcpy(pcpudest + per_cpu_offset(cpu), from, size);
+}
 #else /* ... !CONFIG_SMP */
 static inline void *percpu_modalloc(unsigned long size, unsigned long align,
                                    const char *name)
 {
@@ -535,6 +568,7 @@ static inline void percpu_modcopy(void *pcpudst, const void *src,
        /* pcpusec should be 0, and size of that section should be 0. */
        BUG_ON(size != 0);
 }
 #endif /* CONFIG_SMP */
 #define MODINFO_ATTR(field)     \
@@ -822,7 +856,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:
@@ -1827,19 +1861,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
+#ifdef CONFIG_DYNAMIC_DEBUG
-        unsigned int i;
+        if (ddebug_add_module(debug, num, debug->modname))
+                printk(KERN_ERR "dynamic debug error adding module: %s\n",
-        for (i = 0; i < num; i++) {
+                                        debug->modname);
-                register_dynamic_debug_module(debug[i].modname,
+#endif
-                                              debug[i].type,
-                                              debug[i].logical_modname,
-                                              debug[i].flag_names,
-                                              debug[i].hash, debug[i].hash2);
-        }
-#endif /* CONFIG_DYNAMIC_PRINTK_DEBUG */
 }
 static void *module_alloc_update_bounds(unsigned long size)
@@ -2213,12 +2241,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 */
diff --git a/kernel/mutex-debug.c b/kernel/mutex-debug.c
index 1d94160eb532..50d022e5a560 100644
--- a/kernel/mutex-debug.c
+++ b/kernel/mutex-debug.c
@@ -26,11 +26,6 @@
 /*
 * Must be called with lock->wait_lock held.
 */
-void debug_mutex_set_owner(struct mutex *lock, struct thread_info *new_owner)
-{
-        lock->owner = new_owner;
-}
 void debug_mutex_lock_common(struct mutex *lock, struct mutex_waiter *waiter)
 {
        memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter));
@@ -59,7 +54,6 @@ void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,
        /* Mark the current thread as blocked on the lock: */
        ti->task->blocked_on = waiter;
-        waiter->lock = lock;
 }
 void mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter,
@@ -82,7 +76,7 @@ void debug_mutex_unlock(struct mutex *lock)
        DEBUG_LOCKS_WARN_ON(lock->magic != lock);
        DEBUG_LOCKS_WARN_ON(lock->owner != current_thread_info());
        DEBUG_LOCKS_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next);
-        DEBUG_LOCKS_WARN_ON(lock->owner != current_thread_info());
+        mutex_clear_owner(lock);
 }
 void debug_mutex_init(struct mutex *lock, const char *name,
@@ -95,7 +89,6 @@ void debug_mutex_init(struct mutex *lock, const char *name,
        debug_check_no_locks_freed((void *)lock, sizeof(*lock));
        lockdep_init_map(&lock->dep_map, name, key, 0);
 #endif
-        lock->owner = NULL;
        lock->magic = lock;
 }
diff --git a/kernel/mutex-debug.h b/kernel/mutex-debug.h
index babfbdfc534b..6b2d735846a5 100644
--- a/kernel/mutex-debug.h
+++ b/kernel/mutex-debug.h
@@ -13,14 +13,6 @@
 /*
 * This must be called with lock->wait_lock held.
 */
-extern void
-debug_mutex_set_owner(struct mutex *lock, struct thread_info *new_owner);
-static inline void debug_mutex_clear_owner(struct mutex *lock)
-{
-        lock->owner = NULL;
-}
 extern void debug_mutex_lock_common(struct mutex *lock,
                                    struct mutex_waiter *waiter);
 extern void debug_mutex_wake_waiter(struct mutex *lock,
@@ -35,6 +27,16 @@ extern void debug_mutex_unlock(struct mutex *lock);
 extern void debug_mutex_init(struct mutex *lock, const char *name,
                             struct lock_class_key *key);
+static inline void mutex_set_owner(struct mutex *lock)
+{
+        lock->owner = current_thread_info();
+}
+static inline void mutex_clear_owner(struct mutex *lock)
+{
+        lock->owner = NULL;
+}
 #define spin_lock_mutex(lock, flags)                    \
        do {                                            \
                struct mutex *l = container_of(lock, struct mutex, wait_lock); \
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 4f45d4b658ef..5d79781394a3 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -10,6 +10,11 @@
 * Many thanks to Arjan van de Ven, Thomas Gleixner, Steven Rostedt and
 * David Howells for suggestions and improvements.
 *
+ *  - Adaptive spinning for mutexes by Peter Zijlstra. (Ported to mainline
+ *    from the -rt tree, where it was originally implemented for rtmutexes
+ *    by Steven Rostedt, based on work by Gregory Haskins, Peter Morreale
+ *    and Sven Dietrich.
+ *
 * Also see Documentation/mutex-design.txt.
 */
 #include <linux/mutex.h>
@@ -46,6 +51,7 @@ __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
        atomic_set(&lock->count, 1);
        spin_lock_init(&lock->wait_lock);
        INIT_LIST_HEAD(&lock->wait_list);
+        mutex_clear_owner(lock);
        debug_mutex_init(lock, name, key);
 }
@@ -91,6 +97,7 @@ void inline __sched mutex_lock(struct mutex *lock)
         * 'unlocked' into 'locked' state.
         */
        __mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);
+        mutex_set_owner(lock);
 }
 EXPORT_SYMBOL(mutex_lock);
@@ -115,6 +122,14 @@ void __sched mutex_unlock(struct mutex *lock)
         * The unlocking fastpath is the 0->1 transition from 'locked'
         * into 'unlocked' state:
         */
+#ifndef CONFIG_DEBUG_MUTEXES
+        /*
+         * When debugging is enabled we must not clear the owner before time,
+         * the slow path will always be taken, and that clears the owner field
+         * after verifying that it was indeed current.
+         */
+        mutex_clear_owner(lock);
+#endif
        __mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);
 }
@@ -129,21 +144,75 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
 {
        struct task_struct *task = current;
        struct mutex_waiter waiter;
-        unsigned int old_val;
        unsigned long flags;
+        preempt_disable();
+        mutex_acquire(&lock->dep_map, subclass, 0, ip);
+#if defined(CONFIG_SMP) && !defined(CONFIG_DEBUG_MUTEXES)
+        /*
+         * Optimistic spinning.
+         *
+         * We try to spin for acquisition when we find that there are no
+         * pending waiters and the lock owner is currently running on a
+         * (different) CPU.
+         *
+         * The rationale is that if the lock owner is running, it is likely to
+         * release the lock soon.
+         *
+         * Since this needs the lock owner, and this mutex implementation
+         * doesn't track the owner atomically in the lock field, we need to
+         * track it non-atomically.
+         *
+         * We can't do this for DEBUG_MUTEXES because that relies on wait_lock
+         * to serialize everything.
+         */
+        for (;;) {
+                struct thread_info *owner;
+                /*
+                 * If there's an owner, wait for it to either
+                 * release the lock or go to sleep.
+                 */
+                owner = ACCESS_ONCE(lock->owner);
+                if (owner && !mutex_spin_on_owner(lock, owner))
+                        break;
+                if (atomic_cmpxchg(&lock->count, 1, 0) == 1) {
+                        lock_acquired(&lock->dep_map, ip);
+                        mutex_set_owner(lock);
+                        preempt_enable();
+                        return 0;
+                }
+                /*
+                 * When there's no owner, we might have preempted between the
+                 * owner acquiring the lock and setting the owner field. If
+                 * we're an RT task that will live-lock because we won't let
+                 * the owner complete.
+                 */
+                if (!owner && (need_resched() || rt_task(task)))
+                        break;
+                /*
+                 * The cpu_relax() call is a compiler barrier which forces
+                 * everything in this loop to be re-loaded. We don't need
+                 * memory barriers as we'll eventually observe the right
+                 * values at the cost of a few extra spins.
+                 */
+                cpu_relax();
+        }
+#endif
        spin_lock_mutex(&lock->wait_lock, flags);
        debug_mutex_lock_common(lock, &waiter);
-        mutex_acquire(&lock->dep_map, subclass, 0, ip);
        debug_mutex_add_waiter(lock, &waiter, task_thread_info(task));
        /* add waiting tasks to the end of the waitqueue (FIFO): */
        list_add_tail(&waiter.list, &lock->wait_list);
        waiter.task = task;
-        old_val = atomic_xchg(&lock->count, -1);
+        if (atomic_xchg(&lock->count, -1) == 1)
-        if (old_val == 1)
                goto done;
        lock_contended(&lock->dep_map, ip);
@@ -158,8 +227,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
                 * that when we release the lock, we properly wake up the
                 * other waiters:
                 */
-                old_val = atomic_xchg(&lock->count, -1);
+                if (atomic_xchg(&lock->count, -1) == 1)
-                if (old_val == 1)
                        break;
                /*
@@ -173,21 +241,22 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
                        spin_unlock_mutex(&lock->wait_lock, flags);
                        debug_mutex_free_waiter(&waiter);
+                        preempt_enable();
                        return -EINTR;
                }
                __set_task_state(task, state);
                /* didnt get the lock, go to sleep: */
                spin_unlock_mutex(&lock->wait_lock, flags);
-                schedule();
+                __schedule();
                spin_lock_mutex(&lock->wait_lock, flags);
        }
 done:
        lock_acquired(&lock->dep_map, ip);
        /* got the lock - rejoice! */
-        mutex_remove_waiter(lock, &waiter, task_thread_info(task));
+        mutex_remove_waiter(lock, &waiter, current_thread_info());
-        debug_mutex_set_owner(lock, task_thread_info(task));
+        mutex_set_owner(lock);
        /* set it to 0 if there are no waiters left: */
        if (likely(list_empty(&lock->wait_list)))
@@ -196,6 +265,7 @@ done:
        spin_unlock_mutex(&lock->wait_lock, flags);
        debug_mutex_free_waiter(&waiter);
+        preempt_enable();
        return 0;
 }
@@ -222,7 +292,8 @@ int __sched
 mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass)
 {
        might_sleep();
-        return __mutex_lock_common(lock, TASK_INTERRUPTIBLE, subclass, _RET_IP_);
+        return __mutex_lock_common(lock, TASK_INTERRUPTIBLE,
+                                   subclass, _RET_IP_);
 }
 EXPORT_SYMBOL_GPL(mutex_lock_interruptible_nested);
@@ -260,8 +331,6 @@ __mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
                wake_up_process(waiter->task);
        }
-        debug_mutex_clear_owner(lock);
        spin_unlock_mutex(&lock->wait_lock, flags);
 }
@@ -298,18 +367,30 @@ __mutex_lock_interruptible_slowpath(atomic_t *lock_count);
 */
 int __sched mutex_lock_interruptible(struct mutex *lock)
 {
+        int ret;
        might_sleep();
-        return __mutex_fastpath_lock_retval
+        ret =  __mutex_fastpath_lock_retval
                        (&lock->count, __mutex_lock_interruptible_slowpath);
+        if (!ret)
+                mutex_set_owner(lock);
+        return ret;
 }
 EXPORT_SYMBOL(mutex_lock_interruptible);
 int __sched mutex_lock_killable(struct mutex *lock)
 {
+        int ret;
        might_sleep();
-        return __mutex_fastpath_lock_retval
+        ret = __mutex_fastpath_lock_retval
                        (&lock->count, __mutex_lock_killable_slowpath);
+        if (!ret)
+                mutex_set_owner(lock);
+        return ret;
 }
 EXPORT_SYMBOL(mutex_lock_killable);
@@ -352,9 +433,10 @@ static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
        prev = atomic_xchg(&lock->count, -1);
        if (likely(prev == 1)) {
-                debug_mutex_set_owner(lock, current_thread_info());
+                mutex_set_owner(lock);
                mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);
        }
        /* Set it back to 0 if there are no waiters: */
        if (likely(list_empty(&lock->wait_list)))
                atomic_set(&lock->count, 0);
@@ -380,8 +462,13 @@ static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
 */
 int __sched mutex_trylock(struct mutex *lock)
 {
-        return __mutex_fastpath_trylock(&lock->count,
+        int ret;
-                                        __mutex_trylock_slowpath);
+        ret = __mutex_fastpath_trylock(&lock->count, __mutex_trylock_slowpath);
+        if (ret)
+                mutex_set_owner(lock);
+        return ret;
 }
 EXPORT_SYMBOL(mutex_trylock);
diff --git a/kernel/mutex.h b/kernel/mutex.h
index a075dafbb290..67578ca48f94 100644
--- a/kernel/mutex.h
+++ b/kernel/mutex.h
@@ -16,8 +16,26 @@
 #define mutex_remove_waiter(lock, waiter, ti) \
                __list_del((waiter)->list.prev, (waiter)->list.next)
-#define debug_mutex_set_owner(lock, new_owner)          do { } while (0)
+#ifdef CONFIG_SMP
-#define debug_mutex_clear_owner(lock)                   do { } while (0)
+static inline void mutex_set_owner(struct mutex *lock)
+{
+        lock->owner = current_thread_info();
+}
+static inline void mutex_clear_owner(struct mutex *lock)
+{
+        lock->owner = NULL;
+}
+#else
+static inline void mutex_set_owner(struct mutex *lock)
+{
+}
+static inline void mutex_clear_owner(struct mutex *lock)
+{
+}
+#endif
 #define debug_mutex_wake_waiter(lock, waiter)           do { } while (0)
 #define debug_mutex_free_waiter(waiter)                 do { } while (0)
 #define debug_mutex_add_waiter(lock, waiter, ti)        do { } while (0)
diff --git a/kernel/panic.c b/kernel/panic.c
index 2a2ff36ff44d..32fe4eff1b89 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -74,6 +74,9 @@ NORET_TYPE void panic(const char * fmt, ...)
        vsnprintf(buf, sizeof(buf), fmt, args);
        va_end(args);
        printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
+#ifdef CONFIG_DEBUG_BUGVERBOSE
+        dump_stack();
+#endif
        bust_spinlocks(0);
        /*
@@ -355,15 +358,18 @@ EXPORT_SYMBOL(warn_slowpath);
 #endif
 #ifdef CONFIG_CC_STACKPROTECTOR
 /*
 * Called when gcc's -fstack-protector feature is used, and
 * gcc detects corruption of the on-stack canary value
 */
 void __stack_chk_fail(void)
 {
-        panic("stack-protector: Kernel stack is corrupted");
+        panic("stack-protector: Kernel stack is corrupted in: %p\n",
+                __builtin_return_address(0));
 }
 EXPORT_SYMBOL(__stack_chk_fail);
 #endif
 core_param(panic, panic_timeout, int, 0644);
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index e976e505648d..8e5d9a68b022 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -1370,7 +1370,8 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
                if (task_cputime_expired(&group_sample, &sig->cputime_expires))
                        return 1;
        }
-        return 0;
+        return sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY;
 }
 /*
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 4a4a206b1979..e886d1332a10 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -214,7 +214,7 @@ static int create_image(int platform_mode)
                return error;
        device_pm_lock();
-        local_irq_disable();
        /* At this point, device_suspend() has been called, but *not*
         * device_power_down(). We *must* call device_power_down() now.
         * Otherwise, drivers for some devices (e.g. interrupt controllers)
@@ -225,13 +225,25 @@ static int create_image(int platform_mode)
        if (error) {
                printk(KERN_ERR "PM: Some devices failed to power down, "
                        "aborting hibernation\n");
-                goto Enable_irqs;
+                goto Unlock;
        }
+        error = platform_pre_snapshot(platform_mode);
+        if (error || hibernation_test(TEST_PLATFORM))
+                goto Platform_finish;
+        error = disable_nonboot_cpus();
+        if (error || hibernation_test(TEST_CPUS)
+            || hibernation_testmode(HIBERNATION_TEST))
+                goto Enable_cpus;
+        local_irq_disable();
        sysdev_suspend(PMSG_FREEZE);
        if (error) {
                printk(KERN_ERR "PM: Some devices failed to power down, "
                        "aborting hibernation\n");
-                goto Power_up_devices;
+                goto Enable_irqs;
        }
        if (hibernation_test(TEST_CORE))
@@ -247,17 +259,28 @@ static int create_image(int platform_mode)
        restore_processor_state();
        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:
        local_irq_enable();
+ Enable_cpus:
+        enable_nonboot_cpus();
+ Platform_finish:
+        platform_finish(platform_mode);
+        device_power_up(in_suspend ?
+                (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
+ Unlock:
        device_pm_unlock();
        return error;
 }
@@ -291,25 +314,9 @@ int hibernation_snapshot(int platform_mode)
        if (hibernation_test(TEST_DEVICES))
                goto Recover_platform;
-        error = platform_pre_snapshot(platform_mode);
+        error = create_image(platform_mode);
-        if (error || hibernation_test(TEST_PLATFORM))
+        /* Control returns here after successful restore */
-                goto Finish;
-        error = disable_nonboot_cpus();
-        if (!error) {
-                if (hibernation_test(TEST_CPUS))
-                        goto Enable_cpus;
-                if (hibernation_testmode(HIBERNATION_TEST))
-                        goto Enable_cpus;
-                error = create_image(platform_mode);
-                /* Control returns here after successful restore */
-        }
- Enable_cpus:
-        enable_nonboot_cpus();
- Finish:
-        platform_finish(platform_mode);
 Resume_devices:
        device_resume(in_suspend ?
                (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
@@ -331,19 +338,33 @@ int hibernation_snapshot(int platform_mode)
 *      kernel.
 */
-static int resume_target_kernel(void)
+static int resume_target_kernel(bool platform_mode)
 {
        int error;
        device_pm_lock();
-        local_irq_disable();
        error = device_power_down(PMSG_QUIESCE);
        if (error) {
                printk(KERN_ERR "PM: Some devices failed to power down, "
                        "aborting resume\n");
-                goto Enable_irqs;
+                goto Unlock;
        }
-        sysdev_suspend(PMSG_QUIESCE);
+        error = platform_pre_restore(platform_mode);
+        if (error)
+                goto Cleanup;
+        error = disable_nonboot_cpus();
+        if (error)
+                goto Enable_cpus;
+        local_irq_disable();
+        error = sysdev_suspend(PMSG_QUIESCE);
+        if (error)
+                goto Enable_irqs;
        /* We'll ignore saved state, but this gets preempt count (etc) right */
        save_processor_state();
        error = restore_highmem();
@@ -366,11 +387,23 @@ 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();
+ Enable_cpus:
+        enable_nonboot_cpus();
+ Cleanup:
+        platform_restore_cleanup(platform_mode);
+        device_power_up(PMSG_RECOVER);
+ Unlock:
        device_pm_unlock();
        return error;
 }
@@ -390,19 +423,10 @@ int hibernation_restore(int platform_mode)
        pm_prepare_console();
        suspend_console();
        error = device_suspend(PMSG_QUIESCE);
-        if (error)
-                goto Finish;
-        error = platform_pre_restore(platform_mode);
        if (!error) {
-                error = disable_nonboot_cpus();
+                error = resume_target_kernel(platform_mode);
-                if (!error)
+                device_resume(PMSG_RECOVER);
-                        error = resume_target_kernel();
-                enable_nonboot_cpus();
        }
-        platform_restore_cleanup(platform_mode);
-        device_resume(PMSG_RECOVER);
- Finish:
        resume_console();
        pm_restore_console();
        return error;
@@ -438,38 +462,46 @@ int hibernation_platform_enter(void)
                goto Resume_devices;
        }
+        device_pm_lock();
+        error = device_power_down(PMSG_HIBERNATE);
+        if (error)
+                goto Unlock;
        error = hibernation_ops->prepare();
        if (error)
-                goto Resume_devices;
+                goto Platofrm_finish;
        error = disable_nonboot_cpus();
        if (error)
-                goto Finish;
+                goto Platofrm_finish;
-        device_pm_lock();
        local_irq_disable();
-        error = device_power_down(PMSG_HIBERNATE);
+        sysdev_suspend(PMSG_HIBERNATE);
-        if (!error) {
+        hibernation_ops->enter();
-                sysdev_suspend(PMSG_HIBERNATE);
+        /* We should never get here */
-                hibernation_ops->enter();
+        while (1);
-                /* We should never get here */
-                while (1);
-        }
-        local_irq_enable();
-        device_pm_unlock();
        /*
         * We don't need to reenable the nonboot CPUs or resume consoles, since
         * the system is going to be halted anyway.
         */
- Finish:
+ Platofrm_finish:
        hibernation_ops->finish();
+        device_power_up(PMSG_RESTORE);
+ Unlock:
+        device_pm_unlock();
 Resume_devices:
        entering_platform_hibernation = false;
        device_resume(PMSG_RESTORE);
        resume_console();
 Close:
        hibernation_ops->end();
        return error;
 }
diff --git a/kernel/power/main.c b/kernel/power/main.c
index c9632f841f64..f172f41858bb 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -287,17 +287,32 @@ void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
 */
 static int suspend_enter(suspend_state_t state)
 {
-        int error = 0;
+        int error;
        device_pm_lock();
-        arch_suspend_disable_irqs();
-        BUG_ON(!irqs_disabled());
-        if ((error = device_power_down(PMSG_SUSPEND))) {
+        error = device_power_down(PMSG_SUSPEND);
+        if (error) {
                printk(KERN_ERR "PM: Some devices failed to power down\n");
                goto Done;
        }
+        if (suspend_ops->prepare) {
+                error = suspend_ops->prepare();
+                if (error)
+                        goto Power_up_devices;
+        }
+        if (suspend_test(TEST_PLATFORM))
+                goto Platfrom_finish;
+        error = disable_nonboot_cpus();
+        if (error || suspend_test(TEST_CPUS))
+                goto Enable_cpus;
+        arch_suspend_disable_irqs();
+        BUG_ON(!irqs_disabled());
        error = sysdev_suspend(PMSG_SUSPEND);
        if (!error) {
                if (!suspend_test(TEST_CORE))
@@ -305,11 +320,22 @@ static int suspend_enter(suspend_state_t state)
                sysdev_resume();
        }
-        device_power_up(PMSG_RESUME);
- Done:
        arch_suspend_enable_irqs();
        BUG_ON(irqs_disabled());
+ Enable_cpus:
+        enable_nonboot_cpus();
+ Platfrom_finish:
+        if (suspend_ops->finish)
+                suspend_ops->finish();
+ Power_up_devices:
+        device_power_up(PMSG_RESUME);
+ Done:
        device_pm_unlock();
        return error;
 }
@@ -341,23 +367,8 @@ int suspend_devices_and_enter(suspend_state_t state)
        if (suspend_test(TEST_DEVICES))
                goto Recover_platform;
-        if (suspend_ops->prepare) {
+        suspend_enter(state);
-                error = suspend_ops->prepare();
-                if (error)
-                        goto Resume_devices;
-        }
-        if (suspend_test(TEST_PLATFORM))
-                goto Finish;
-        error = disable_nonboot_cpus();
-        if (!error && !suspend_test(TEST_CPUS))
-                suspend_enter(state);
-        enable_nonboot_cpus();
- Finish:
-        if (suspend_ops->finish)
-                suspend_ops->finish();
 Resume_devices:
        suspend_test_start();
        device_resume(PMSG_RESUME);
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 7c4142a79f0a..9b4a975a4b4a 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -126,6 +126,7 @@ static atomic_t n_rcu_torture_mberror;
 static atomic_t n_rcu_torture_error;
 static long n_rcu_torture_timers = 0;
 static struct list_head rcu_torture_removed;
+static cpumask_var_t shuffle_tmp_mask;
 static int stutter_pause_test = 0;
@@ -889,10 +890,9 @@ static int rcu_idle_cpu;	/* Force all torture tasks off this CPU */
 */
 static void rcu_torture_shuffle_tasks(void)
 {
-        cpumask_t tmp_mask;
        int i;
-        cpus_setall(tmp_mask);
+        cpumask_setall(shuffle_tmp_mask);
        get_online_cpus();
        /* No point in shuffling if there is only one online CPU (ex: UP) */
@@ -902,29 +902,29 @@ static void rcu_torture_shuffle_tasks(void)
        }
        if (rcu_idle_cpu != -1)
-                cpu_clear(rcu_idle_cpu, tmp_mask);
+                cpumask_clear_cpu(rcu_idle_cpu, shuffle_tmp_mask);
-        set_cpus_allowed_ptr(current, &tmp_mask);
+        set_cpus_allowed_ptr(current, shuffle_tmp_mask);
        if (reader_tasks) {
                for (i = 0; i < nrealreaders; i++)
                        if (reader_tasks[i])
                                set_cpus_allowed_ptr(reader_tasks[i],
-                                                     &tmp_mask);
+                                                     shuffle_tmp_mask);
        }
        if (fakewriter_tasks) {
                for (i = 0; i < nfakewriters; i++)
                        if (fakewriter_tasks[i])
                                set_cpus_allowed_ptr(fakewriter_tasks[i],
-                                                     &tmp_mask);
+                                                     shuffle_tmp_mask);
        }
        if (writer_task)
-                set_cpus_allowed_ptr(writer_task, &tmp_mask);
+                set_cpus_allowed_ptr(writer_task, shuffle_tmp_mask);
        if (stats_task)
-                set_cpus_allowed_ptr(stats_task, &tmp_mask);
+                set_cpus_allowed_ptr(stats_task, shuffle_tmp_mask);
        if (rcu_idle_cpu == -1)
                rcu_idle_cpu = num_online_cpus() - 1;
@@ -1012,6 +1012,7 @@ rcu_torture_cleanup(void)
        if (shuffler_task) {
                VERBOSE_PRINTK_STRING("Stopping rcu_torture_shuffle task");
                kthread_stop(shuffler_task);
+                free_cpumask_var(shuffle_tmp_mask);
        }
        shuffler_task = NULL;
@@ -1190,10 +1191,18 @@ rcu_torture_init(void)
        }
        if (test_no_idle_hz) {
                rcu_idle_cpu = num_online_cpus() - 1;
+                if (!alloc_cpumask_var(&shuffle_tmp_mask, GFP_KERNEL)) {
+                        firsterr = -ENOMEM;
+                        VERBOSE_PRINTK_ERRSTRING("Failed to alloc mask");
+                        goto unwind;
+                }
                /* Create the shuffler thread */
                shuffler_task = kthread_run(rcu_torture_shuffle, NULL,
                                          "rcu_torture_shuffle");
                if (IS_ERR(shuffler_task)) {
+                        free_cpumask_var(shuffle_tmp_mask);
                        firsterr = PTR_ERR(shuffler_task);
                        VERBOSE_PRINTK_ERRSTRING("Failed to create shuffler");
                        shuffler_task = NULL;
diff --git a/kernel/relay.c b/kernel/relay.c
index 9d79b7854fa6..8f2179c8056f 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -750,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 8e2558c2ba67..196d48babbef 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -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) {
+        if (sleep) {
-                update_avg(&p->se.avg_overlap,
+                if (p->se.last_wakeup) {
-                           p->se.sum_exec_runtime - p->se.last_wakeup);
+                        update_avg(&p->se.avg_overlap,
-                p->se.last_wakeup = 0;
+                                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) ||
+        tsk_cache_hot = task_hot(p, rq->clock, sd);
-                        sd->nr_balance_failed > sd->cache_nice_tries) {
+        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,480 @@ static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
        return 0;
 }
+/********** Helpers for find_busiest_group ************************/
 /*
- * find_busiest_group finds and returns the busiest CPU group within the
+ * sd_lb_stats - Structure to store the statistics of a sched_domain
- * domain. It calculates and returns the amount of weighted load which
+ *              during load balancing.
- * should be moved to restore balance via the imbalance parameter.
 */
-static struct sched_group *
+struct sd_lb_stats {
-find_busiest_group(struct sched_domain *sd, int this_cpu,
+        struct sched_group *busiest; /* Busiest group in this sd */
-                   unsigned long *imbalance, enum cpu_idle_type idle,
+        struct sched_group *this;  /* Local group in this sd */
-                   int *sd_idle, const struct cpumask *cpus, int *balance)
+        unsigned long total_load;  /* Total load of all groups in sd */
-{
+        unsigned long total_pwr;   /*   Total power of all groups in sd */
-        struct sched_group *busiest = NULL, *this = NULL, *group = sd->groups;
+        unsigned long avg_load;    /* Average load across all groups in sd */
-        unsigned long max_load, avg_load, total_load, this_load, total_pwr;
-        unsigned long max_pull;
+        /** Statistics of this group */
-        unsigned long busiest_load_per_task, busiest_nr_running;
+        unsigned long this_load;
-        unsigned long this_load_per_task, this_nr_running;
+        unsigned long this_load_per_task;
-        int load_idx, group_imb = 0;
+        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 = 1;
+        int power_savings_balance; /* Is powersave balance needed for this sd */
-        unsigned long leader_nr_running = 0, min_load_per_task = 0;
+        struct sched_group *group_min; /* Least loaded group in sd */
-        unsigned long min_nr_running = ULONG_MAX;
+        struct sched_group *group_leader; /* Group which relieves group_min */
-        struct sched_group *group_min = NULL, *group_leader = NULL;
+        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
+};
+/*
+ * 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 ? */
+};
-        max_load = this_load = total_load = total_pwr = 0;
+/**
-        busiest_load_per_task = busiest_nr_running = 0;
+ * group_first_cpu - Returns the first cpu in the cpumask of a sched_group.
-        this_load_per_task = this_nr_running = 0;
+ * @group: The group whose first cpu is to be returned.
+ */
+static inline unsigned int group_first_cpu(struct sched_group *group)
+{
+        return cpumask_first(sched_group_cpus(group));
+}
-        if (idle == CPU_NOT_IDLE)
+/**
+ * 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;
+        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 {
+        return load_idx;
-                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;
-                local_group = cpumask_test_cpu(this_cpu,
-                                               sched_group_cpus(group));
-                if (local_group)
+#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
-                        balance_cpu = cpumask_first(sched_group_cpus(group));
+/**
+ * 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;
+ * update_sd_power_savings_stats - Update the power saving stats for a
-                sum_avg_load_per_task = avg_load_per_task = 0;
+ * 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;
+        if (!sds->power_savings_balance)
-                min_cpu_load = ~0UL;
+                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 (*sd_idle && rq->nr_running)
+        /*
-                                *sd_idle = 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;
-                        /* Bias balancing toward cpus of our domain */
+        /*
-                        if (local_group) {
+         * Calculate the group which has the least non-idle load.
-                                if (idle_cpu(i) && !first_idle_cpu) {
+         * This is the group from where we need to pick up the load
-                                        first_idle_cpu = 1;
+         * for saving power
-                                        balance_cpu = i;
+         */
-                                }
+        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;
+        }
-                                load = target_load(i, load_idx);
+        /*
-                        } else {
+         * Calculate the group which is almost near its
-                                load = source_load(i, load_idx);
+         * capacity but still has some space to pick up some load
-                                if (load > max_cpu_load)
+         * from other group and save more power
-                                        max_cpu_load = load;
+         */
-                                if (min_cpu_load > load)
+        if (sgs->sum_nr_running > sgs->group_capacity - 1)
-                                        min_cpu_load = load;
+                return;
-                        }
-                        avg_load += load;
+        if (sgs->sum_nr_running > sds->leader_nr_running ||
-                        sum_nr_running += rq->nr_running;
+            (sgs->sum_nr_running == sds->leader_nr_running &&
-                        sum_weighted_load += weighted_cpuload(i);
+             group_first_cpu(group) < group_first_cpu(sds->group_leader))) {
+                sds->group_leader = group;
+                sds->leader_nr_running = sgs->sum_nr_running;
+        }
+}
-                        sum_avg_load_per_task += cpu_avg_load_per_task(i);
+/**
-                }
+ * check_power_save_busiest_group - see if there is potential for some power-savings balance
+ * @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.
+ *
+ * Description:
+ * 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.
+ *
+ * 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;
-                /*
+        if (sds->this != sds->group_leader ||
-                 * First idle cpu or the first cpu(busiest) in this sched group
+                        sds->group_leader == sds->group_min)
-                 * is eligible for doing load balancing at this and above
+                return 0;
-                 * 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;
-                }
-                total_load += avg_load;
+        *imbalance = sds->min_load_per_task;
-                total_pwr += group->__cpu_power;
+        sds->busiest = sds->group_min;
-                /* Adjust by relative CPU power of the group */
+        if (sched_mc_power_savings >= POWERSAVINGS_BALANCE_WAKEUP) {
-                avg_load = sg_div_cpu_power(group,
+                cpu_rq(this_cpu)->rd->sched_mc_preferred_wakeup_cpu =
-                                avg_load * SCHED_LOAD_SCALE);
+                        group_first_cpu(sds->group_leader);
+        }
+        return 1;
-                /*
+}
-                 * Consider the group unbalanced when the imbalance is larger
+#else /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
-                 * than the average weight of two tasks.
+static inline void init_sd_power_savings_stats(struct sched_domain *sd,
-                 *
+        struct sd_lb_stats *sds, enum cpu_idle_type idle)
-                 * APZ: with cgroup the avg task weight can vary wildly and
+{
-                 *      might not be a suitable number - should we keep a
+        return;
-                 *      normalized nr_running number somewhere that negates
+}
-                 *      the hierarchy?
-                 */
+static inline void update_sd_power_savings_stats(struct sched_group *group,
-                avg_load_per_task = sg_div_cpu_power(group,
+        struct sd_lb_stats *sds, int local_group, struct sg_lb_stats *sgs)
-                                sum_avg_load_per_task * SCHED_LOAD_SCALE);
+{
+        return;
+}
-                if ((max_cpu_load - min_cpu_load) > 2*avg_load_per_task)
+static inline int check_power_save_busiest_group(struct sd_lb_stats *sds,
-                        __group_imb = 1;
+                                        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;
+                        if (idle_cpu(i) && !first_idle_cpu) {
-                        this = group;
+                                first_idle_cpu = 1;
-                        this_nr_running = sum_nr_running;
+                                balance_cpu = i;
-                        this_load_per_task = sum_weighted_load;
+                        }
-                } else if (avg_load > max_load &&
-                           (sum_nr_running > group_capacity || __group_imb)) {
+                        load = target_load(i, load_idx);
-                        max_load = avg_load;
+                } else {
-                        busiest = group;
+                        load = source_load(i, load_idx);
-                        busiest_nr_running = sum_nr_running;
+                        if (load > max_cpu_load)
-                        busiest_load_per_task = sum_weighted_load;
+                                max_cpu_load = load;
-                        group_imb = __group_imb;
+                        if (min_cpu_load > load)
+                                min_cpu_load = load;
                }
-#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
+                sgs->group_load += load;
-                /*
+                sgs->sum_nr_running += rq->nr_running;
-                 * Busy processors will not participate in power savings
+                sgs->sum_weighted_load += weighted_cpuload(i);
-                 * balance.
-                 */
-                if (idle == CPU_NOT_IDLE ||
-                                !(sd->flags & SD_POWERSAVINGS_BALANCE))
-                        goto group_next;
-                /*
+                sum_avg_load_per_task += cpu_avg_load_per_task(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;
-                /*
+        /*
-                 * If a group is already running at full capacity or idle,
+         * First idle cpu or the first cpu(busiest) in this sched group
-                 * don't include that group in power savings calculations
+         * is eligible for doing load balancing at this and above
-                 */
+         * domains. In the newly idle case, we will allow all the cpu's
-                if (!power_savings_balance || sum_nr_running >= group_capacity
+         * to do the newly idle load balance.
-                    || !sum_nr_running)
+         */
-                        goto group_next;
+        if (idle != CPU_NEWLY_IDLE && local_group &&
+            balance_cpu != this_cpu && balance) {
+                *balance = 0;
+                return;
+        }
-                /*
+        /* Adjust by relative CPU power of the group */
-                 * Calculate the group which has the least non-idle load.
+        sgs->avg_load = sg_div_cpu_power(group,
-                 * This is the group from where we need to pick up the load
+                        sgs->group_load * SCHED_LOAD_SCALE);
-                 * 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;
-                }
-                /*
-                 * Calculate the group which is almost near its
+        /*
-                 * capacity but still has some space to pick up some load
+         * Consider the group unbalanced when the imbalance is larger
-                 * from other group and save more power
+         * than the average weight of two tasks.
-                 */
+         *
-                if (sum_nr_running <= group_capacity - 1) {
+         * APZ: with cgroup the avg task weight can vary wildly and
-                        if (sum_nr_running > leader_nr_running ||
+         *      might not be a suitable number - should we keep a
-                            (sum_nr_running == leader_nr_running &&
+         *      normalized nr_running number somewhere that negates
-                             cpumask_first(sched_group_cpus(group)) <
+         *      the hierarchy?
-                             cpumask_first(sched_group_cpus(group_leader)))) {
+         */
-                                group_leader = group;
+        avg_load_per_task = sg_div_cpu_power(group,
-                                leader_nr_running = sum_nr_running;
+                        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)
+ * fix_small_imbalance - Calculate the minor imbalance that exists
-                goto out_balanced;
+ *                      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 (sds->max_load - sds->this_load + sds->busiest_load_per_task >=
-        if (group_imb)
+                        sds->busiest_load_per_task * imbn) {
-                busiest_load_per_task = min(busiest_load_per_task, avg_load);
+                *imbalance = sds->busiest_load_per_task;
+                return;
+        }
        /*
-         * We're trying to get all the cpus to the average_load, so we don't
+         * OK, we don't have enough imbalance to justify moving tasks,
-         * want to push ourselves above the average load, nor do we wish to
+         * however we may be able to increase total CPU power used by
-         * reduce the max loaded cpu below the average load, as either of these
+         * moving them.
-         * 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 (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,
+        *imbalance = min(max_pull * sds->busiest->__cpu_power,
-                                (avg_load - this_load) * this->__cpu_power)
+                (sds->avg_load - sds->this_load) * sds->this->__cpu_power)
                        / SCHED_LOAD_SCALE;
        /*
@@ -3333,78 +3671,110 @@ group_next:
         * a think about bumping its value to force at least one task to be
         * moved
         */
-        if (*imbalance < busiest_load_per_task) {
+        if (*imbalance < sds->busiest_load_per_task)
-                unsigned long tmp, pwr_now, pwr_move;
+                return fix_small_imbalance(sds, this_cpu, imbalance);
-                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 (max_load - this_load + busiest_load_per_task >=
+}
-                                        busiest_load_per_task * imbn) {
+/******* find_busiest_group() helpers end here *********************/
-                        *imbalance = busiest_load_per_task;
-                        return busiest;
-                }
-                /*
+/**
-                 * OK, we don't have enough imbalance to justify moving tasks,
+ * find_busiest_group - Returns the busiest group within the sched_domain
-                 * however we may be able to increase total CPU power used by
+ * if there is an imbalance. If there isn't an imbalance, and
-                 * moving them.
+ * 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 *
+        memset(&sds, 0, sizeof(sds));
-                                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;
-                /* Move if we gain throughput */
+        /*
-                if (pwr_move > pwr_now)
+         * Compute the various statistics relavent for load balancing at
-                        *imbalance = busiest_load_per_task;
+         * 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 (sds.this_load >= sds.max_load)
-#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
+                goto out_balanced;
-        if (idle == CPU_NOT_IDLE || !(sd->flags & SD_POWERSAVINGS_BALANCE))
-                goto ret;
-        if (this == group_leader && group_leader != group_min) {
+        sds.avg_load = (SCHED_LOAD_SCALE * sds.total_load) / sds.total_pwr;
-                *imbalance = min_load_per_task;
-                if (sched_mc_power_savings >= POWERSAVINGS_BALANCE_WAKEUP) {
+        if (sds.this_load >= sds.avg_load)
-                        cpu_rq(this_cpu)->rd->sched_mc_preferred_wakeup_cpu =
+                goto out_balanced;
-                                cpumask_first(sched_group_cpus(group_leader));
-                }
+        if (100 * sds.max_load <= sd->imbalance_pct * sds.this_load)
-                return group_min;
+                goto out_balanced;
-        }
-#endif
+        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;
@@ -4057,6 +4427,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.
 *
@@ -4114,7 +4489,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);
 }
@@ -4508,11 +4885,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;
@@ -4543,15 +4942,13 @@ pick_next_task(struct rq *rq, struct task_struct *prev)
 /*
 * schedule() is the main scheduler function.
 */
-asmlinkage void __sched schedule(void)
+asmlinkage void __sched __schedule(void)
 {
        struct task_struct *prev, *next;
        unsigned long *switch_count;
        struct rq *rq;
        int cpu;
-need_resched:
-        preempt_disable();
        cpu = smp_processor_id();
        rq = cpu_rq(cpu);
        rcu_qsctr_inc(cpu);
@@ -4586,8 +4983,8 @@ need_resched_nonpreemptible:
        if (unlikely(!rq->nr_running))
                idle_balance(cpu, rq);
-        prev->sched_class->put_prev_task(rq, prev);
+        put_prev_task(rq, prev);
-        next = pick_next_task(rq, prev);
+        next = pick_next_task(rq);
        if (likely(prev != next)) {
                sched_info_switch(prev, next);
@@ -4608,13 +5005,80 @@ need_resched_nonpreemptible:
        if (unlikely(reacquire_kernel_lock(current) < 0))
                goto need_resched_nonpreemptible;
+}
+asmlinkage void __sched schedule(void)
+{
+need_resched:
+        preempt_disable();
+        __schedule();
        preempt_enable_no_resched();
        if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))
                goto need_resched;
 }
 EXPORT_SYMBOL(schedule);
+#ifdef CONFIG_SMP
+/*
+ * Look out! "owner" is an entirely speculative pointer
+ * access and not reliable.
+ */
+int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner)
+{
+        unsigned int cpu;
+        struct rq *rq;
+        if (!sched_feat(OWNER_SPIN))
+                return 0;
+#ifdef CONFIG_DEBUG_PAGEALLOC
+        /*
+         * Need to access the cpu field knowing that
+         * DEBUG_PAGEALLOC could have unmapped it if
+         * the mutex owner just released it and exited.
+         */
+        if (probe_kernel_address(&owner->cpu, cpu))
+                goto out;
+#else
+        cpu = owner->cpu;
+#endif
+        /*
+         * Even if the access succeeded (likely case),
+         * the cpu field may no longer be valid.
+         */
+        if (cpu >= nr_cpumask_bits)
+                goto out;
+        /*
+         * We need to validate that we can do a
+         * get_cpu() and that we have the percpu area.
+         */
+        if (!cpu_online(cpu))
+                goto out;
+        rq = cpu_rq(cpu);
+        for (;;) {
+                /*
+                 * Owner changed, break to re-assess state.
+                 */
+                if (lock->owner != owner)
+                        break;
+                /*
+                 * Is that owner really running on that cpu?
+                 */
+                if (task_thread_info(rq->curr) != owner || need_resched())
+                        return 0;
+                cpu_relax();
+        }
+out:
+        return 1;
+}
+#endif
 #ifdef CONFIG_PREEMPT
 /*
 * this is the entry point to schedule() from in-kernel preemption
@@ -4642,7 +5106,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);
@@ -4671,7 +5135,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 */
@@ -5145,7 +5609,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)
@@ -5944,12 +6408,7 @@ void sched_show_task(struct task_struct *p)
                printk(KERN_CONT " %016lx ", thread_saved_pc(p));
 #endif
 #ifdef CONFIG_DEBUG_STACK_USAGE
-        {
+        free = stack_not_used(p);
-                unsigned long *n = end_of_stack(p);
-                while (!*n)
-                        n++;
-                free = (unsigned long)n - (unsigned long)end_of_stack(p);
-        }
 #endif
        printk(KERN_CONT "%5lu %5d %6d\n", free,
                task_pid_nr(p), task_pid_nr(p->real_parent));
@@ -6423,7 +6882,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);
@@ -8218,11 +8677,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;
@@ -9490,7 +9953,7 @@ cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
 static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
 {
-        u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
+        u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
        u64 data;
 #ifndef CONFIG_64BIT
@@ -9509,7 +9972,7 @@ static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
 static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val)
 {
-        u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
+        u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
 #ifndef CONFIG_64BIT
        /*
@@ -9598,14 +10061,14 @@ 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);
        ca = task_ca(tsk);
        for (; ca; ca = ca->parent) {
-                u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
+                u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
                *cpuusage += cputime;
        }
 }
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),
+         *                    max(scd->tick_gtod, scd->clock),
-         *                    scd->tick_gtod + TICK_NSEC);
+         *                    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))
+        if (sched_clock_stable)
-                return 0ull;
+                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_cpupri.h b/kernel/sched_cpupri.h
index 642a94ef8a0a..9a7e859b8fbf 100644
--- a/kernel/sched_cpupri.h
+++ b/kernel/sched_cpupri.h
@@ -25,7 +25,7 @@ struct cpupri {
 #ifdef CONFIG_SMP
 int  cpupri_find(struct cpupri *cp,
-                 struct task_struct *p, cpumask_t *lowest_mask);
+                 struct task_struct *p, struct cpumask *lowest_mask);
 void cpupri_set(struct cpupri *cp, int cpu, int pri);
 int cpupri_init(struct cpupri *cp, bool bootmem);
 void cpupri_cleanup(struct cpupri *cp);
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 0566f2a03c42..3816f217f119 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -1314,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
+         * Since its curr running now, convert the gran from real-time
-         * + nice tasks.
+         * to virtual-time in his units.
         */
-        if (!sched_feat(ASYM_GRAN) || se->load.weight > NICE_0_LOAD)
+        if (sched_feat(ASYM_GRAN)) {
-                gran = calc_delta_fair(sysctl_sched_wakeup_granularity, se);
+                /*
+                 * 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;
 }
@@ -1350,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;
diff --git a/kernel/sched_features.h b/kernel/sched_features.h
index da5d93b5d2c6..4569bfa7df9b 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)
@@ -13,3 +14,4 @@ SCHED_FEAT(LB_WAKEUP_UPDATE, 1)
 SCHED_FEAT(ASYM_EFF_LOAD, 1)
 SCHED_FEAT(WAKEUP_OVERLAP, 0)
 SCHED_FEAT(LAST_BUDDY, 1)
+SCHED_FEAT(OWNER_SPIN, 1)
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index bac1061cea2f..299d012b4394 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 (rt_rq->rt_nr_migratory && (rt_rq->rt_nr_running > 1)) {
-                if (!rq->rt.overloaded) {
+                if (!rt_rq->overloaded) {
-                        rt_set_overload(rq);
+                        rt_set_overload(rq_of_rt_rq(rt_rq));
-                        rq->rt.overloaded = 1;
+                        rt_rq->overloaded = 1;
                }
-        } else if (rq->rt.overloaded) {
+        } else if (rt_rq->overloaded) {
-                rt_clear_overload(rq);
+                rt_clear_overload(rq_of_rt_rq(rt_rq));
-                rq->rt.overloaded = 0;
+                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
+#if defined CONFIG_SMP
-void inc_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
+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)));
+        struct task_struct *next = pick_next_highest_task_rt(rq, rq->cpu);
-        rt_rq->rt_nr_running++;
-#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
+        if (next && rt_prio(next->prio))
-        if (rt_se_prio(rt_se) < rt_rq->highest_prio) {
+                return next->prio;
-#ifdef CONFIG_SMP
+        else
-                struct rq *rq = rq_of_rt_rq(rt_rq);
+                return MAX_RT_PRIO;
-#endif
+}
+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,
+                        cpupri_set(&rq->rd->cpupri, rq->cpu, prio);
-                                   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);
-                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));
+static void
-#endif
+dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
-#ifdef CONFIG_RT_GROUP_SCHED
+{
-        if (rt_se_boosted(rt_se))
+        struct rq *rq = rq_of_rt_rq(rt_rq);
-                rt_rq->rt_nr_boosted++;
-        if (rt_rq->tg)
+        if (rt_rq->rt_nr_running && (prio <= rt_rq->highest_prio.next))
-                start_rt_bandwidth(&rt_rq->tg->rt_bandwidth);
+                rt_rq->highest_prio.next = next_prio(rq);
-#else
-        start_rt_bandwidth(&def_rt_bandwidth);
+        if (rq->online && rt_rq->highest_prio.curr != prev_prio)
-#endif
+                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)
+void inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio) {}
-{
+static inline
-#ifdef CONFIG_SMP
+void dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio) {}
-        int highest_prio = rt_rq->highest_prio;
-#endif
+#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);
+                WARN_ON(prio < prev_prio);
-                if (rt_se_prio(rt_se) == rt_rq->highest_prio) {
-                        /* recalculate */
+                /*
-                        array = &rt_rq->active;
+                 * This may have been our highest task, and therefore
-                        rt_rq->highest_prio =
+                 * 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;
+                rt_rq->highest_prio.curr = 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--;
-        }
-        if (rt_rq->highest_prio != highest_prio) {
+        dec_rt_prio_smp(rt_rq, prio, prev_prio);
-                struct rq *rq = rq_of_rt_rq(rt_rq);
+}
-                if (rq->online)
+#else
-                        cpupri_set(&rq->rd->cpupri, rq->cpu,
-                                   rt_rq->highest_prio);
+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
@@ -960,12 +1122,13 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
 static DEFINE_PER_CPU(cpumask_var_t, local_cpu_mask);
-static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
+static inline int pick_optimal_cpu(int this_cpu,
+                                   const struct cpumask *mask)
 {
        int first;
        /* "this_cpu" is cheaper to preempt than a remote processor */
-        if ((this_cpu != -1) && cpu_isset(this_cpu, *mask))
+        if ((this_cpu != -1) && cpumask_test_cpu(this_cpu, mask))
                return this_cpu;
        first = cpumask_first(mask);
@@ -981,6 +1144,7 @@ static int find_lowest_rq(struct task_struct *task)
        struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
        int this_cpu = smp_processor_id();
        int cpu      = task_cpu(task);
+        cpumask_var_t domain_mask;
        if (task->rt.nr_cpus_allowed == 1)
                return -1; /* No other targets possible */
@@ -1013,19 +1177,25 @@ static int find_lowest_rq(struct task_struct *task)
        if (this_cpu == cpu)
                this_cpu = -1; /* Skip this_cpu opt if the same */
-        for_each_domain(cpu, sd) {
+        if (alloc_cpumask_var(&domain_mask, GFP_ATOMIC)) {
-                if (sd->flags & SD_WAKE_AFFINE) {
+                for_each_domain(cpu, sd) {
-                        cpumask_t domain_mask;
+                        if (sd->flags & SD_WAKE_AFFINE) {
-                        int       best_cpu;
+                                int best_cpu;
+                                cpumask_and(domain_mask,
+                                            sched_domain_span(sd),
+                                            lowest_mask);
-                        cpumask_and(&domain_mask, sched_domain_span(sd),
+                                best_cpu = pick_optimal_cpu(this_cpu,
-                                    lowest_mask);
+                                                            domain_mask);
-                        best_cpu = pick_optimal_cpu(this_cpu,
+                                if (best_cpu != -1) {
-                                                    &domain_mask);
+                                        free_cpumask_var(domain_mask);
-                        if (best_cpu != -1)
+                                        return best_cpu;
-                                return best_cpu;
+                                }
+                        }
                }
+                free_cpumask_var(domain_mask);
        }
        /*
@@ -1072,7 +1242,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 +1253,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 +1287,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 +1320,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.
+                 * so it is possible that next_task has migrated.
-                 * If it has, then try again.
+                 *
+                 * 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);
+                task = pick_next_pushable_task(rq);
-                if (unlikely(task != next_task) && task && paranoid--) {
+                if (task_cpu(next_task) == rq->cpu && task == next_task) {
-                        put_task_struct(next_task);
+                        /*
-                        next_task = task;
+                         * If we get here, the task hasnt moved at all, but
-                        goto retry;
+                         * 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 +1358,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 +1374,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
+                 * alter this_rq
-                 * the caller to recalculate the next task
-                 * in that case:
                 */
-                if (double_lock_balance(this_rq, src_rq)) {
+                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;
-                }
                /*
                 * Are there still pullable RT tasks?
@@ -1214,7 +1416,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 +1426,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
+                         * current task on the run queue
-                         * this_rq next task is lower in prio than
-                         * the current task on that rq.
                         */
-                        if (p->prio < src_rq->curr->prio ||
+                        if (p->prio < src_rq->curr->prio)
-                            (next && next->prio < src_rq->curr->prio))
                                goto skip;
                        ret = 1;
@@ -1242,13 +1441,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 +1453,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
+         * This is only called if needs_post_schedule_rt() indicates that
-         * see if we can push the other rt_tasks off to other CPUS.
+         * we need to push tasks away
-         * 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.
         */
-        if (unlikely(rq->rt.overloaded)) {
+        spin_lock_irq(&rq->lock);
-                spin_lock_irq(&rq->lock);
+        push_rt_tasks(rq);
-                push_rt_tasks(rq);
+        spin_unlock_irq(&rq->lock);
-                spin_unlock_irq(&rq->lock);
-        }
 }
 /*
@@ -1288,7 +1484,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 +1521,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 +1546,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 +1561,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 +1653,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 +1724,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 +1749,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 a8f93dd374e1..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%d %u %u %u %u %u %u %llu %llu %lu",
-                    cpu, rq->yld_both_empty,
+                    cpu, rq->yld_count,
-                    rq->yld_act_empty, rq->yld_exp_empty, rq->yld_count,
                    rq->sched_switch, rq->sched_count, rq->sched_goidle,
                    rq->ttwu_count, rq->ttwu_local,
                    rq->rq_cpu_time,
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 9041ea7948fe..57d3f67f6f38 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -796,6 +796,11 @@ int __init __weak early_irq_init(void)
        return 0;
 }
+int __init __weak arch_probe_nr_irqs(void)
+{
+        return 0;
+}
 int __init __weak arch_early_irq_init(void)
 {
        return 0;
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index 0cd415ee62a2..912823e2a11b 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -44,7 +44,7 @@ static DEFINE_MUTEX(setup_lock);
 static int refcount;
 static struct workqueue_struct *stop_machine_wq;
 static struct stop_machine_data active, idle;
-static const cpumask_t *active_cpus;
+static const struct cpumask *active_cpus;
 static void *stop_machine_work;
 static void set_state(enum stopmachine_state newstate)
@@ -170,7 +170,7 @@ int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus)
         * doesn't hit this CPU until we're ready. */
        get_cpu();
        for_each_online_cpu(i) {
-                sm_work = percpu_ptr(stop_machine_work, i);
+                sm_work = per_cpu_ptr(stop_machine_work, i);
                INIT_WORK(sm_work, stop_cpu);
                queue_work_on(i, stop_machine_wq, sm_work);
        }
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 */
+/* ACTHZ period (nsecs): */
-#define MAX_TICKADJ_SCALED      (((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \
+unsigned long                   tick_nsec;
-                                  NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
+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)
+        u64 second_length;
-                                << NTP_SCALE_SHIFT;
+        u64 new_base;
-        second_length += (s64)ntp_tick_adj << NTP_SCALE_SHIFT;
-        second_length += time_freq;
+        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)
+        secs = xtime.tv_sec - time_reftime;
-                time_reftime = xtime.tv_sec;
+        if (unlikely(time_status & STA_FREQHOLD))
-        mtemp = xtime.tv_sec - time_reftime;
+                secs = 0;
        time_reftime = xtime.tv_sec;
-        freq_adj = (s64)offset * mtemp;
+        offset64    = offset;
-        freq_adj <<= NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant);
+        freq_adj    = (offset64 * secs) <<
-        time_status &= ~STA_MODE;
+                        (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
-        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);
-        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_adjust     = 0;            /* stop active adjtime() */
-        time_status |= STA_UNSYNC;
+        time_status     |= STA_UNSYNC;
-        time_maxerror = NTP_PHASE_LIMIT;
+        time_maxerror   = NTP_PHASE_LIMIT;
-        time_esterror = NTP_PHASE_LIMIT;
+        time_esterror   = NTP_PHASE_LIMIT;
        ntp_update_frequency();
-        tick_length = tick_length_base;
+        tick_length     = tick_length_base;
-        time_offset = 0;
+        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: "
+                printk(KERN_NOTICE
-                       "inserting leap second 23:59:60 UTC\n");
+                        "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: "
+                printk(KERN_NOTICE
-                       "deleting leap second 23:59:59 UTC\n");
+                        "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;
+        tick_length      = tick_length_base;
-        time_adj = shift_right(time_offset, SHIFT_PLL + time_constant);
-        time_offset -= time_adj;
+        delta            = shift_right(time_offset, SHIFT_PLL + time_constant);
-        tick_length += time_adj;
+        time_offset     -= delta;
+        tick_length     += delta;
-        if (unlikely(time_adjust)) {
-                if (time_adjust > MAX_TICKADJ) {
+        if (!time_adjust)
-                        time_adjust -= MAX_TICKADJ;
+                return;
-                        tick_length += MAX_TICKADJ_SCALED;
-                } else if (time_adjust < -MAX_TICKADJ) {
+        if (time_adjust > MAX_TICKADJ) {
-                        time_adjust += MAX_TICKADJ;
+                time_adjust -= MAX_TICKADJ;
-                        tick_length -= MAX_TICKADJ_SCALED;
+                tick_length += MAX_TICKADJ_SCALED;
-                } else {
+                return;
-                        tick_length += (s64)(time_adjust * NSEC_PER_USEC /
-                                        NTP_INTERVAL_FREQ) << NTP_SCALE_SHIFT;
-                        time_adjust = 0;
-                }
        }
+        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;
+        } else {
-        }
-        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;
-                if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
+                /* If there are input parameters, then process them: */
-                        ntp_update_frequency();
+                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))
+                if (!(time_status & STA_NANO))
-                txc->offset /= NSEC_PER_USEC;
+                        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/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..b4555568b4e4 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -491,14 +491,18 @@ static inline void debug_timer_free(struct timer_list *timer)
        debug_object_free(timer, &timer_debug_descr);
 }
-static void __init_timer(struct timer_list *timer);
+static void __init_timer(struct timer_list *timer,
+                         const char *name,
+                         struct lock_class_key *key);
-void init_timer_on_stack(struct timer_list *timer)
+void init_timer_on_stack_key(struct timer_list *timer,
+                             const char *name,
+                             struct lock_class_key *key)
 {
        debug_object_init_on_stack(timer, &timer_debug_descr);
-        __init_timer(timer);
+        __init_timer(timer, name, key);
 }
-EXPORT_SYMBOL_GPL(init_timer_on_stack);
+EXPORT_SYMBOL_GPL(init_timer_on_stack_key);
 void destroy_timer_on_stack(struct timer_list *timer)
 {
@@ -512,7 +516,9 @@ static inline void debug_timer_activate(struct timer_list *timer) { }
 static inline void debug_timer_deactivate(struct timer_list *timer) { }
 #endif
-static void __init_timer(struct timer_list *timer)
+static void __init_timer(struct timer_list *timer,
+                         const char *name,
+                         struct lock_class_key *key)
 {
        timer->entry.next = NULL;
        timer->base = __raw_get_cpu_var(tvec_bases);
@@ -521,6 +527,7 @@ static void __init_timer(struct timer_list *timer)
        timer->start_pid = -1;
        memset(timer->start_comm, 0, TASK_COMM_LEN);
 #endif
+        lockdep_init_map(&timer->lockdep_map, name, key, 0);
 }
 /**
@@ -530,19 +537,23 @@ static void __init_timer(struct timer_list *timer)
 * init_timer() must be done to a timer prior calling *any* of the
 * other timer functions.
 */
-void init_timer(struct timer_list *timer)
+void init_timer_key(struct timer_list *timer,
+                    const char *name,
+                    struct lock_class_key *key)
 {
        debug_timer_init(timer);
-        __init_timer(timer);
+        __init_timer(timer, name, key);
 }
-EXPORT_SYMBOL(init_timer);
+EXPORT_SYMBOL(init_timer_key);
-void init_timer_deferrable(struct timer_list *timer)
+void init_timer_deferrable_key(struct timer_list *timer,
+                               const char *name,
+                               struct lock_class_key *key)
 {
-        init_timer(timer);
+        init_timer_key(timer, name, key);
        timer_set_deferrable(timer);
 }
-EXPORT_SYMBOL(init_timer_deferrable);
+EXPORT_SYMBOL(init_timer_deferrable_key);
 static inline void detach_timer(struct timer_list *timer,
                                int clear_pending)
@@ -589,11 +600,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 +617,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 +646,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
+ * mod_timer_pending - modify a pending timer's timeout
- * @timer: the timer to be added
+ * @timer: the pending timer to be modified
- * @cpu: the CPU to start it on
+ * @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);
+        return __mod_timer(timer, expires, true);
-        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);
 }
+EXPORT_SYMBOL(mod_timer_pending);
 /**
 * mod_timer - modify a timer's timeout
@@ -688,9 +691,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 +699,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 +783,6 @@ int del_timer(struct timer_list *timer)
        return ret;
 }
 EXPORT_SYMBOL(del_timer);
 #ifdef CONFIG_SMP
@@ -767,7 +816,6 @@ out:
        return ret;
 }
 EXPORT_SYMBOL(try_to_del_timer_sync);
 /**
@@ -789,6 +837,15 @@ EXPORT_SYMBOL(try_to_del_timer_sync);
 */
 int del_timer_sync(struct timer_list *timer)
 {
+#ifdef CONFIG_LOCKDEP
+        unsigned long flags;
+        local_irq_save(flags);
+        lock_map_acquire(&timer->lockdep_map);
+        lock_map_release(&timer->lockdep_map);
+        local_irq_restore(flags);
+#endif
        for (;;) {
                int ret = try_to_del_timer_sync(timer);
                if (ret >= 0)
@@ -796,7 +853,6 @@ int del_timer_sync(struct timer_list *timer)
                cpu_relax();
        }
 }
 EXPORT_SYMBOL(del_timer_sync);
 #endif
@@ -861,10 +917,36 @@ static inline void __run_timers(struct tvec_base *base)
                        set_running_timer(base, timer);
                        detach_timer(timer, 1);
                        spin_unlock_irq(&base->lock);
                        {
                                int preempt_count = preempt_count();
+#ifdef CONFIG_LOCKDEP
+                                /*
+                                 * It is permissible to free the timer from
+                                 * inside the function that is called from
+                                 * it, this we need to take into account for
+                                 * lockdep too. To avoid bogus "held lock
+                                 * freed" warnings as well as problems when
+                                 * looking into timer->lockdep_map, make a
+                                 * copy and use that here.
+                                 */
+                                struct lockdep_map lockdep_map =
+                                        timer->lockdep_map;
+#endif
+                                /*
+                                 * Couple the lock chain with the lock chain at
+                                 * del_timer_sync() by acquiring the lock_map
+                                 * around the fn() call here and in
+                                 * del_timer_sync().
+                                 */
+                                lock_map_acquire(&lockdep_map);
                                fn(data);
+                                lock_map_release(&lockdep_map);
                                if (preempt_count != preempt_count()) {
                                        printk(KERN_ERR "huh, entered %p "
                                               "with preempt_count %08x, exited"
@@ -1268,7 +1350,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/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 930c08e5b38e..dce71a5b51bc 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -42,6 +42,81 @@ static struct tracer_flags tracer_flags = {
 /* pid on the last trace processed */
 static pid_t last_pid[NR_CPUS] = { [0 ... NR_CPUS-1] = -1 };
+/* Add a function return address to the trace stack on thread info.*/
+int
+ftrace_push_return_trace(unsigned long ret, unsigned long long time,
+                         unsigned long func, int *depth)
+{
+        int index;
+        if (!current->ret_stack)
+                return -EBUSY;
+        /* The return trace stack is full */
+        if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
+                atomic_inc(&current->trace_overrun);
+                return -EBUSY;
+        }
+        index = ++current->curr_ret_stack;
+        barrier();
+        current->ret_stack[index].ret = ret;
+        current->ret_stack[index].func = func;
+        current->ret_stack[index].calltime = time;
+        *depth = index;
+        return 0;
+}
+/* Retrieve a function return address to the trace stack on thread info.*/
+void
+ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
+{
+        int index;
+        index = current->curr_ret_stack;
+        if (unlikely(index < 0)) {
+                ftrace_graph_stop();
+                WARN_ON(1);
+                /* Might as well panic, otherwise we have no where to go */
+                *ret = (unsigned long)panic;
+                return;
+        }
+        *ret = current->ret_stack[index].ret;
+        trace->func = current->ret_stack[index].func;
+        trace->calltime = current->ret_stack[index].calltime;
+        trace->overrun = atomic_read(&current->trace_overrun);
+        trace->depth = index;
+        barrier();
+        current->curr_ret_stack--;
+}
+/*
+ * Send the trace to the ring-buffer.
+ * @return the original return address.
+ */
+unsigned long ftrace_return_to_handler(void)
+{
+        struct ftrace_graph_ret trace;
+        unsigned long ret;
+        ftrace_pop_return_trace(&trace, &ret);
+        trace.rettime = cpu_clock(raw_smp_processor_id());
+        ftrace_graph_return(&trace);
+        if (unlikely(!ret)) {
+                ftrace_graph_stop();
+                WARN_ON(1);
+                /* Might as well panic. What else to do? */
+                ret = (unsigned long)panic;
+        }
+        return ret;
+}
 static int graph_trace_init(struct trace_array *tr)
 {
        int cpu, ret;
diff --git a/kernel/user.c b/kernel/user.c
index fbb300e6191f..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,
 };
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 1f0c509b40d3..9aedd9fd825b 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -416,7 +416,7 @@ void flush_workqueue(struct workqueue_struct *wq)
        might_sleep();
        lock_map_acquire(&wq->lockdep_map);
        lock_map_release(&wq->lockdep_map);
-        for_each_cpu_mask_nr(cpu, *cpu_map)
+        for_each_cpu(cpu, cpu_map)
                flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, cpu));
 }
 EXPORT_SYMBOL_GPL(flush_workqueue);
@@ -547,7 +547,7 @@ static void wait_on_work(struct work_struct *work)
        wq = cwq->wq;
        cpu_map = wq_cpu_map(wq);
-        for_each_cpu_mask_nr(cpu, *cpu_map)
+        for_each_cpu(cpu, cpu_map)
                wait_on_cpu_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
 }
@@ -911,7 +911,7 @@ void destroy_workqueue(struct workqueue_struct *wq)
        list_del(&wq->list);
        spin_unlock(&workqueue_lock);
-        for_each_cpu_mask_nr(cpu, *cpu_map)
+        for_each_cpu(cpu, cpu_map)
                cleanup_workqueue_thread(per_cpu_ptr(wq->cpu_wq, cpu));
        cpu_maps_update_done();