50 files changed, 1026 insertions, 594 deletions
diff --git a/kernel/Makefile b/kernel/Makefile
index 2aebc4cd7878..170a9213c1b6 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -40,9 +40,8 @@ obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
 obj-$(CONFIG_DEBUG_RT_MUTEXES) += rtmutex-debug.o
 obj-$(CONFIG_RT_MUTEX_TESTER) += rtmutex-tester.o
 obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
-ifeq ($(CONFIG_USE_GENERIC_SMP_HELPERS),y)
+obj-$(CONFIG_USE_GENERIC_SMP_HELPERS) += smp.o
-obj-y += smp.o
+ifneq ($(CONFIG_SMP),y)
-else
 obj-y += up.o
 endif
 obj-$(CONFIG_SMP) += spinlock.o
diff --git a/kernel/acct.c b/kernel/acct.c
index d57b7cbb98b6..7afa31564162 100644
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -277,7 +277,7 @@ static int acct_on(char *name)
 * should be written. If the filename is NULL, accounting will be
 * shutdown.
 */
-asmlinkage long sys_acct(const char __user *name)
+SYSCALL_DEFINE1(acct, const char __user *, name)
 {
        int error;
diff --git a/kernel/capability.c b/kernel/capability.c
index 688926e496be..4e17041963f5 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -161,7 +161,7 @@ static inline int cap_get_target_pid(pid_t pid, kernel_cap_t *pEp,
 *
 * Returns 0 on success and < 0 on error.
 */
-asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
+SYSCALL_DEFINE2(capget, cap_user_header_t, header, cap_user_data_t, dataptr)
 {
        int ret = 0;
        pid_t pid;
@@ -235,7 +235,7 @@ asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
 *
 * Returns 0 on success and < 0 on error.
 */
-asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
+SYSCALL_DEFINE2(capset, cap_user_header_t, header, const cap_user_data_t, data)
 {
        struct __user_cap_data_struct kdata[_KERNEL_CAPABILITY_U32S];
        unsigned i, tocopy;
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index c29831076e7a..5a54ff42874e 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1115,8 +1115,10 @@ static void cgroup_kill_sb(struct super_block *sb) {
        }
        write_unlock(&css_set_lock);
-        list_del(&root->root_list);
+        if (!list_empty(&root->root_list)) {
-        root_count--;
+                list_del(&root->root_list);
+                root_count--;
+        }
        mutex_unlock(&cgroup_mutex);
@@ -2434,7 +2436,9 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
 err_remove:
+        cgroup_lock_hierarchy(root);
        list_del(&cgrp->sibling);
+        cgroup_unlock_hierarchy(root);
        root->number_of_cgroups--;
 err_destroy:
@@ -2507,7 +2511,7 @@ static int cgroup_clear_css_refs(struct cgroup *cgrp)
        for_each_subsys(cgrp->root, ss) {
                struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
                int refcnt;
-                do {
+                while (1) {
                        /* We can only remove a CSS with a refcnt==1 */
                        refcnt = atomic_read(&css->refcnt);
                        if (refcnt > 1) {
@@ -2521,7 +2525,10 @@ static int cgroup_clear_css_refs(struct cgroup *cgrp)
                         * css_tryget() to spin until we set the
                         * CSS_REMOVED bits or abort
                         */
-                } while (atomic_cmpxchg(&css->refcnt, refcnt, 0) != refcnt);
+                        if (atomic_cmpxchg(&css->refcnt, refcnt, 0) == refcnt)
+                                break;
+                        cpu_relax();
+                }
        }
 done:
        for_each_subsys(cgrp->root, ss) {
@@ -2991,20 +2998,21 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
                mutex_unlock(&cgroup_mutex);
                return 0;
        }
-        task_lock(tsk);
-        cg = tsk->cgroups;
-        parent = task_cgroup(tsk, subsys->subsys_id);
        /* Pin the hierarchy */
-        if (!atomic_inc_not_zero(&parent->root->sb->s_active)) {
+        if (!atomic_inc_not_zero(&root->sb->s_active)) {
                /* We race with the final deactivate_super() */
                mutex_unlock(&cgroup_mutex);
                return 0;
        }
        /* Keep the cgroup alive */
+        task_lock(tsk);
+        parent = task_cgroup(tsk, subsys->subsys_id);
+        cg = tsk->cgroups;
        get_css_set(cg);
        task_unlock(tsk);
        mutex_unlock(&cgroup_mutex);
        /* Now do the VFS work to create a cgroup */
@@ -3043,7 +3051,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
                mutex_unlock(&inode->i_mutex);
                put_css_set(cg);
-                deactivate_super(parent->root->sb);
+                deactivate_super(root->sb);
                /* The cgroup is still accessible in the VFS, but
                 * we're not going to try to rmdir() it at this
                 * point. */
@@ -3069,7 +3077,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
        mutex_lock(&cgroup_mutex);
        put_css_set(cg);
        mutex_unlock(&cgroup_mutex);
-        deactivate_super(parent->root->sb);
+        deactivate_super(root->sb);
        return ret;
 }
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 647c77a88fcb..f76db9dcaa05 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -61,6 +61,14 @@
 #include <linux/cgroup.h>
 /*
+ * Workqueue for cpuset related tasks.
+ *
+ * Using kevent workqueue may cause deadlock when memory_migrate
+ * is set. So we create a separate workqueue thread for cpuset.
+ */
+static struct workqueue_struct *cpuset_wq;
+/*
 * Tracks how many cpusets are currently defined in system.
 * When there is only one cpuset (the root cpuset) we can
 * short circuit some hooks.
@@ -568,7 +576,7 @@ update_domain_attr_tree(struct sched_domain_attr *dattr, struct cpuset *c)
 * load balancing domains (sched domains) as specified by that partial
 * partition.
 *
- * See "What is sched_load_balance" in Documentation/cpusets.txt
+ * See "What is sched_load_balance" in Documentation/cgroups/cpusets.txt
 * for a background explanation of this.
 *
 * Does not return errors, on the theory that the callers of this
@@ -831,7 +839,7 @@ static DECLARE_WORK(rebuild_sched_domains_work, do_rebuild_sched_domains);
 */
 static void async_rebuild_sched_domains(void)
 {
-        schedule_work(&rebuild_sched_domains_work);
+        queue_work(cpuset_wq, &rebuild_sched_domains_work);
 }
 /*
@@ -2111,6 +2119,9 @@ void __init cpuset_init_smp(void)
        hotcpu_notifier(cpuset_track_online_cpus, 0);
        hotplug_memory_notifier(cpuset_track_online_nodes, 10);
+        cpuset_wq = create_singlethread_workqueue("cpuset");
+        BUG_ON(!cpuset_wq);
 }
 /**
diff --git a/kernel/dma-coherent.c b/kernel/dma-coherent.c
index 038707404b76..962a3b574f21 100644
--- a/kernel/dma-coherent.c
+++ b/kernel/dma-coherent.c
@@ -98,7 +98,7 @@ EXPORT_SYMBOL(dma_mark_declared_memory_occupied);
 * @size:       size of requested memory area
 * @dma_handle: This will be filled with the correct dma handle
 * @ret:        This pointer will be filled with the virtual address
- *              to allocated area.
+ *              to allocated area.
 *
 * This function should be only called from per-arch dma_alloc_coherent()
 * to support allocation from per-device coherent memory pools.
@@ -118,31 +118,32 @@ int dma_alloc_from_coherent(struct device *dev, ssize_t size,
        mem = dev->dma_mem;
        if (!mem)
                return 0;
-        if (unlikely(size > mem->size))
-                return 0;
+        *ret = NULL;
+        if (unlikely(size > (mem->size << PAGE_SHIFT)))
+                goto err;
        pageno = bitmap_find_free_region(mem->bitmap, mem->size, order);
-        if (pageno >= 0) {
+        if (unlikely(pageno < 0))
-                /*
+                goto err;
-                 * Memory was found in the per-device arena.
-                 */
+        /*
-                *dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
+         * Memory was found in the per-device area.
-                *ret = mem->virt_base + (pageno << PAGE_SHIFT);
+         */
-                memset(*ret, 0, size);
+        *dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
-        } else if (mem->flags & DMA_MEMORY_EXCLUSIVE) {
+        *ret = mem->virt_base + (pageno << PAGE_SHIFT);
-                /*
+        memset(*ret, 0, size);
-                 * The per-device arena is exhausted and we are not
-                 * permitted to fall back to generic memory.
-                 */
-                *ret = NULL;
-        } else {
-                /*
-                 * The per-device arena is exhausted and we are
-                 * permitted to fall back to generic memory.
-                 */
-                 return 0;
-        }
        return 1;
+err:
+        /*
+         * In the case where the allocation can not be satisfied from the
+         * per-device area, try to fall back to generic memory if the
+         * constraints allow it.
+         */
+        return mem->flags & DMA_MEMORY_EXCLUSIVE;
 }
 EXPORT_SYMBOL(dma_alloc_from_coherent);
diff --git a/kernel/exec_domain.c b/kernel/exec_domain.c
index 0511716e9424..667c841c2952 100644
--- a/kernel/exec_domain.c
+++ b/kernel/exec_domain.c
@@ -209,8 +209,7 @@ static int __init proc_execdomains_init(void)
 module_init(proc_execdomains_init);
 #endif
-asmlinkage long
+SYSCALL_DEFINE1(personality, u_long, personality)
-sys_personality(u_long personality)
 {
        u_long old = current->personality;
diff --git a/kernel/exit.c b/kernel/exit.c
index c7740fa3252c..f80dec3f1875 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1141,7 +1141,7 @@ NORET_TYPE void complete_and_exit(struct completion *comp, long code)
 EXPORT_SYMBOL(complete_and_exit);
-asmlinkage long sys_exit(int error_code)
+SYSCALL_DEFINE1(exit, int, error_code)
 {
        do_exit((error_code&0xff)<<8);
 }
@@ -1182,9 +1182,11 @@ do_group_exit(int exit_code)
 * wait4()-ing process will get the correct exit code - even if this
 * thread is not the thread group leader.
 */
-asmlinkage void sys_exit_group(int error_code)
+SYSCALL_DEFINE1(exit_group, int, error_code)
 {
        do_group_exit((error_code & 0xff) << 8);
+        /* NOTREACHED */
+        return 0;
 }
 static struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
@@ -1752,9 +1754,8 @@ end:
        return retval;
 }
-asmlinkage long sys_waitid(int which, pid_t upid,
+SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
-                           struct siginfo __user *infop, int options,
+                infop, int, options, struct rusage __user *, ru)
-                           struct rusage __user *ru)
 {
        struct pid *pid = NULL;
        enum pid_type type;
@@ -1793,8 +1794,8 @@ asmlinkage long sys_waitid(int which, pid_t upid,
        return ret;
 }
-asmlinkage long sys_wait4(pid_t upid, int __user *stat_addr,
+SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
-                          int options, struct rusage __user *ru)
+                int, options, struct rusage __user *, ru)
 {
        struct pid *pid = NULL;
        enum pid_type type;
@@ -1831,7 +1832,7 @@ asmlinkage long sys_wait4(pid_t upid, int __user *stat_addr,
 * sys_waitpid() remains for compatibility. waitpid() should be
 * implemented by calling sys_wait4() from libc.a.
 */
-asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options)
+SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
 {
        return sys_wait4(pid, stat_addr, options, NULL);
 }
diff --git a/kernel/fork.c b/kernel/fork.c
index 1d68f1255dd8..242a706e7721 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -817,17 +817,17 @@ static void posix_cpu_timers_init_group(struct signal_struct *sig)
 static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
 {
        struct signal_struct *sig;
-        int ret;
        if (clone_flags & CLONE_THREAD) {
-                ret = thread_group_cputime_clone_thread(current);
+                atomic_inc(&current->signal->count);
-                if (likely(!ret)) {
+                atomic_inc(&current->signal->live);
-                        atomic_inc(&current->signal->count);
+                return 0;
-                        atomic_inc(&current->signal->live);
-                }
-                return ret;
        }
        sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
+        if (sig)
+                posix_cpu_timers_init_group(sig);
        tsk->signal = sig;
        if (!sig)
                return -ENOMEM;
@@ -864,8 +864,6 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
        memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
        task_unlock(current->group_leader);
-        posix_cpu_timers_init_group(sig);
        acct_init_pacct(&sig->pacct);
        tty_audit_fork(sig);
@@ -901,7 +899,7 @@ static void copy_flags(unsigned long clone_flags, struct task_struct *p)
        clear_freeze_flag(p);
 }
-asmlinkage long sys_set_tid_address(int __user *tidptr)
+SYSCALL_DEFINE1(set_tid_address, int __user *, tidptr)
 {
        current->clear_child_tid = tidptr;
@@ -1603,7 +1601,7 @@ static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp
 * constructed. Here we are modifying the current, active,
 * task_struct.
 */
-asmlinkage long sys_unshare(unsigned long unshare_flags)
+SYSCALL_DEFINE1(unshare, unsigned long, unshare_flags)
 {
        int err = 0;
        struct fs_struct *fs, *new_fs = NULL;
diff --git a/kernel/futex.c b/kernel/futex.c
index 002aa189eb09..f89d373a9c6d 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -1733,9 +1733,8 @@ pi_faulted:
 * @head: pointer to the list-head
 * @len: length of the list-head, as userspace expects
 */
-asmlinkage long
+SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
-sys_set_robust_list(struct robust_list_head __user *head,
+                size_t, len)
-                    size_t len)
 {
        if (!futex_cmpxchg_enabled)
                return -ENOSYS;
@@ -1756,9 +1755,9 @@ sys_set_robust_list(struct robust_list_head __user *head,
 * @head_ptr: pointer to a list-head pointer, the kernel fills it in
 * @len_ptr: pointer to a length field, the kernel fills in the header size
 */
-asmlinkage long
+SYSCALL_DEFINE3(get_robust_list, int, pid,
-sys_get_robust_list(int pid, struct robust_list_head __user * __user *head_ptr,
+                struct robust_list_head __user * __user *, head_ptr,
-                    size_t __user *len_ptr)
+                size_t __user *, len_ptr)
 {
        struct robust_list_head __user *head;
        unsigned long ret;
@@ -1978,9 +1977,9 @@ long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
 }
-asmlinkage long sys_futex(u32 __user *uaddr, int op, u32 val,
+SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
-                          struct timespec __user *utime, u32 __user *uaddr2,
+                struct timespec __user *, utime, u32 __user *, uaddr2,
-                          u32 val3)
+                u32, val3)
 {
        struct timespec ts;
        ktime_t t, *tp = NULL;
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 1455b7651b6b..f394d2a42ca3 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -501,6 +501,13 @@ static void hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base)
                        continue;
                timer = rb_entry(base->first, struct hrtimer, node);
                expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
+                /*
+                 * clock_was_set() has changed base->offset so the
+                 * result might be negative. Fix it up to prevent a
+                 * false positive in clockevents_program_event()
+                 */
+                if (expires.tv64 < 0)
+                        expires.tv64 = 0;
                if (expires.tv64 < cpu_base->expires_next.tv64)
                        cpu_base->expires_next = expires;
        }
@@ -614,7 +621,9 @@ void clock_was_set(void)
 */
 void hres_timers_resume(void)
 {
-        /* Retrigger the CPU local events: */
+        WARN_ONCE(!irqs_disabled(),
+                  KERN_INFO "hres_timers_resume() called with IRQs enabled!");
        retrigger_next_event(NULL);
 }
@@ -1156,6 +1165,29 @@ static void __run_hrtimer(struct hrtimer *timer)
 #ifdef CONFIG_HIGH_RES_TIMERS
+static int force_clock_reprogram;
+/*
+ * After 5 iteration's attempts, we consider that hrtimer_interrupt()
+ * is hanging, which could happen with something that slows the interrupt
+ * such as the tracing. Then we force the clock reprogramming for each future
+ * hrtimer interrupts to avoid infinite loops and use the min_delta_ns
+ * threshold that we will overwrite.
+ * The next tick event will be scheduled to 3 times we currently spend on
+ * hrtimer_interrupt(). This gives a good compromise, the cpus will spend
+ * 1/4 of their time to process the hrtimer interrupts. This is enough to
+ * let it running without serious starvation.
+ */
+static inline void
+hrtimer_interrupt_hanging(struct clock_event_device *dev,
+                        ktime_t try_time)
+{
+        force_clock_reprogram = 1;
+        dev->min_delta_ns = (unsigned long)try_time.tv64 * 3;
+        printk(KERN_WARNING "hrtimer: interrupt too slow, "
+                "forcing clock min delta to %lu ns\n", dev->min_delta_ns);
+}
 /*
 * High resolution timer interrupt
 * Called with interrupts disabled
@@ -1165,6 +1197,7 @@ void hrtimer_interrupt(struct clock_event_device *dev)
        struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
        struct hrtimer_clock_base *base;
        ktime_t expires_next, now;
+        int nr_retries = 0;
        int i;
        BUG_ON(!cpu_base->hres_active);
@@ -1172,6 +1205,10 @@ void hrtimer_interrupt(struct clock_event_device *dev)
        dev->next_event.tv64 = KTIME_MAX;
 retry:
+        /* 5 retries is enough to notice a hang */
+        if (!(++nr_retries % 5))
+                hrtimer_interrupt_hanging(dev, ktime_sub(ktime_get(), now));
        now = ktime_get();
        expires_next.tv64 = KTIME_MAX;
@@ -1224,7 +1261,7 @@ void hrtimer_interrupt(struct clock_event_device *dev)
        /* Reprogramming necessary ? */
        if (expires_next.tv64 != KTIME_MAX) {
-                if (tick_program_event(expires_next, 0))
+                if (tick_program_event(expires_next, force_clock_reprogram))
                        goto retry;
        }
 }
@@ -1467,8 +1504,8 @@ out:
        return ret;
 }
-asmlinkage long
+SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
-sys_nanosleep(struct timespec __user *rqtp, struct timespec __user *rmtp)
+                struct timespec __user *, rmtp)
 {
        struct timespec tu;
@@ -1578,6 +1615,10 @@ static int __cpuinit hrtimer_cpu_notify(struct notifier_block *self,
                break;
 #ifdef CONFIG_HOTPLUG_CPU
+        case CPU_DYING:
+        case CPU_DYING_FROZEN:
+                clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DYING, &scpu);
+                break;
        case CPU_DEAD:
        case CPU_DEAD_FROZEN:
        {
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index f63c706d25e1..7de11bd64dfe 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -383,6 +383,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
 out_unlock:
        spin_unlock(&desc->lock);
 }
+EXPORT_SYMBOL_GPL(handle_level_irq);
 /**
 *      handle_fasteoi_irq - irq handler for transparent controllers
@@ -593,6 +594,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
        }
        spin_unlock_irqrestore(&desc->lock, flags);
 }
+EXPORT_SYMBOL_GPL(__set_irq_handler);
 void
 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index c20db0be9173..3aba8d12f328 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -39,6 +39,18 @@ void handle_bad_irq(unsigned int irq, struct irq_desc *desc)
        ack_bad_irq(irq);
 }
+#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
+static void __init init_irq_default_affinity(void)
+{
+        alloc_bootmem_cpumask_var(&irq_default_affinity);
+        cpumask_setall(irq_default_affinity);
+}
+#else
+static void __init init_irq_default_affinity(void)
+{
+}
+#endif
 /*
 * Linux has a controller-independent interrupt architecture.
 * Every controller has a 'controller-template', that is used
@@ -134,6 +146,8 @@ int __init early_irq_init(void)
        int legacy_count;
        int i;
+        init_irq_default_affinity();
        desc = irq_desc_legacy;
        legacy_count = ARRAY_SIZE(irq_desc_legacy);
@@ -219,6 +233,8 @@ int __init early_irq_init(void)
        int count;
        int i;
+        init_irq_default_affinity();
        desc = irq_desc;
        count = ARRAY_SIZE(irq_desc);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index cd0cd8dcb345..291f03664552 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -15,17 +15,9 @@
 #include "internals.h"
-#ifdef CONFIG_SMP
+#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 cpumask_var_t irq_default_affinity;
-static int init_irq_default_affinity(void)
-{
-        alloc_cpumask_var(&irq_default_affinity, GFP_KERNEL);
-        cpumask_setall(irq_default_affinity);
-        return 0;
-}
-core_initcall(init_irq_default_affinity);
 /**
 *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
 *      @irq: interrupt number to wait for
diff --git a/kernel/itimer.c b/kernel/itimer.c
index db7c358b9a02..6a5fe93dd8bd 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -100,7 +100,7 @@ int do_getitimer(int which, struct itimerval *value)
        return 0;
 }
-asmlinkage long sys_getitimer(int which, struct itimerval __user *value)
+SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value)
 {
        int error = -EFAULT;
        struct itimerval get_buffer;
@@ -260,9 +260,8 @@ unsigned int alarm_setitimer(unsigned int seconds)
        return it_old.it_value.tv_sec;
 }
-asmlinkage long sys_setitimer(int which,
+SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value,
-                              struct itimerval __user *value,
+                struct itimerval __user *, ovalue)
-                              struct itimerval __user *ovalue)
 {
        struct itimerval set_buffer, get_buffer;
        int error;
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index e694afa0eb8c..7b8b0f21a5b1 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -30,19 +30,20 @@
 #define all_var 0
 #endif
-extern const unsigned long kallsyms_addresses[];
+/* These will be re-linked against their real values during the second link stage */
-extern const u8 kallsyms_names[];
+extern const unsigned long kallsyms_addresses[] __attribute__((weak));
+extern const u8 kallsyms_names[] __attribute__((weak));
 /* tell the compiler that the count isn't in the small data section if the arch
 * has one (eg: FRV)
 */
 extern const unsigned long kallsyms_num_syms
-        __attribute__((__section__(".rodata")));
+__attribute__((weak, section(".rodata")));
-extern const u8 kallsyms_token_table[];
+extern const u8 kallsyms_token_table[] __attribute__((weak));
-extern const u16 kallsyms_token_index[];
+extern const u16 kallsyms_token_index[] __attribute__((weak));
-extern const unsigned long kallsyms_markers[];
+extern const unsigned long kallsyms_markers[] __attribute__((weak));
 static inline int is_kernel_inittext(unsigned long addr)
 {
@@ -167,6 +168,9 @@ static unsigned long get_symbol_pos(unsigned long addr,
        unsigned long symbol_start = 0, symbol_end = 0;
        unsigned long i, low, high, mid;
+        /* This kernel should never had been booted. */
+        BUG_ON(!kallsyms_addresses);
        /* do a binary search on the sorted kallsyms_addresses array */
        low = 0;
        high = kallsyms_num_syms;
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 3fb855ad6aa0..8a6d7b08864e 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -934,9 +934,8 @@ struct kimage *kexec_crash_image;
 static DEFINE_MUTEX(kexec_mutex);
-asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
+SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,
-                                struct kexec_segment __user *segments,
+                struct kexec_segment __user *, segments, unsigned long, flags)
-                                unsigned long flags)
 {
        struct kimage **dest_image, *image;
        int result;
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 1b9cbdc0127a..7ba8cd9845cb 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -123,7 +123,7 @@ static int collect_garbage_slots(void);
 static int __kprobes check_safety(void)
 {
        int ret = 0;
-#if defined(CONFIG_PREEMPT) && defined(CONFIG_PM)
+#if defined(CONFIG_PREEMPT) && defined(CONFIG_FREEZER)
        ret = freeze_processes();
        if (ret == 0) {
                struct task_struct *p, *q;
diff --git a/kernel/module.c b/kernel/module.c
index c9332c90d5a0..ba22484a987e 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -573,13 +573,13 @@ static char last_unloaded_module[MODULE_NAME_LEN+1];
 /* Init the unload section of the module. */
 static void module_unload_init(struct module *mod)
 {
-        unsigned int i;
+        int cpu;
        INIT_LIST_HEAD(&mod->modules_which_use_me);
-        for (i = 0; i < NR_CPUS; i++)
+        for_each_possible_cpu(cpu)
-                local_set(&mod->ref[i].count, 0);
+                local_set(__module_ref_addr(mod, cpu), 0);
        /* Hold reference count during initialization. */
-        local_set(&mod->ref[raw_smp_processor_id()].count, 1);
+        local_set(__module_ref_addr(mod, raw_smp_processor_id()), 1);
        /* Backwards compatibility macros put refcount during init. */
        mod->waiter = current;
 }
@@ -717,10 +717,11 @@ static int try_stop_module(struct module *mod, int flags, int *forced)
 unsigned int module_refcount(struct module *mod)
 {
-        unsigned int i, total = 0;
+        unsigned int total = 0;
+        int cpu;
-        for (i = 0; i < NR_CPUS; i++)
+        for_each_possible_cpu(cpu)
-                total += local_read(&mod->ref[i].count);
+                total += local_read(__module_ref_addr(mod, cpu));
        return total;
 }
 EXPORT_SYMBOL(module_refcount);
@@ -743,8 +744,8 @@ static void wait_for_zero_refcount(struct module *mod)
        mutex_lock(&module_mutex);
 }
-asmlinkage long
+SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
-sys_delete_module(const char __user *name_user, unsigned int flags)
+                unsigned int, flags)
 {
        struct module *mod;
        char name[MODULE_NAME_LEN];
@@ -894,7 +895,7 @@ void module_put(struct module *module)
 {
        if (module) {
                unsigned int cpu = get_cpu();
-                local_dec(&module->ref[cpu].count);
+                local_dec(__module_ref_addr(module, cpu));
                /* Maybe they're waiting for us to drop reference? */
                if (unlikely(!module_is_live(module)))
                        wake_up_process(module->waiter);
@@ -1464,7 +1465,10 @@ static void free_module(struct module *mod)
        kfree(mod->args);
        if (mod->percpu)
                percpu_modfree(mod->percpu);
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        if (mod->refptr)
+                percpu_modfree(mod->refptr);
+#endif
        /* Free lock-classes: */
        lockdep_free_key_range(mod->module_core, mod->core_size);
@@ -2011,6 +2015,14 @@ static noinline struct module *load_module(void __user *umod,
        if (err < 0)
                goto free_mod;
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        mod->refptr = percpu_modalloc(sizeof(local_t), __alignof__(local_t),
+                                      mod->name);
+        if (!mod->refptr) {
+                err = -ENOMEM;
+                goto free_mod;
+        }
+#endif
        if (pcpuindex) {
                /* We have a special allocation for this section. */
                percpu = percpu_modalloc(sechdrs[pcpuindex].sh_size,
@@ -2018,7 +2030,7 @@ static noinline struct module *load_module(void __user *umod,
                                         mod->name);
                if (!percpu) {
                        err = -ENOMEM;
-                        goto free_mod;
+                        goto free_percpu;
                }
                sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
                mod->percpu = percpu;
@@ -2282,6 +2294,9 @@ static noinline struct module *load_module(void __user *umod,
 free_percpu:
        if (percpu)
                percpu_modfree(percpu);
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        percpu_modfree(mod->refptr);
+#endif
 free_mod:
        kfree(args);
 free_hdr:
@@ -2296,10 +2311,8 @@ static noinline struct module *load_module(void __user *umod,
 }
 /* This is where the real work happens */
-asmlinkage long
+SYSCALL_DEFINE3(init_module, void __user *, umod,
-sys_init_module(void __user *umod,
+                unsigned long, len, const char __user *, uargs)
-                unsigned long len,
-                const char __user *uargs)
 {
        struct module *mod;
        int ret = 0;
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 157de3a47832..fa07da94d7be 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -10,76 +10,6 @@
 #include <linux/kernel_stat.h>
 /*
- * Allocate the thread_group_cputime structure appropriately and fill in the
- * current values of the fields.  Called from copy_signal() via
- * thread_group_cputime_clone_thread() when adding a second or subsequent
- * thread to a thread group.  Assumes interrupts are enabled when called.
- */
-int thread_group_cputime_alloc(struct task_struct *tsk)
-{
-        struct signal_struct *sig = tsk->signal;
-        struct task_cputime *cputime;
-        /*
-         * If we have multiple threads and we don't already have a
-         * per-CPU task_cputime struct (checked in the caller), allocate
-         * one and fill it in with the times accumulated so far.  We may
-         * race with another thread so recheck after we pick up the sighand
-         * lock.
-         */
-        cputime = alloc_percpu(struct task_cputime);
-        if (cputime == NULL)
-                return -ENOMEM;
-        spin_lock_irq(&tsk->sighand->siglock);
-        if (sig->cputime.totals) {
-                spin_unlock_irq(&tsk->sighand->siglock);
-                free_percpu(cputime);
-                return 0;
-        }
-        sig->cputime.totals = cputime;
-        cputime = per_cpu_ptr(sig->cputime.totals, smp_processor_id());
-        cputime->utime = tsk->utime;
-        cputime->stime = tsk->stime;
-        cputime->sum_exec_runtime = tsk->se.sum_exec_runtime;
-        spin_unlock_irq(&tsk->sighand->siglock);
-        return 0;
-}
-/**
- * thread_group_cputime - Sum the thread group time fields across all CPUs.
- *
- * @tsk:        The task we use to identify the thread group.
- * @times:      task_cputime structure in which we return the summed fields.
- *
- * Walk the list of CPUs to sum the per-CPU time fields in the thread group
- * time structure.
- */
-void thread_group_cputime(
-        struct task_struct *tsk,
-        struct task_cputime *times)
-{
-        struct task_cputime *totals, *tot;
-        int i;
-        totals = tsk->signal->cputime.totals;
-        if (!totals) {
-                times->utime = tsk->utime;
-                times->stime = tsk->stime;
-                times->sum_exec_runtime = tsk->se.sum_exec_runtime;
-                return;
-        }
-        times->stime = times->utime = cputime_zero;
-        times->sum_exec_runtime = 0;
-        for_each_possible_cpu(i) {
-                tot = per_cpu_ptr(totals, i);
-                times->utime = cputime_add(times->utime, tot->utime);
-                times->stime = cputime_add(times->stime, tot->stime);
-                times->sum_exec_runtime += tot->sum_exec_runtime;
-        }
-}
-/*
 * Called after updating RLIMIT_CPU to set timer expiration if necessary.
 */
 void update_rlimit_cpu(unsigned long rlim_new)
diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index 887c63787de6..052ec4d195c7 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -477,10 +477,9 @@ static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
 /* Create a POSIX.1b interval timer. */
-asmlinkage long
+SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
-sys_timer_create(const clockid_t which_clock,
+                struct sigevent __user *, timer_event_spec,
-                 struct sigevent __user *timer_event_spec,
+                timer_t __user *, created_timer_id)
-                 timer_t __user * created_timer_id)
 {
        struct k_itimer *new_timer;
        int error, new_timer_id;
@@ -661,8 +660,8 @@ common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
 }
 /* Get the time remaining on a POSIX.1b interval timer. */
-asmlinkage long
+SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
-sys_timer_gettime(timer_t timer_id, struct itimerspec __user *setting)
+                struct itimerspec __user *, setting)
 {
        struct k_itimer *timr;
        struct itimerspec cur_setting;
@@ -691,8 +690,7 @@ sys_timer_gettime(timer_t timer_id, struct itimerspec __user *setting)
 * the call back to do_schedule_next_timer().  So all we need to do is
 * to pick up the frozen overrun.
 */
-asmlinkage long
+SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
-sys_timer_getoverrun(timer_t timer_id)
 {
        struct k_itimer *timr;
        int overrun;
@@ -760,10 +758,9 @@ common_timer_set(struct k_itimer *timr, int flags,
 }
 /* Set a POSIX.1b interval timer */
-asmlinkage long
+SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
-sys_timer_settime(timer_t timer_id, int flags,
+                const struct itimerspec __user *, new_setting,
-                  const struct itimerspec __user *new_setting,
+                struct itimerspec __user *, old_setting)
-                  struct itimerspec __user *old_setting)
 {
        struct k_itimer *timr;
        struct itimerspec new_spec, old_spec;
@@ -816,8 +813,7 @@ static inline int timer_delete_hook(struct k_itimer *timer)
 }
 /* Delete a POSIX.1b interval timer. */
-asmlinkage long
+SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
-sys_timer_delete(timer_t timer_id)
 {
        struct k_itimer *timer;
        unsigned long flags;
@@ -903,8 +899,8 @@ int do_posix_clock_nonanosleep(const clockid_t clock, int flags,
 }
 EXPORT_SYMBOL_GPL(do_posix_clock_nonanosleep);
-asmlinkage long sys_clock_settime(const clockid_t which_clock,
+SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
-                                  const struct timespec __user *tp)
+                const struct timespec __user *, tp)
 {
        struct timespec new_tp;
@@ -916,8 +912,8 @@ asmlinkage long sys_clock_settime(const clockid_t which_clock,
        return CLOCK_DISPATCH(which_clock, clock_set, (which_clock, &new_tp));
 }
-asmlinkage long
+SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
-sys_clock_gettime(const clockid_t which_clock, struct timespec __user *tp)
+                struct timespec __user *,tp)
 {
        struct timespec kernel_tp;
        int error;
@@ -933,8 +929,8 @@ sys_clock_gettime(const clockid_t which_clock, struct timespec __user *tp)
 }
-asmlinkage long
+SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
-sys_clock_getres(const clockid_t which_clock, struct timespec __user *tp)
+                struct timespec __user *, tp)
 {
        struct timespec rtn_tp;
        int error;
@@ -963,10 +959,9 @@ static int common_nsleep(const clockid_t which_clock, int flags,
                                 which_clock);
 }
-asmlinkage long
+SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
-sys_clock_nanosleep(const clockid_t which_clock, int flags,
+                const struct timespec __user *, rqtp,
-                    const struct timespec __user *rqtp,
+                struct timespec __user *, rmtp)
-                    struct timespec __user *rmtp)
 {
        struct timespec t;
diff --git a/kernel/power/Makefile b/kernel/power/Makefile
index 597823b5b700..d7a10167a25b 100644
--- a/kernel/power/Makefile
+++ b/kernel/power/Makefile
@@ -4,7 +4,8 @@ EXTRA_CFLAGS	+=	-DDEBUG
 endif
 obj-y                           := main.o
-obj-$(CONFIG_PM_SLEEP)          += process.o console.o
+obj-$(CONFIG_PM_SLEEP)          += console.o
+obj-$(CONFIG_FREEZER)           += process.o
 obj-$(CONFIG_HIBERNATION)       += swsusp.o disk.o snapshot.o swap.o user.o
 obj-$(CONFIG_MAGIC_SYSRQ)       += poweroff.o
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 45e8541ab7e3..432ee575c9ee 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -71,6 +71,14 @@ void hibernation_set_ops(struct platform_hibernation_ops *ops)
        mutex_unlock(&pm_mutex);
 }
+static bool entering_platform_hibernation;
+bool system_entering_hibernation(void)
+{
+        return entering_platform_hibernation;
+}
+EXPORT_SYMBOL(system_entering_hibernation);
 #ifdef CONFIG_PM_DEBUG
 static void hibernation_debug_sleep(void)
 {
@@ -411,6 +419,7 @@ int hibernation_platform_enter(void)
        if (error)
                goto Close;
+        entering_platform_hibernation = true;
        suspend_console();
        error = device_suspend(PMSG_HIBERNATE);
        if (error) {
@@ -445,6 +454,7 @@ int hibernation_platform_enter(void)
 Finish:
        hibernation_ops->finish();
 Resume_devices:
+        entering_platform_hibernation = false;
        device_resume(PMSG_RESTORE);
        resume_console();
 Close:
diff --git a/kernel/printk.c b/kernel/printk.c
index 7015733793e8..69188f226a93 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -382,7 +382,7 @@ out:
        return error;
 }
-asmlinkage long sys_syslog(int type, char __user *buf, int len)
+SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
 {
        return do_syslog(type, buf, len);
 }
@@ -742,11 +742,6 @@ EXPORT_SYMBOL(vprintk);
 #else
-asmlinkage long sys_syslog(int type, char __user *buf, int len)
-{
-        return -ENOSYS;
-}
 static void call_console_drivers(unsigned start, unsigned end)
 {
 }
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 29dc700e198c..c9cf48b21f05 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -574,7 +574,7 @@ struct task_struct *ptrace_get_task_struct(pid_t pid)
 #define arch_ptrace_attach(child)       do { } while (0)
 #endif
-asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
+SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data)
 {
        struct task_struct *child;
        long ret;
diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
index 490934fc7ac3..bd5a9003497c 100644
--- a/kernel/rcuclassic.c
+++ b/kernel/rcuclassic.c
@@ -716,7 +716,7 @@ void rcu_check_callbacks(int cpu, int user)
        raise_rcu_softirq();
 }
-static void rcu_init_percpu_data(int cpu, struct rcu_ctrlblk *rcp,
+static void __cpuinit rcu_init_percpu_data(int cpu, struct rcu_ctrlblk *rcp,
                                                struct rcu_data *rdp)
 {
        unsigned long flags;
diff --git a/kernel/rcutree.c b/kernel/rcutree.c
index f2d8638e6c60..b2fd602a6f6f 100644
--- a/kernel/rcutree.c
+++ b/kernel/rcutree.c
@@ -1314,7 +1314,7 @@ int rcu_needs_cpu(int cpu)
 * access due to the fact that this CPU cannot possibly have any RCU
 * callbacks in flight yet.
 */
-static void
+static void __cpuinit
 rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
 {
        unsigned long flags;
diff --git a/kernel/relay.c b/kernel/relay.c
index 09ac2008f77b..9d79b7854fa6 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -663,8 +663,10 @@ int relay_late_setup_files(struct rchan *chan,
        mutex_lock(&relay_channels_mutex);
        /* Is chan already set up? */
-        if (unlikely(chan->has_base_filename))
+        if (unlikely(chan->has_base_filename)) {
+                mutex_unlock(&relay_channels_mutex);
                return -EEXIST;
+        }
        chan->has_base_filename = 1;
        chan->parent = parent;
        curr_cpu = get_cpu();
diff --git a/kernel/resource.c b/kernel/resource.c
index ca6a1536b205..fd5d7d574bb9 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -620,6 +620,7 @@ resource_size_t resource_alignment(struct resource *res)
 * @start: resource start address
 * @n: resource region size
 * @name: reserving caller's ID string
+ * @flags: IO resource flags
 */
 struct resource * __request_region(struct resource *parent,
                                   resource_size_t start, resource_size_t n,
diff --git a/kernel/sched.c b/kernel/sched.c
index 86f5a063f0b9..1dae85a1221a 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -467,11 +467,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;
@@ -1323,8 +1329,8 @@ static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
 * slice expiry etc.
 */
-#define WEIGHT_IDLEPRIO         2
+#define WEIGHT_IDLEPRIO                3
-#define WMULT_IDLEPRIO          (1 << 31)
+#define WMULT_IDLEPRIO         1431655765
 /*
 * Nice levels are multiplicative, with a gentle 10% change for every
@@ -1610,21 +1616,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 +1664,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)
 {
@@ -2274,6 +2317,16 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
        if (!sched_feat(SYNC_WAKEUPS))
                sync = 0;
+        if (!sync) {
+                if (current->se.avg_overlap < sysctl_sched_migration_cost &&
+                          p->se.avg_overlap < sysctl_sched_migration_cost)
+                        sync = 1;
+        } else {
+                if (current->se.avg_overlap >= sysctl_sched_migration_cost ||
+                          p->se.avg_overlap >= sysctl_sched_migration_cost)
+                        sync = 0;
+        }
 #ifdef CONFIG_SMP
        if (sched_feat(LB_WAKEUP_UPDATE)) {
                struct sched_domain *sd;
@@ -2472,6 +2525,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();
 }
@@ -2612,6 +2667,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;
@@ -2630,7 +2691,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
@@ -3011,6 +3072,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.
         */
@@ -3057,9 +3128,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;
@@ -3904,19 +3981,24 @@ int select_nohz_load_balancer(int stop_tick)
        int cpu = smp_processor_id();
        if (stop_tick) {
-                cpumask_set_cpu(cpu, nohz.cpu_mask);
                cpu_rq(cpu)->in_nohz_recently = 1;
-                /*
+                if (!cpu_active(cpu)) {
-                 * If we are going offline and still the leader, give up!
+                        if (atomic_read(&nohz.load_balancer) != cpu)
-                 */
+                                return 0;
-                if (!cpu_active(cpu) &&
-                    atomic_read(&nohz.load_balancer) == cpu) {
+                        /*
+                         * If we are going offline and still the leader,
+                         * give up!
+                         */
                        if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
                                BUG();
                        return 0;
                }
+                cpumask_set_cpu(cpu, nohz.cpu_mask);
                /* time for ilb owner also to sleep */
                if (cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                        if (atomic_read(&nohz.load_balancer) == cpu)
@@ -4464,7 +4546,7 @@ void __kprobes sub_preempt_count(int val)
        /*
         * Underflow?
         */
-       if (DEBUG_LOCKS_WARN_ON(val > preempt_count() - (!!kernel_locked())))
+        if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
                return;
        /*
         * Is the spinlock portion underflowing?
@@ -5150,7 +5232,7 @@ int can_nice(const struct task_struct *p, const int nice)
 * sys_setpriority is a more generic, but much slower function that
 * does similar things.
 */
-asmlinkage long sys_nice(int increment)
+SYSCALL_DEFINE1(nice, int, increment)
 {
        long nice, retval;
@@ -5457,8 +5539,8 @@ do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
 * @policy: new policy.
 * @param: structure containing the new RT priority.
 */
-asmlinkage long
+SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
-sys_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
+                struct sched_param __user *, param)
 {
        /* negative values for policy are not valid */
        if (policy < 0)
@@ -5472,7 +5554,7 @@ sys_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
 * @pid: the pid in question.
 * @param: structure containing the new RT priority.
 */
-asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param __user *param)
+SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
 {
        return do_sched_setscheduler(pid, -1, param);
 }
@@ -5481,7 +5563,7 @@ asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param __user *param)
 * sys_sched_getscheduler - get the policy (scheduling class) of a thread
 * @pid: the pid in question.
 */
-asmlinkage long sys_sched_getscheduler(pid_t pid)
+SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
 {
        struct task_struct *p;
        int retval;
@@ -5506,7 +5588,7 @@ asmlinkage long sys_sched_getscheduler(pid_t pid)
 * @pid: the pid in question.
 * @param: structure containing the RT priority.
 */
-asmlinkage long sys_sched_getparam(pid_t pid, struct sched_param __user *param)
+SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
 {
        struct sched_param lp;
        struct task_struct *p;
@@ -5624,8 +5706,8 @@ static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
 * @len: length in bytes of the bitmask pointed to by user_mask_ptr
 * @user_mask_ptr: user-space pointer to the new cpu mask
 */
-asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
+SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
-                                      unsigned long __user *user_mask_ptr)
+                unsigned long __user *, user_mask_ptr)
 {
        cpumask_var_t new_mask;
        int retval;
@@ -5672,8 +5754,8 @@ out_unlock:
 * @len: length in bytes of the bitmask pointed to by user_mask_ptr
 * @user_mask_ptr: user-space pointer to hold the current cpu mask
 */
-asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
+SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
-                                      unsigned long __user *user_mask_ptr)
+                unsigned long __user *, user_mask_ptr)
 {
        int ret;
        cpumask_var_t mask;
@@ -5702,7 +5784,7 @@ asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
 * This function yields the current CPU to other tasks. If there are no
 * other threads running on this CPU then this function will return.
 */
-asmlinkage long sys_sched_yield(void)
+SYSCALL_DEFINE0(sched_yield)
 {
        struct rq *rq = this_rq_lock();
@@ -5843,7 +5925,7 @@ long __sched io_schedule_timeout(long timeout)
 * this syscall returns the maximum rt_priority that can be used
 * by a given scheduling class.
 */
-asmlinkage long sys_sched_get_priority_max(int policy)
+SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
 {
        int ret = -EINVAL;
@@ -5868,7 +5950,7 @@ asmlinkage long sys_sched_get_priority_max(int policy)
 * this syscall returns the minimum rt_priority that can be used
 * by a given scheduling class.
 */
-asmlinkage long sys_sched_get_priority_min(int policy)
+SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
 {
        int ret = -EINVAL;
@@ -5893,8 +5975,8 @@ asmlinkage long sys_sched_get_priority_min(int policy)
 * this syscall writes the default timeslice value of a given process
 * into the user-space timespec buffer. A value of '0' means infinity.
 */
-asmlinkage
+SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
-long sys_sched_rr_get_interval(pid_t pid, struct timespec __user *interval)
+                struct timespec __user *, interval)
 {
        struct task_struct *p;
        unsigned int time_slice;
@@ -8228,11 +8310,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;
@@ -9074,6 +9160,13 @@ static int tg_schedulable(struct task_group *tg, void *data)
                runtime = d->rt_runtime;
        }
+#ifdef CONFIG_USER_SCHED
+        if (tg == &root_task_group) {
+                period = global_rt_period();
+                runtime = global_rt_runtime();
+        }
+#endif
        /*
         * Cannot have more runtime than the period.
         */
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index bdf64346b4d1..bc1563e7a248 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -283,7 +283,7 @@ static void update_min_vruntime(struct cfs_rq *cfs_rq)
                                                   struct sched_entity,
                                                   run_node);
-                if (vruntime == cfs_rq->min_vruntime)
+                if (!cfs_rq->curr)
                        vruntime = se->vruntime;
                else
                        vruntime = min_vruntime(vruntime, se->vruntime);
@@ -429,7 +429,10 @@ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
        u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
        for_each_sched_entity(se) {
-                struct load_weight *load = &cfs_rq->load;
+                struct load_weight *load;
+                cfs_rq = cfs_rq_of(se);
+                load = &cfs_rq->load;
                if (unlikely(!se->on_rq)) {
                        struct load_weight lw = cfs_rq->load;
@@ -677,9 +680,13 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
                        unsigned long thresh = sysctl_sched_latency;
                        /*
-                         * convert the sleeper threshold into virtual time
+                         * Convert the sleeper threshold into virtual time.
+                         * SCHED_IDLE is a special sub-class.  We care about
+                         * fairness only relative to other SCHED_IDLE tasks,
+                         * all of which have the same weight.
                         */
-                        if (sched_feat(NORMALIZED_SLEEPER))
+                        if (sched_feat(NORMALIZED_SLEEPER) &&
+                                        task_of(se)->policy != SCHED_IDLE)
                                thresh = calc_delta_fair(thresh, se);
                        vruntime -= thresh;
@@ -712,7 +719,7 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int wakeup)
                __enqueue_entity(cfs_rq, se);
 }
-static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void __clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
        if (cfs_rq->last == se)
                cfs_rq->last = NULL;
@@ -721,6 +728,12 @@ static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
                cfs_rq->next = NULL;
 }
+static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+{
+        for_each_sched_entity(se)
+                __clear_buddies(cfs_rq_of(se), se);
+}
 static void
 dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
 {
@@ -761,8 +774,14 @@ check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
        ideal_runtime = sched_slice(cfs_rq, curr);
        delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
-        if (delta_exec > ideal_runtime)
+        if (delta_exec > ideal_runtime) {
                resched_task(rq_of(cfs_rq)->curr);
+                /*
+                 * The current task ran long enough, ensure it doesn't get
+                 * re-elected due to buddy favours.
+                 */
+                clear_buddies(cfs_rq, curr);
+        }
 }
 static void
@@ -1172,20 +1191,15 @@ wake_affine(struct sched_domain *this_sd, struct rq *this_rq,
            int idx, unsigned long load, unsigned long this_load,
            unsigned int imbalance)
 {
-        struct task_struct *curr = this_rq->curr;
-        struct task_group *tg;
        unsigned long tl = this_load;
        unsigned long tl_per_task;
+        struct task_group *tg;
        unsigned long weight;
        int balanced;
        if (!(this_sd->flags & SD_WAKE_AFFINE) || !sched_feat(AFFINE_WAKEUPS))
                return 0;
-        if (sync && (curr->se.avg_overlap > sysctl_sched_migration_cost ||
-                        p->se.avg_overlap > sysctl_sched_migration_cost))
-                sync = 0;
        /*
         * If sync wakeup then subtract the (maximum possible)
         * effect of the currently running task from the load
@@ -1387,14 +1401,18 @@ wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
 static void set_last_buddy(struct sched_entity *se)
 {
-        for_each_sched_entity(se)
+        if (likely(task_of(se)->policy != SCHED_IDLE)) {
-                cfs_rq_of(se)->last = se;
+                for_each_sched_entity(se)
+                        cfs_rq_of(se)->last = se;
+        }
 }
 static void set_next_buddy(struct sched_entity *se)
 {
-        for_each_sched_entity(se)
+        if (likely(task_of(se)->policy != SCHED_IDLE)) {
-                cfs_rq_of(se)->next = se;
+                for_each_sched_entity(se)
+                        cfs_rq_of(se)->next = se;
+        }
 }
 /*
@@ -1440,18 +1458,22 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int sync)
                return;
        /*
-         * Batch tasks do not preempt (their preemption is driven by
+         * Batch and idle tasks do not preempt (their preemption is driven by
         * the tick):
         */
-        if (unlikely(p->policy == SCHED_BATCH))
+        if (unlikely(p->policy != SCHED_NORMAL))
                return;
+        /* Idle tasks are by definition preempted by everybody. */
+        if (unlikely(curr->policy == SCHED_IDLE)) {
+                resched_task(curr);
+                return;
+        }
        if (!sched_feat(WAKEUP_PREEMPT))
                return;
-        if (sched_feat(WAKEUP_OVERLAP) && (sync ||
+        if (sched_feat(WAKEUP_OVERLAP) && sync) {
-                        (se->avg_overlap < sysctl_sched_migration_cost &&
-                         pse->avg_overlap < sysctl_sched_migration_cost))) {
                resched_task(curr);
                return;
        }
@@ -1482,6 +1504,11 @@ static struct task_struct *pick_next_task_fair(struct rq *rq)
        do {
                se = pick_next_entity(cfs_rq);
+                /*
+                 * If se was a buddy, clear it so that it will have to earn
+                 * the favour again.
+                 */
+                __clear_buddies(cfs_rq, se);
                set_next_entity(cfs_rq, se);
                cfs_rq = group_cfs_rq(se);
        } while (cfs_rq);
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 954e1a81b796..c79dc7844012 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -3,6 +3,40 @@
 * policies)
 */
+static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
+{
+        return container_of(rt_se, struct task_struct, rt);
+}
+#ifdef CONFIG_RT_GROUP_SCHED
+static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
+{
+        return rt_rq->rq;
+}
+static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
+{
+        return rt_se->rt_rq;
+}
+#else /* CONFIG_RT_GROUP_SCHED */
+static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
+{
+        return container_of(rt_rq, struct rq, rt);
+}
+static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
+{
+        struct task_struct *p = rt_task_of(rt_se);
+        struct rq *rq = task_rq(p);
+        return &rq->rt;
+}
+#endif /* CONFIG_RT_GROUP_SCHED */
 #ifdef CONFIG_SMP
 static inline int rt_overloaded(struct rq *rq)
@@ -37,25 +71,69 @@ static inline void rt_clear_overload(struct rq *rq)
        cpumask_clear_cpu(rq->cpu, rq->rd->rto_mask);
 }
-static void update_rt_migration(struct rq *rq)
+static void update_rt_migration(struct rt_rq *rt_rq)
 {
-        if (rq->rt.rt_nr_migratory && (rq->rt.rt_nr_running > 1)) {
+        if (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
@@ -968,8 +1130,8 @@ static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
        if ((this_cpu != -1) && cpu_isset(this_cpu, *mask))
                return this_cpu;
-        first = first_cpu(*mask);
+        first = cpumask_first(mask);
-        if (first != NR_CPUS)
+        if (first < nr_cpu_ids)
                return first;
        return -1;
@@ -1072,7 +1234,7 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
                }
                /* If this rq is still suitable use it. */
-                if (lowest_rq->rt.highest_prio > task->prio)
+                if (lowest_rq->rt.highest_prio.curr > task->prio)
                        break;
                /* try again */
@@ -1083,6 +1245,31 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
        return lowest_rq;
 }
+static inline int has_pushable_tasks(struct rq *rq)
+{
+        return !plist_head_empty(&rq->rt.pushable_tasks);
+}
+static struct task_struct *pick_next_pushable_task(struct rq *rq)
+{
+        struct task_struct *p;
+        if (!has_pushable_tasks(rq))
+                return NULL;
+        p = plist_first_entry(&rq->rt.pushable_tasks,
+                              struct task_struct, pushable_tasks);
+        BUG_ON(rq->cpu != task_cpu(p));
+        BUG_ON(task_current(rq, p));
+        BUG_ON(p->rt.nr_cpus_allowed <= 1);
+        BUG_ON(!p->se.on_rq);
+        BUG_ON(!rt_task(p));
+        return p;
+}
 /*
 * If the current CPU has more than one RT task, see if the non
 * running task can migrate over to a CPU that is running a task
@@ -1092,13 +1279,11 @@ static int push_rt_task(struct rq *rq)
 {
        struct task_struct *next_task;
        struct rq *lowest_rq;
-        int ret = 0;
-        int paranoid = RT_MAX_TRIES;
        if (!rq->rt.overloaded)
                return 0;
-        next_task = pick_next_highest_task_rt(rq, -1);
+        next_task = pick_next_pushable_task(rq);
        if (!next_task)
                return 0;
@@ -1127,16 +1312,34 @@ static int push_rt_task(struct rq *rq)
                struct task_struct *task;
                /*
                 * find lock_lowest_rq releases rq->lock
-                 * so it is possible that next_task has changed.
+                 * 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 +1350,12 @@ static int push_rt_task(struct rq *rq)
        double_unlock_balance(rq, lowest_rq);
-        ret = 1;
 out:
        put_task_struct(next_task);
-        return ret;
+        return 1;
 }
-/*
- * TODO: Currently we just use the second highest prio task on
- *       the queue, and stop when it can't migrate (or there's
- *       no more RT tasks).  There may be a case where a lower
- *       priority RT task has a different affinity than the
- *       higher RT task. In this case the lower RT task could
- *       possibly be able to migrate where as the higher priority
- *       RT task could not.  We currently ignore this issue.
- *       Enhancements are welcome!
- */
 static void push_rt_tasks(struct rq *rq)
 {
        /* push_rt_task will return true if it moved an RT */
@@ -1174,33 +1366,35 @@ static void push_rt_tasks(struct rq *rq)
 static int pull_rt_task(struct rq *this_rq)
 {
        int this_cpu = this_rq->cpu, ret = 0, cpu;
-        struct task_struct *p, *next;
+        struct task_struct *p;
        struct rq *src_rq;
        if (likely(!rt_overloaded(this_rq)))
                return 0;
-        next = pick_next_task_rt(this_rq);
        for_each_cpu(cpu, this_rq->rd->rto_mask) {
                if (this_cpu == cpu)
                        continue;
                src_rq = cpu_rq(cpu);
+                /*
+                 * Don't bother taking the src_rq->lock if the next highest
+                 * task is known to be lower-priority than our current task.
+                 * This may look racy, but if this value is about to go
+                 * logically higher, the src_rq will push this task away.
+                 * And if its going logically lower, we do not care
+                 */
+                if (src_rq->rt.highest_prio.next >=
+                    this_rq->rt.highest_prio.curr)
+                        continue;
                /*
                 * We can potentially drop this_rq's lock in
                 * double_lock_balance, and another CPU could
-                 * steal our next task - hence we must cause
+                 * 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 +1408,7 @@ static int pull_rt_task(struct rq *this_rq)
                 * Do we have an RT task that preempts
                 * the to-be-scheduled task?
                 */
-                if (p && (!next || (p->prio < next->prio))) {
+                if (p && (p->prio < this_rq->rt.highest_prio.curr)) {
                        WARN_ON(p == src_rq->curr);
                        WARN_ON(!p->se.on_rq);
@@ -1224,12 +1418,9 @@ static int pull_rt_task(struct rq *this_rq)
                         * This is just that p is wakeing up and hasn't
                         * had a chance to schedule. We only pull
                         * p if it is lower in priority than the
-                         * current task on the run queue or
+                         * 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 +1433,7 @@ static int pull_rt_task(struct rq *this_rq)
                         * case there's an even higher prio task
                         * in another runqueue. (low likelyhood
                         * but possible)
-                         *
-                         * Update next so that we won't pick a task
-                         * on another cpu with a priority lower (or equal)
-                         * than the one we just picked.
                         */
-                        next = p;
                }
 skip:
                double_unlock_balance(this_rq, src_rq);
@@ -1260,24 +1445,27 @@ static int pull_rt_task(struct rq *this_rq)
 static void pre_schedule_rt(struct rq *rq, struct task_struct *prev)
 {
        /* Try to pull RT tasks here if we lower this rq's prio */
-        if (unlikely(rt_task(prev)) && rq->rt.highest_prio > prev->prio)
+        if (unlikely(rt_task(prev)) && rq->rt.highest_prio.curr > prev->prio)
                pull_rt_task(rq);
 }
+/*
+ * assumes rq->lock is held
+ */
+static int needs_post_schedule_rt(struct rq *rq)
+{
+        return has_pushable_tasks(rq);
+}
 static void post_schedule_rt(struct rq *rq)
 {
        /*
-         * If we have more than one rt_task queued, then
+         * 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 +1476,8 @@ static void task_wake_up_rt(struct rq *rq, struct task_struct *p)
 {
        if (!task_running(rq, p) &&
            !test_tsk_need_resched(rq->curr) &&
-            rq->rt.overloaded)
+            has_pushable_tasks(rq) &&
+            p->rt.nr_cpus_allowed > 1)
                push_rt_tasks(rq);
 }
@@ -1324,6 +1513,24 @@ static void set_cpus_allowed_rt(struct task_struct *p,
        if (p->se.on_rq && (weight != p->rt.nr_cpus_allowed)) {
                struct rq *rq = task_rq(p);
+                if (!task_current(rq, p)) {
+                        /*
+                         * Make sure we dequeue this task from the pushable list
+                         * before going further.  It will either remain off of
+                         * the list because we are no longer pushable, or it
+                         * will be requeued.
+                         */
+                        if (p->rt.nr_cpus_allowed > 1)
+                                dequeue_pushable_task(rq, p);
+                        /*
+                         * Requeue if our weight is changing and still > 1
+                         */
+                        if (weight > 1)
+                                enqueue_pushable_task(rq, p);
+                }
                if ((p->rt.nr_cpus_allowed <= 1) && (weight > 1)) {
                        rq->rt.rt_nr_migratory++;
                } else if ((p->rt.nr_cpus_allowed > 1) && (weight <= 1)) {
@@ -1331,7 +1538,7 @@ static void set_cpus_allowed_rt(struct task_struct *p,
                        rq->rt.rt_nr_migratory--;
                }
-                update_rt_migration(rq);
+                update_rt_migration(&rq->rt);
        }
        cpumask_copy(&p->cpus_allowed, new_mask);
@@ -1346,7 +1553,7 @@ static void rq_online_rt(struct rq *rq)
        __enable_runtime(rq);
-        cpupri_set(&rq->rd->cpupri, rq->cpu, rq->rt.highest_prio);
+        cpupri_set(&rq->rd->cpupri, rq->cpu, rq->rt.highest_prio.curr);
 }
 /* Assumes rq->lock is held */
@@ -1438,7 +1645,7 @@ static void prio_changed_rt(struct rq *rq, struct task_struct *p,
                 * can release the rq lock and p could migrate.
                 * Only reschedule if p is still on the same runqueue.
                 */
-                if (p->prio > rq->rt.highest_prio && rq->curr == p)
+                if (p->prio > rq->rt.highest_prio.curr && rq->curr == p)
                        resched_task(p);
 #else
                /* For UP simply resched on drop of prio */
@@ -1509,6 +1716,9 @@ static void set_curr_task_rt(struct rq *rq)
        struct task_struct *p = rq->curr;
        p->se.exec_start = rq->clock;
+        /* The running task is never eligible for pushing */
+        dequeue_pushable_task(rq, p);
 }
 static const struct sched_class rt_sched_class = {
@@ -1531,6 +1741,7 @@ static const struct sched_class rt_sched_class = {
        .rq_online              = rq_online_rt,
        .rq_offline             = rq_offline_rt,
        .pre_schedule           = pre_schedule_rt,
+        .needs_post_schedule    = needs_post_schedule_rt,
        .post_schedule          = post_schedule_rt,
        .task_wake_up           = task_wake_up_rt,
        .switched_from          = switched_from_rt,
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index f2773b5d1226..8ab0cef8ecab 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -296,6 +296,7 @@ sched_info_switch(struct task_struct *prev, struct task_struct *next)
 static inline void account_group_user_time(struct task_struct *tsk,
                                           cputime_t cputime)
 {
+        struct task_cputime *times;
        struct signal_struct *sig;
        /* tsk == current, ensure it is safe to use ->signal */
@@ -303,13 +304,11 @@ static inline void account_group_user_time(struct task_struct *tsk,
                return;
        sig = tsk->signal;
-        if (sig->cputime.totals) {
+        times = &sig->cputime.totals;
-                struct task_cputime *times;
-                times = per_cpu_ptr(sig->cputime.totals, get_cpu());
+        spin_lock(&times->lock);
-                times->utime = cputime_add(times->utime, cputime);
+        times->utime = cputime_add(times->utime, cputime);
-                put_cpu_no_resched();
+        spin_unlock(&times->lock);
-        }
 }
 /**
@@ -325,6 +324,7 @@ static inline void account_group_user_time(struct task_struct *tsk,
 static inline void account_group_system_time(struct task_struct *tsk,
                                             cputime_t cputime)
 {
+        struct task_cputime *times;
        struct signal_struct *sig;
        /* tsk == current, ensure it is safe to use ->signal */
@@ -332,13 +332,11 @@ static inline void account_group_system_time(struct task_struct *tsk,
                return;
        sig = tsk->signal;
-        if (sig->cputime.totals) {
+        times = &sig->cputime.totals;
-                struct task_cputime *times;
-                times = per_cpu_ptr(sig->cputime.totals, get_cpu());
+        spin_lock(&times->lock);
-                times->stime = cputime_add(times->stime, cputime);
+        times->stime = cputime_add(times->stime, cputime);
-                put_cpu_no_resched();
+        spin_unlock(&times->lock);
-        }
 }
 /**
@@ -354,6 +352,7 @@ static inline void account_group_system_time(struct task_struct *tsk,
 static inline void account_group_exec_runtime(struct task_struct *tsk,
                                              unsigned long long ns)
 {
+        struct task_cputime *times;
        struct signal_struct *sig;
        sig = tsk->signal;
@@ -362,11 +361,9 @@ static inline void account_group_exec_runtime(struct task_struct *tsk,
        if (unlikely(!sig))
                return;
-        if (sig->cputime.totals) {
+        times = &sig->cputime.totals;
-                struct task_cputime *times;
-                times = per_cpu_ptr(sig->cputime.totals, get_cpu());
+        spin_lock(&times->lock);
-                times->sum_exec_runtime += ns;
+        times->sum_exec_runtime += ns;
-                put_cpu_no_resched();
+        spin_unlock(&times->lock);
-        }
 }
diff --git a/kernel/signal.c b/kernel/signal.c
index 3152ac3b62e2..b6b36768b758 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -909,7 +909,9 @@ static void print_fatal_signal(struct pt_regs *regs, int signr)
        }
 #endif
        printk("\n");
+        preempt_disable();
        show_regs(regs);
+        preempt_enable();
 }
 static int __init setup_print_fatal_signals(char *str)
@@ -1961,7 +1963,7 @@ EXPORT_SYMBOL(unblock_all_signals);
 * System call entry points.
 */
-asmlinkage long sys_restart_syscall(void)
+SYSCALL_DEFINE0(restart_syscall)
 {
        struct restart_block *restart = &current_thread_info()->restart_block;
        return restart->fn(restart);
@@ -2014,8 +2016,8 @@ int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
        return error;
 }
-asmlinkage long
+SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
-sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
+                sigset_t __user *, oset, size_t, sigsetsize)
 {
        int error = -EINVAL;
        sigset_t old_set, new_set;
@@ -2074,8 +2076,7 @@ out:
        return error;
 }       
-asmlinkage long
+SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
-sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
 {
        return do_sigpending(set, sigsetsize);
 }
@@ -2146,11 +2147,9 @@ int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
 #endif
-asmlinkage long
+SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
-sys_rt_sigtimedwait(const sigset_t __user *uthese,
+                siginfo_t __user *, uinfo, const struct timespec __user *, uts,
-                    siginfo_t __user *uinfo,
+                size_t, sigsetsize)
-                    const struct timespec __user *uts,
-                    size_t sigsetsize)
 {
        int ret, sig;
        sigset_t these;
@@ -2223,8 +2222,7 @@ sys_rt_sigtimedwait(const sigset_t __user *uthese,
        return ret;
 }
-asmlinkage long
+SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
-sys_kill(pid_t pid, int sig)
 {
        struct siginfo info;
@@ -2283,7 +2281,7 @@ static int do_tkill(pid_t tgid, pid_t pid, int sig)
 *  exists but it's not belonging to the target process anymore. This
 *  method solves the problem of threads exiting and PIDs getting reused.
 */
-asmlinkage long sys_tgkill(pid_t tgid, pid_t pid, int sig)
+SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
 {
        /* This is only valid for single tasks */
        if (pid <= 0 || tgid <= 0)
@@ -2295,8 +2293,7 @@ asmlinkage long sys_tgkill(pid_t tgid, pid_t pid, int sig)
 /*
 *  Send a signal to only one task, even if it's a CLONE_THREAD task.
 */
-asmlinkage long
+SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
-sys_tkill(pid_t pid, int sig)
 {
        /* This is only valid for single tasks */
        if (pid <= 0)
@@ -2305,8 +2302,8 @@ sys_tkill(pid_t pid, int sig)
        return do_tkill(0, pid, sig);
 }
-asmlinkage long
+SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
-sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo)
+                siginfo_t __user *, uinfo)
 {
        siginfo_t info;
@@ -2434,8 +2431,7 @@ out:
 #ifdef __ARCH_WANT_SYS_SIGPENDING
-asmlinkage long
+SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
-sys_sigpending(old_sigset_t __user *set)
 {
        return do_sigpending(set, sizeof(*set));
 }
@@ -2446,8 +2442,8 @@ sys_sigpending(old_sigset_t __user *set)
 /* Some platforms have their own version with special arguments others
   support only sys_rt_sigprocmask.  */
-asmlinkage long
+SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
-sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
+                old_sigset_t __user *, oset)
 {
        int error;
        old_sigset_t old_set, new_set;
@@ -2497,11 +2493,10 @@ out:
 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
-asmlinkage long
+SYSCALL_DEFINE4(rt_sigaction, int, sig,
-sys_rt_sigaction(int sig,
+                const struct sigaction __user *, act,
-                 const struct sigaction __user *act,
+                struct sigaction __user *, oact,
-                 struct sigaction __user *oact,
+                size_t, sigsetsize)
-                 size_t sigsetsize)
 {
        struct k_sigaction new_sa, old_sa;
        int ret = -EINVAL;
@@ -2531,15 +2526,13 @@ out:
 /*
 * For backwards compatibility.  Functionality superseded by sigprocmask.
 */
-asmlinkage long
+SYSCALL_DEFINE0(sgetmask)
-sys_sgetmask(void)
 {
        /* SMP safe */
        return current->blocked.sig[0];
 }
-asmlinkage long
+SYSCALL_DEFINE1(ssetmask, int, newmask)
-sys_ssetmask(int newmask)
 {
        int old;
@@ -2559,8 +2552,7 @@ sys_ssetmask(int newmask)
 /*
 * For backwards compatibility.  Functionality superseded by sigaction.
 */
-asmlinkage unsigned long
+SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
-sys_signal(int sig, __sighandler_t handler)
 {
        struct k_sigaction new_sa, old_sa;
        int ret;
@@ -2577,8 +2569,7 @@ sys_signal(int sig, __sighandler_t handler)
 #ifdef __ARCH_WANT_SYS_PAUSE
-asmlinkage long
+SYSCALL_DEFINE0(pause)
-sys_pause(void)
 {
        current->state = TASK_INTERRUPTIBLE;
        schedule();
@@ -2588,7 +2579,7 @@ sys_pause(void)
 #endif
 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
-asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
+SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
 {
        sigset_t newset;
diff --git a/kernel/smp.c b/kernel/smp.c
index 5cfa0e5e3e88..bbedbb7efe32 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -18,6 +18,7 @@ __cacheline_aligned_in_smp DEFINE_SPINLOCK(call_function_lock);
 enum {
        CSD_FLAG_WAIT           = 0x01,
        CSD_FLAG_ALLOC          = 0x02,
+        CSD_FLAG_LOCK           = 0x04,
 };
 struct call_function_data {
@@ -186,6 +187,9 @@ void generic_smp_call_function_single_interrupt(void)
                        if (data_flags & CSD_FLAG_WAIT) {
                                smp_wmb();
                                data->flags &= ~CSD_FLAG_WAIT;
+                        } else if (data_flags & CSD_FLAG_LOCK) {
+                                smp_wmb();
+                                data->flags &= ~CSD_FLAG_LOCK;
                        } else if (data_flags & CSD_FLAG_ALLOC)
                                kfree(data);
                }
@@ -196,6 +200,8 @@ void generic_smp_call_function_single_interrupt(void)
        }
 }
+static DEFINE_PER_CPU(struct call_single_data, csd_data);
 /*
 * smp_call_function_single - Run a function on a specific CPU
 * @func: The function to run. This must be fast and non-blocking.
@@ -224,14 +230,38 @@ int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
                func(info);
                local_irq_restore(flags);
        } else if ((unsigned)cpu < nr_cpu_ids && cpu_online(cpu)) {
-                struct call_single_data *data = NULL;
+                struct call_single_data *data;
                if (!wait) {
+                        /*
+                         * We are calling a function on a single CPU
+                         * and we are not going to wait for it to finish.
+                         * We first try to allocate the data, but if we
+                         * fail, we fall back to use a per cpu data to pass
+                         * the information to that CPU. Since all callers
+                         * of this code will use the same data, we must
+                         * synchronize the callers to prevent a new caller
+                         * from corrupting the data before the callee
+                         * can access it.
+                         *
+                         * The CSD_FLAG_LOCK is used to let us know when
+                         * the IPI handler is done with the data.
+                         * The first caller will set it, and the callee
+                         * will clear it. The next caller must wait for
+                         * it to clear before we set it again. This
+                         * will make sure the callee is done with the
+                         * data before a new caller will use it.
+                         */
                        data = kmalloc(sizeof(*data), GFP_ATOMIC);
                        if (data)
                                data->flags = CSD_FLAG_ALLOC;
-                }
+                        else {
-                if (!data) {
+                                data = &per_cpu(csd_data, me);
+                                while (data->flags & CSD_FLAG_LOCK)
+                                        cpu_relax();
+                                data->flags = CSD_FLAG_LOCK;
+                        }
+                } else {
                        data = &d;
                        data->flags = CSD_FLAG_WAIT;
                }
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index d9188c66278a..85d5a2455103 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -16,6 +16,7 @@
 #include <linux/lockdep.h>
 #include <linux/notifier.h>
 #include <linux/module.h>
+#include <linux/sysctl.h>
 #include <asm/irq_regs.h>
@@ -88,6 +89,14 @@ void touch_all_softlockup_watchdogs(void)
 }
 EXPORT_SYMBOL(touch_all_softlockup_watchdogs);
+int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
+                             struct file *filp, void __user *buffer,
+                             size_t *lenp, loff_t *ppos)
+{
+        touch_all_softlockup_watchdogs();
+        return proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos);
+}
 /*
 * This callback runs from the timer interrupt, and checks
 * whether the watchdog thread has hung or not:
diff --git a/kernel/sys.c b/kernel/sys.c
index 763c3c17ded3..e7dc0e10a485 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -143,7 +143,7 @@ out:
        return error;
 }
-asmlinkage long sys_setpriority(int which, int who, int niceval)
+SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
 {
        struct task_struct *g, *p;
        struct user_struct *user;
@@ -208,7 +208,7 @@ out:
 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
 * to stay compatible.
 */
-asmlinkage long sys_getpriority(int which, int who)
+SYSCALL_DEFINE2(getpriority, int, which, int, who)
 {
        struct task_struct *g, *p;
        struct user_struct *user;
@@ -355,7 +355,8 @@ EXPORT_SYMBOL_GPL(kernel_power_off);
 *
 * reboot doesn't sync: do that yourself before calling this.
 */
-asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user * arg)
+SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
+                void __user *, arg)
 {
        char buffer[256];
@@ -478,7 +479,7 @@ void ctrl_alt_del(void)
 * SMP: There are not races, the GIDs are checked only by filesystem
 *      operations (as far as semantic preservation is concerned).
 */
-asmlinkage long sys_setregid(gid_t rgid, gid_t egid)
+SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
 {
        const struct cred *old;
        struct cred *new;
@@ -529,7 +530,7 @@ error:
 *
 * SMP: Same implicit races as above.
 */
-asmlinkage long sys_setgid(gid_t gid)
+SYSCALL_DEFINE1(setgid, gid_t, gid)
 {
        const struct cred *old;
        struct cred *new;
@@ -597,7 +598,7 @@ static int set_user(struct cred *new)
 * 100% compatible with BSD.  A program which uses just setuid() will be
 * 100% compatible with POSIX with saved IDs. 
 */
-asmlinkage long sys_setreuid(uid_t ruid, uid_t euid)
+SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
 {
        const struct cred *old;
        struct cred *new;
@@ -661,7 +662,7 @@ error:
 * will allow a root program to temporarily drop privileges and be able to
 * regain them by swapping the real and effective uid.  
 */
-asmlinkage long sys_setuid(uid_t uid)
+SYSCALL_DEFINE1(setuid, uid_t, uid)
 {
        const struct cred *old;
        struct cred *new;
@@ -705,7 +706,7 @@ error:
 * This function implements a generic ability to update ruid, euid,
 * and suid.  This allows you to implement the 4.4 compatible seteuid().
 */
-asmlinkage long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
+SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
 {
        const struct cred *old;
        struct cred *new;
@@ -756,7 +757,7 @@ error:
        return retval;
 }
-asmlinkage long sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __user *suid)
+SYSCALL_DEFINE3(getresuid, uid_t __user *, ruid, uid_t __user *, euid, uid_t __user *, suid)
 {
        const struct cred *cred = current_cred();
        int retval;
@@ -771,7 +772,7 @@ asmlinkage long sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __us
 /*
 * Same as above, but for rgid, egid, sgid.
 */
-asmlinkage long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
+SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
 {
        const struct cred *old;
        struct cred *new;
@@ -814,7 +815,7 @@ error:
        return retval;
 }
-asmlinkage long sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __user *sgid)
+SYSCALL_DEFINE3(getresgid, gid_t __user *, rgid, gid_t __user *, egid, gid_t __user *, sgid)
 {
        const struct cred *cred = current_cred();
        int retval;
@@ -833,7 +834,7 @@ asmlinkage long sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __us
 * whatever uid it wants to). It normally shadows "euid", except when
 * explicitly set by setfsuid() or for access..
 */
-asmlinkage long sys_setfsuid(uid_t uid)
+SYSCALL_DEFINE1(setfsuid, uid_t, uid)
 {
        const struct cred *old;
        struct cred *new;
@@ -870,7 +871,7 @@ change_okay:
 /*
 * Samma på svenska..
 */
-asmlinkage long sys_setfsgid(gid_t gid)
+SYSCALL_DEFINE1(setfsgid, gid_t, gid)
 {
        const struct cred *old;
        struct cred *new;
@@ -919,7 +920,7 @@ void do_sys_times(struct tms *tms)
        tms->tms_cstime = cputime_to_clock_t(cstime);
 }
-asmlinkage long sys_times(struct tms __user * tbuf)
+SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
 {
        if (tbuf) {
                struct tms tmp;
@@ -944,7 +945,7 @@ asmlinkage long sys_times(struct tms __user * tbuf)
 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
 * LBT 04.03.94
 */
-asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
+SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid)
 {
        struct task_struct *p;
        struct task_struct *group_leader = current->group_leader;
@@ -1015,7 +1016,7 @@ out:
        return err;
 }
-asmlinkage long sys_getpgid(pid_t pid)
+SYSCALL_DEFINE1(getpgid, pid_t, pid)
 {
        struct task_struct *p;
        struct pid *grp;
@@ -1045,14 +1046,14 @@ out:
 #ifdef __ARCH_WANT_SYS_GETPGRP
-asmlinkage long sys_getpgrp(void)
+SYSCALL_DEFINE0(getpgrp)
 {
        return sys_getpgid(0);
 }
 #endif
-asmlinkage long sys_getsid(pid_t pid)
+SYSCALL_DEFINE1(getsid, pid_t, pid)
 {
        struct task_struct *p;
        struct pid *sid;
@@ -1080,7 +1081,7 @@ out:
        return retval;
 }
-asmlinkage long sys_setsid(void)
+SYSCALL_DEFINE0(setsid)
 {
        struct task_struct *group_leader = current->group_leader;
        struct pid *sid = task_pid(group_leader);
@@ -1311,7 +1312,7 @@ int set_current_groups(struct group_info *group_info)
 EXPORT_SYMBOL(set_current_groups);
-asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist)
+SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)
 {
        const struct cred *cred = current_cred();
        int i;
@@ -1340,7 +1341,7 @@ out:
 *      without another task interfering.
 */
 
-asmlinkage long sys_setgroups(int gidsetsize, gid_t __user *grouplist)
+SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)
 {
        struct group_info *group_info;
        int retval;
@@ -1394,7 +1395,7 @@ EXPORT_SYMBOL(in_egroup_p);
 DECLARE_RWSEM(uts_sem);
-asmlinkage long sys_newuname(struct new_utsname __user * name)
+SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
 {
        int errno = 0;
@@ -1405,7 +1406,7 @@ asmlinkage long sys_newuname(struct new_utsname __user * name)
        return errno;
 }
-asmlinkage long sys_sethostname(char __user *name, int len)
+SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
 {
        int errno;
        char tmp[__NEW_UTS_LEN];
@@ -1429,7 +1430,7 @@ asmlinkage long sys_sethostname(char __user *name, int len)
 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
-asmlinkage long sys_gethostname(char __user *name, int len)
+SYSCALL_DEFINE2(gethostname, char __user *, name, int, len)
 {
        int i, errno;
        struct new_utsname *u;
@@ -1454,7 +1455,7 @@ asmlinkage long sys_gethostname(char __user *name, int len)
 * Only setdomainname; getdomainname can be implemented by calling
 * uname()
 */
-asmlinkage long sys_setdomainname(char __user *name, int len)
+SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len)
 {
        int errno;
        char tmp[__NEW_UTS_LEN];
@@ -1477,7 +1478,7 @@ asmlinkage long sys_setdomainname(char __user *name, int len)
        return errno;
 }
-asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit __user *rlim)
+SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
 {
        if (resource >= RLIM_NLIMITS)
                return -EINVAL;
@@ -1496,7 +1497,8 @@ asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit __user *rlim)
 *      Back compatibility for getrlimit. Needed for some apps.
 */
 
-asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim)
+SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
+                struct rlimit __user *, rlim)
 {
        struct rlimit x;
        if (resource >= RLIM_NLIMITS)
@@ -1514,7 +1516,7 @@ asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *r
 #endif
-asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit __user *rlim)
+SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
 {
        struct rlimit new_rlim, *old_rlim;
        int retval;
@@ -1687,7 +1689,7 @@ int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
        return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
 }
-asmlinkage long sys_getrusage(int who, struct rusage __user *ru)
+SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
 {
        if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
            who != RUSAGE_THREAD)
@@ -1695,14 +1697,14 @@ asmlinkage long sys_getrusage(int who, struct rusage __user *ru)
        return getrusage(current, who, ru);
 }
-asmlinkage long sys_umask(int mask)
+SYSCALL_DEFINE1(umask, int, mask)
 {
        mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
        return mask;
 }
-asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
+SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
-                          unsigned long arg4, unsigned long arg5)
+                unsigned long, arg4, unsigned long, arg5)
 {
        struct task_struct *me = current;
        unsigned char comm[sizeof(me->comm)];
@@ -1815,8 +1817,8 @@ asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
        return error;
 }
-asmlinkage long sys_getcpu(unsigned __user *cpup, unsigned __user *nodep,
+SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep,
-                           struct getcpu_cache __user *unused)
+                struct getcpu_cache __user *, unused)
 {
        int err = 0;
        int cpu = raw_smp_processor_id();
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index e14a23281707..27dad2967387 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -131,6 +131,7 @@ cond_syscall(sys_io_destroy);
 cond_syscall(sys_io_submit);
 cond_syscall(sys_io_cancel);
 cond_syscall(sys_io_getevents);
+cond_syscall(sys_syslog);
 /* arch-specific weak syscall entries */
 cond_syscall(sys_pciconfig_read);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 89d74436318c..790f9d785663 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -144,6 +144,7 @@ extern int acct_parm[];
 #ifdef CONFIG_IA64
 extern int no_unaligned_warning;
+extern int unaligned_dump_stack;
 #endif
 #ifdef CONFIG_RT_MUTEXES
@@ -781,6 +782,14 @@ static struct ctl_table kern_table[] = {
                .mode           = 0644,
                .proc_handler   = &proc_dointvec,
        },
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "unaligned-dump-stack",
+                .data           = &unaligned_dump_stack,
+                .maxlen         = sizeof (int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
 #endif
 #ifdef CONFIG_DETECT_SOFTLOCKUP
        {
@@ -800,7 +809,7 @@ static struct ctl_table kern_table[] = {
                .data           = &softlockup_thresh,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-                .proc_handler   = &proc_dointvec_minmax,
+                .proc_handler   = &proc_dosoftlockup_thresh,
                .strategy       = &sysctl_intvec,
                .extra1         = &neg_one,
                .extra2         = &sixty,
@@ -1688,7 +1697,7 @@ int do_sysctl(int __user *name, int nlen, void __user *oldval, size_t __user *ol
        return error;
 }
-asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
+SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
 {
        struct __sysctl_args tmp;
        int error;
@@ -2989,7 +2998,7 @@ int sysctl_ms_jiffies(struct ctl_table *table,
 #else /* CONFIG_SYSCTL_SYSCALL */
-asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
+SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
 {
        struct __sysctl_args tmp;
        int error;
diff --git a/kernel/time.c b/kernel/time.c
index 4886e3ce83a4..29511943871a 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -60,7 +60,7 @@ EXPORT_SYMBOL(sys_tz);
 * why not move it into the appropriate arch directory (for those
 * architectures that need it).
 */
-asmlinkage long sys_time(time_t __user * tloc)
+SYSCALL_DEFINE1(time, time_t __user *, tloc)
 {
        time_t i = get_seconds();
@@ -79,7 +79,7 @@ asmlinkage long sys_time(time_t __user * tloc)
 * architectures that need it).
 */
-asmlinkage long sys_stime(time_t __user *tptr)
+SYSCALL_DEFINE1(stime, time_t __user *, tptr)
 {
        struct timespec tv;
        int err;
@@ -99,8 +99,8 @@ asmlinkage long sys_stime(time_t __user *tptr)
 #endif /* __ARCH_WANT_SYS_TIME */
-asmlinkage long sys_gettimeofday(struct timeval __user *tv,
+SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
-                                 struct timezone __user *tz)
+                struct timezone __user *, tz)
 {
        if (likely(tv != NULL)) {
                struct timeval ktv;
@@ -184,8 +184,8 @@ int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
        return 0;
 }
-asmlinkage long sys_settimeofday(struct timeval __user *tv,
+SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
-                                struct timezone __user *tz)
+                struct timezone __user *, tz)
 {
        struct timeval user_tv;
        struct timespec new_ts;
@@ -205,7 +205,7 @@ asmlinkage long sys_settimeofday(struct timeval __user *tv,
        return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 }
-asmlinkage long sys_adjtimex(struct timex __user *txc_p)
+SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
 {
        struct timex txc;               /* Local copy of parameter */
        int ret;
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 63e05d423a09..21a5ca849514 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -274,6 +274,21 @@ out_bc:
 }
 /*
+ * Transfer the do_timer job away from a dying cpu.
+ *
+ * Called with interrupts disabled.
+ */
+static void tick_handover_do_timer(int *cpup)
+{
+        if (*cpup == tick_do_timer_cpu) {
+                int cpu = cpumask_first(cpu_online_mask);
+                tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
+                        TICK_DO_TIMER_NONE;
+        }
+}
+/*
 * Shutdown an event device on a given cpu:
 *
 * This is called on a life CPU, when a CPU is dead. So we cannot
@@ -297,13 +312,6 @@ static void tick_shutdown(unsigned int *cpup)
                clockevents_exchange_device(dev, NULL);
                td->evtdev = NULL;
        }
-        /* Transfer the do_timer job away from this cpu */
-        if (*cpup == tick_do_timer_cpu) {
-                int cpu = cpumask_first(cpu_online_mask);
-                tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
-                        TICK_DO_TIMER_NONE;
-        }
        spin_unlock_irqrestore(&tick_device_lock, flags);
 }
@@ -357,6 +365,10 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason,
                tick_broadcast_oneshot_control(reason);
                break;
+        case CLOCK_EVT_NOTIFY_CPU_DYING:
+                tick_handover_do_timer(dev);
+                break;
        case CLOCK_EVT_NOTIFY_CPU_DEAD:
                tick_shutdown_broadcast_oneshot(dev);
                tick_shutdown_broadcast(dev);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 1b6c05bd0d0a..d3f1ef4d5cbe 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -134,7 +134,7 @@ __setup("nohz=", setup_tick_nohz);
 * value. We do this unconditionally on any cpu, as we don't know whether the
 * cpu, which has the update task assigned is in a long sleep.
 */
-void tick_nohz_update_jiffies(void)
+static void tick_nohz_update_jiffies(void)
 {
        int cpu = smp_processor_id();
        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
diff --git a/kernel/timer.c b/kernel/timer.c
index dee3f641a7a7..13dd64fe143d 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1129,7 +1129,7 @@ void do_timer(unsigned long ticks)
 * For backwards compatibility?  This can be done in libc so Alpha
 * and all newer ports shouldn't need it.
 */
-asmlinkage unsigned long sys_alarm(unsigned int seconds)
+SYSCALL_DEFINE1(alarm, unsigned int, seconds)
 {
        return alarm_setitimer(seconds);
 }
@@ -1152,7 +1152,7 @@ asmlinkage unsigned long sys_alarm(unsigned int seconds)
 *
 * This is SMP safe as current->tgid does not change.
 */
-asmlinkage long sys_getpid(void)
+SYSCALL_DEFINE0(getpid)
 {
        return task_tgid_vnr(current);
 }
@@ -1163,7 +1163,7 @@ asmlinkage long sys_getpid(void)
 * value of ->real_parent under rcu_read_lock(), see
 * release_task()->call_rcu(delayed_put_task_struct).
 */
-asmlinkage long sys_getppid(void)
+SYSCALL_DEFINE0(getppid)
 {
        int pid;
@@ -1174,25 +1174,25 @@ asmlinkage long sys_getppid(void)
        return pid;
 }
-asmlinkage long sys_getuid(void)
+SYSCALL_DEFINE0(getuid)
 {
        /* Only we change this so SMP safe */
        return current_uid();
 }
-asmlinkage long sys_geteuid(void)
+SYSCALL_DEFINE0(geteuid)
 {
        /* Only we change this so SMP safe */
        return current_euid();
 }
-asmlinkage long sys_getgid(void)
+SYSCALL_DEFINE0(getgid)
 {
        /* Only we change this so SMP safe */
        return current_gid();
 }
-asmlinkage long sys_getegid(void)
+SYSCALL_DEFINE0(getegid)
 {
        /* Only we change this so SMP safe */
        return  current_egid();
@@ -1308,7 +1308,7 @@ signed long __sched schedule_timeout_uninterruptible(signed long timeout)
 EXPORT_SYMBOL(schedule_timeout_uninterruptible);
 /* Thread ID - the internal kernel "pid" */
-asmlinkage long sys_gettid(void)
+SYSCALL_DEFINE0(gettid)
 {
        return task_pid_vnr(current);
 }
@@ -1400,7 +1400,7 @@ out:
        return 0;
 }
-asmlinkage long sys_sysinfo(struct sysinfo __user *info)
+SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info)
 {
        struct sysinfo val;
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 2f32969c09df..7dcf6e9f2b04 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -17,6 +17,7 @@
 #include <linux/clocksource.h>
 #include <linux/kallsyms.h>
 #include <linux/seq_file.h>
+#include <linux/suspend.h>
 #include <linux/debugfs.h>
 #include <linux/hardirq.h>
 #include <linux/kthread.h>
@@ -1965,6 +1966,7 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static atomic_t ftrace_graph_active;
+static struct notifier_block ftrace_suspend_notifier;
 int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)
 {
@@ -2043,6 +2045,27 @@ static int start_graph_tracing(void)
        return ret;
 }
+/*
+ * Hibernation protection.
+ * The state of the current task is too much unstable during
+ * suspend/restore to disk. We want to protect against that.
+ */
+static int
+ftrace_suspend_notifier_call(struct notifier_block *bl, unsigned long state,
+                                                        void *unused)
+{
+        switch (state) {
+        case PM_HIBERNATION_PREPARE:
+                pause_graph_tracing();
+                break;
+        case PM_POST_HIBERNATION:
+                unpause_graph_tracing();
+                break;
+        }
+        return NOTIFY_DONE;
+}
 int register_ftrace_graph(trace_func_graph_ret_t retfunc,
                        trace_func_graph_ent_t entryfunc)
 {
@@ -2050,6 +2073,9 @@ int register_ftrace_graph(trace_func_graph_ret_t retfunc,
        mutex_lock(&ftrace_sysctl_lock);
+        ftrace_suspend_notifier.notifier_call = ftrace_suspend_notifier_call;
+        register_pm_notifier(&ftrace_suspend_notifier);
        atomic_inc(&ftrace_graph_active);
        ret = start_graph_tracing();
        if (ret) {
@@ -2075,6 +2101,7 @@ void unregister_ftrace_graph(void)
        ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
        ftrace_graph_entry = ftrace_graph_entry_stub;
        ftrace_shutdown(FTRACE_STOP_FUNC_RET);
+        unregister_pm_notifier(&ftrace_suspend_notifier);
        mutex_unlock(&ftrace_sysctl_lock);
 }
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 8b0daf0662ef..bd38c5cfd8ad 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -246,7 +246,7 @@ static inline int test_time_stamp(u64 delta)
        return 0;
 }
-#define BUF_PAGE_SIZE (PAGE_SIZE - sizeof(struct buffer_data_page))
+#define BUF_PAGE_SIZE (PAGE_SIZE - offsetof(struct buffer_data_page, data))
 /*
 * head_page == tail_page && head == tail then buffer is empty.
@@ -1025,12 +1025,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                }
                if (next_page == head_page) {
-                        if (!(buffer->flags & RB_FL_OVERWRITE)) {
+                        if (!(buffer->flags & RB_FL_OVERWRITE))
-                                /* reset write */
-                                if (tail <= BUF_PAGE_SIZE)
-                                        local_set(&tail_page->write, tail);
                                goto out_unlock;
-                        }
                        /* tail_page has not moved yet? */
                        if (tail_page == cpu_buffer->tail_page) {
@@ -1105,6 +1101,10 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
        return event;
 out_unlock:
+        /* reset write */
+        if (tail <= BUF_PAGE_SIZE)
+                local_set(&tail_page->write, tail);
        __raw_spin_unlock(&cpu_buffer->lock);
        local_irq_restore(flags);
        return NULL;
@@ -2174,6 +2174,9 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
        cpu_buffer->overrun = 0;
        cpu_buffer->entries = 0;
+        cpu_buffer->write_stamp = 0;
+        cpu_buffer->read_stamp = 0;
 }
 /**
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index c580233add95..17bb88d86ac2 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -40,7 +40,7 @@
 #define TRACE_BUFFER_FLAGS      (RB_FL_OVERWRITE)
-unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
+unsigned long __read_mostly     tracing_max_latency;
 unsigned long __read_mostly     tracing_thresh;
 /*
@@ -3736,7 +3736,7 @@ static struct notifier_block trace_die_notifier = {
 * it if we decide to change what log level the ftrace dump
 * should be at.
 */
-#define KERN_TRACE              KERN_INFO
+#define KERN_TRACE              KERN_EMERG
 static void
 trace_printk_seq(struct trace_seq *s)
@@ -3770,6 +3770,7 @@ void ftrace_dump(void)
        dump_ran = 1;
        /* No turning back! */
+        tracing_off();
        ftrace_kill();
        for_each_tracing_cpu(cpu) {
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 7c2e326bbc8b..62a78d943534 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -380,6 +380,7 @@ static void stop_irqsoff_tracer(struct trace_array *tr)
 static void __irqsoff_tracer_init(struct trace_array *tr)
 {
+        tracing_max_latency = 0;
        irqsoff_trace = tr;
        /* make sure that the tracer is visible */
        smp_wmb();
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 43586b689e31..42ae1e77b6b3 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -333,6 +333,7 @@ static void stop_wakeup_tracer(struct trace_array *tr)
 static int wakeup_tracer_init(struct trace_array *tr)
 {
+        tracing_max_latency = 0;
        wakeup_trace = tr;
        start_wakeup_tracer(tr);
        return 0;
diff --git a/kernel/uid16.c b/kernel/uid16.c
index 2460c3199b5a..0314501688b9 100644
--- a/kernel/uid16.c
+++ b/kernel/uid16.c
@@ -17,7 +17,7 @@
 #include <asm/uaccess.h>
-asmlinkage long sys_chown16(const char __user * filename, old_uid_t user, old_gid_t group)
+SYSCALL_DEFINE3(chown16, const char __user *, filename, old_uid_t, user, old_gid_t, group)
 {
        long ret = sys_chown(filename, low2highuid(user), low2highgid(group));
        /* avoid REGPARM breakage on x86: */
@@ -25,7 +25,7 @@ asmlinkage long sys_chown16(const char __user * filename, old_uid_t user, old_gi
        return ret;
 }
-asmlinkage long sys_lchown16(const char __user * filename, old_uid_t user, old_gid_t group)
+SYSCALL_DEFINE3(lchown16, const char __user *, filename, old_uid_t, user, old_gid_t, group)
 {
        long ret = sys_lchown(filename, low2highuid(user), low2highgid(group));
        /* avoid REGPARM breakage on x86: */
@@ -33,7 +33,7 @@ asmlinkage long sys_lchown16(const char __user * filename, old_uid_t user, old_g
        return ret;
 }
-asmlinkage long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group)
+SYSCALL_DEFINE3(fchown16, unsigned int, fd, old_uid_t, user, old_gid_t, group)
 {
        long ret = sys_fchown(fd, low2highuid(user), low2highgid(group));
        /* avoid REGPARM breakage on x86: */
@@ -41,7 +41,7 @@ asmlinkage long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group)
        return ret;
 }
-asmlinkage long sys_setregid16(old_gid_t rgid, old_gid_t egid)
+SYSCALL_DEFINE2(setregid16, old_gid_t, rgid, old_gid_t, egid)
 {
        long ret = sys_setregid(low2highgid(rgid), low2highgid(egid));
        /* avoid REGPARM breakage on x86: */
@@ -49,7 +49,7 @@ asmlinkage long sys_setregid16(old_gid_t rgid, old_gid_t egid)
        return ret;
 }
-asmlinkage long sys_setgid16(old_gid_t gid)
+SYSCALL_DEFINE1(setgid16, old_gid_t, gid)
 {
        long ret = sys_setgid(low2highgid(gid));
        /* avoid REGPARM breakage on x86: */
@@ -57,7 +57,7 @@ asmlinkage long sys_setgid16(old_gid_t gid)
        return ret;
 }
-asmlinkage long sys_setreuid16(old_uid_t ruid, old_uid_t euid)
+SYSCALL_DEFINE2(setreuid16, old_uid_t, ruid, old_uid_t, euid)
 {
        long ret = sys_setreuid(low2highuid(ruid), low2highuid(euid));
        /* avoid REGPARM breakage on x86: */
@@ -65,7 +65,7 @@ asmlinkage long sys_setreuid16(old_uid_t ruid, old_uid_t euid)
        return ret;
 }
-asmlinkage long sys_setuid16(old_uid_t uid)
+SYSCALL_DEFINE1(setuid16, old_uid_t, uid)
 {
        long ret = sys_setuid(low2highuid(uid));
        /* avoid REGPARM breakage on x86: */
@@ -73,7 +73,7 @@ asmlinkage long sys_setuid16(old_uid_t uid)
        return ret;
 }
-asmlinkage long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid)
+SYSCALL_DEFINE3(setresuid16, old_uid_t, ruid, old_uid_t, euid, old_uid_t, suid)
 {
        long ret = sys_setresuid(low2highuid(ruid), low2highuid(euid),
                                 low2highuid(suid));
@@ -82,7 +82,7 @@ asmlinkage long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid)
        return ret;
 }
-asmlinkage long sys_getresuid16(old_uid_t __user *ruid, old_uid_t __user *euid, old_uid_t __user *suid)
+SYSCALL_DEFINE3(getresuid16, old_uid_t __user *, ruid, old_uid_t __user *, euid, old_uid_t __user *, suid)
 {
        const struct cred *cred = current_cred();
        int retval;
@@ -94,7 +94,7 @@ asmlinkage long sys_getresuid16(old_uid_t __user *ruid, old_uid_t __user *euid,
        return retval;
 }
-asmlinkage long sys_setresgid16(old_gid_t rgid, old_gid_t egid, old_gid_t sgid)
+SYSCALL_DEFINE3(setresgid16, old_gid_t, rgid, old_gid_t, egid, old_gid_t, sgid)
 {
        long ret = sys_setresgid(low2highgid(rgid), low2highgid(egid),
                                 low2highgid(sgid));
@@ -103,7 +103,8 @@ asmlinkage long sys_setresgid16(old_gid_t rgid, old_gid_t egid, old_gid_t sgid)
        return ret;
 }
-asmlinkage long sys_getresgid16(old_gid_t __user *rgid, old_gid_t __user *egid, old_gid_t __user *sgid)
+SYSCALL_DEFINE3(getresgid16, old_gid_t __user *, rgid, old_gid_t __user *, egid, old_gid_t __user *, sgid)
 {
        const struct cred *cred = current_cred();
        int retval;
@@ -115,7 +116,7 @@ asmlinkage long sys_getresgid16(old_gid_t __user *rgid, old_gid_t __user *egid,
        return retval;
 }
-asmlinkage long sys_setfsuid16(old_uid_t uid)
+SYSCALL_DEFINE1(setfsuid16, old_uid_t, uid)
 {
        long ret = sys_setfsuid(low2highuid(uid));
        /* avoid REGPARM breakage on x86: */
@@ -123,7 +124,7 @@ asmlinkage long sys_setfsuid16(old_uid_t uid)
        return ret;
 }
-asmlinkage long sys_setfsgid16(old_gid_t gid)
+SYSCALL_DEFINE1(setfsgid16, old_gid_t, gid)
 {
        long ret = sys_setfsgid(low2highgid(gid));
        /* avoid REGPARM breakage on x86: */
@@ -161,7 +162,7 @@ static int groups16_from_user(struct group_info *group_info,
        return 0;
 }
-asmlinkage long sys_getgroups16(int gidsetsize, old_gid_t __user *grouplist)
+SYSCALL_DEFINE2(getgroups16, int, gidsetsize, old_gid_t __user *, grouplist)
 {
        const struct cred *cred = current_cred();
        int i;
@@ -184,7 +185,7 @@ out:
        return i;
 }
-asmlinkage long sys_setgroups16(int gidsetsize, old_gid_t __user *grouplist)
+SYSCALL_DEFINE2(setgroups16, int, gidsetsize, old_gid_t __user *, grouplist)
 {
        struct group_info *group_info;
        int retval;
@@ -209,22 +210,22 @@ asmlinkage long sys_setgroups16(int gidsetsize, old_gid_t __user *grouplist)
        return retval;
 }
-asmlinkage long sys_getuid16(void)
+SYSCALL_DEFINE0(getuid16)
 {
        return high2lowuid(current_uid());
 }
-asmlinkage long sys_geteuid16(void)
+SYSCALL_DEFINE0(geteuid16)
 {
        return high2lowuid(current_euid());
 }
-asmlinkage long sys_getgid16(void)
+SYSCALL_DEFINE0(getgid16)
 {
        return high2lowgid(current_gid());
 }
-asmlinkage long sys_getegid16(void)
+SYSCALL_DEFINE0(getegid16)
 {
        return high2lowgid(current_egid());
 }
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 2f445833ae37..1f0c509b40d3 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -971,6 +971,8 @@ undo:
 }
 #ifdef CONFIG_SMP
+static struct workqueue_struct *work_on_cpu_wq __read_mostly;
 struct work_for_cpu {
        struct work_struct work;
        long (*fn)(void *);
@@ -991,8 +993,8 @@ static void do_work_for_cpu(struct work_struct *w)
 * @fn: the function to run
 * @arg: the function arg
 *
- * This will return -EINVAL in the cpu is not online, or the return value
+ * This will return the value @fn returns.
- * of @fn otherwise.
+ * It is up to the caller to ensure that the cpu doesn't go offline.
 */
 long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
 {
@@ -1001,14 +1003,8 @@ long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
        INIT_WORK(&wfc.work, do_work_for_cpu);
        wfc.fn = fn;
        wfc.arg = arg;
-        get_online_cpus();
+        queue_work_on(cpu, work_on_cpu_wq, &wfc.work);
-        if (unlikely(!cpu_online(cpu)))
+        flush_work(&wfc.work);
-                wfc.ret = -EINVAL;
-        else {
-                schedule_work_on(cpu, &wfc.work);
-                flush_work(&wfc.work);
-        }
-        put_online_cpus();
        return wfc.ret;
 }
@@ -1025,4 +1021,8 @@ void __init init_workqueues(void)
        hotcpu_notifier(workqueue_cpu_callback, 0);
        keventd_wq = create_workqueue("events");
        BUG_ON(!keventd_wq);
+#ifdef CONFIG_SMP
+        work_on_cpu_wq = create_workqueue("work_on_cpu");
+        BUG_ON(!work_on_cpu_wq);
+#endif
 }