25 files changed, 175 insertions, 170 deletions
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index 917ab9525568..6e7351739a82 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -734,9 +734,6 @@ int audit_tag_tree(char *old, char *new)
        dentry = dget(path.dentry);
        path_put(&path);
-        if (dentry == tagged->mnt_root && dentry == mnt->mnt_root)
-                follow_up(&mnt, &dentry);
        list_add_tail(&list, &tagged->mnt_list);
        mutex_lock(&audit_filter_mutex);
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index e68bb5aebe02..5dd2572993cf 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -360,8 +360,6 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
        irqreturn_t ret, retval = IRQ_NONE;
        unsigned int status = 0;
-        WARN_ONCE(!in_irq(), "BUG: IRQ handler called from non-hardirq context!");
        if (!(action->flags & IRQF_DISABLED))
                local_irq_enable_in_hardirq();
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 7e2e7dd4cd2f..2734eca59243 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -109,10 +109,9 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
        spin_lock_irqsave(&desc->lock, flags);
 #ifdef CONFIG_GENERIC_PENDING_IRQ
-        if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
+        if (desc->status & IRQ_MOVE_PCNTXT)
-                cpumask_copy(desc->affinity, cpumask);
                desc->chip->set_affinity(irq, cpumask);
-        } else {
+        else {
                desc->status |= IRQ_MOVE_PENDING;
                cpumask_copy(desc->pending_mask, cpumask);
        }
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 47b201ecc6df..8bbeef996c76 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -2492,13 +2492,20 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this,
 void lockdep_init_map(struct lockdep_map *lock, const char *name,
                      struct lock_class_key *key, int subclass)
 {
-        if (unlikely(!debug_locks))
+        lock->class_cache = NULL;
+#ifdef CONFIG_LOCK_STAT
+        lock->cpu = raw_smp_processor_id();
+#endif
+        if (DEBUG_LOCKS_WARN_ON(!name)) {
+                lock->name = "NULL";
                return;
+        }
+        lock->name = name;
        if (DEBUG_LOCKS_WARN_ON(!key))
                return;
-        if (DEBUG_LOCKS_WARN_ON(!name))
-                return;
        /*
         * Sanity check, the lock-class key must be persistent:
         */
@@ -2507,12 +2514,11 @@ void lockdep_init_map(struct lockdep_map *lock, const char *name,
                DEBUG_LOCKS_WARN_ON(1);
                return;
        }
-        lock->name = name;
        lock->key = key;
-        lock->class_cache = NULL;
-#ifdef CONFIG_LOCK_STAT
+        if (unlikely(!debug_locks))
-        lock->cpu = raw_smp_processor_id();
+                return;
-#endif
        if (subclass)
                register_lock_class(lock, subclass, 1);
 }
diff --git a/kernel/panic.c b/kernel/panic.c
index 934fb377f4b3..3dcaa1661357 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -221,7 +221,7 @@ void add_taint(unsigned flag)
         * post-warning case.
         */
        if (flag != TAINT_CRAP && flag != TAINT_WARN && __debug_locks_off())
-                printk(KERN_WARNING "Disabling lockdep due to kernel taint\n");
+                printk(KERN_WARNING "Disabling lock debugging due to kernel taint\n");
        set_bit(flag, &tainted_mask);
 }
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index c9dcf98b4463..bece7c0b67b2 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -1420,19 +1420,19 @@ void run_posix_cpu_timers(struct task_struct *tsk)
         * timer call will interfere.
         */
        list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) {
-                int firing;
+                int cpu_firing;
                spin_lock(&timer->it_lock);
                list_del_init(&timer->it.cpu.entry);
-                firing = timer->it.cpu.firing;
+                cpu_firing = timer->it.cpu.firing;
                timer->it.cpu.firing = 0;
                /*
                 * The firing flag is -1 if we collided with a reset
                 * of the timer, which already reported this
                 * almost-firing as an overrun.  So don't generate an event.
                 */
-                if (likely(firing >= 0)) {
+                if (likely(cpu_firing >= 0))
                        cpu_timer_fire(timer);
-                }
                spin_unlock(&timer->it_lock);
        }
 }
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 0854770b63b9..e71ca9cd81b2 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -646,13 +646,6 @@ static int software_resume(void)
                return 0;
        /*
-         * We can't depend on SCSI devices being available after loading one of
-         * their modules if scsi_complete_async_scans() is not called and the
-         * resume device usually is a SCSI one.
-         */
-        scsi_complete_async_scans();
-        /*
         * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
         * is configured into the kernel. Since the regular hibernate
         * trigger path is via sysfs which takes a buffer mutex before
@@ -663,32 +656,42 @@ static int software_resume(void)
         * here to avoid lockdep complaining.
         */
        mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
+        if (swsusp_resume_device)
+                goto Check_image;
+        if (!strlen(resume_file)) {
+                error = -ENOENT;
+                goto Unlock;
+        }
+        pr_debug("PM: Checking image partition %s\n", resume_file);
+        /* Check if the device is there */
+        swsusp_resume_device = name_to_dev_t(resume_file);
        if (!swsusp_resume_device) {
-                if (!strlen(resume_file)) {
-                        mutex_unlock(&pm_mutex);
-                        return -ENOENT;
-                }
                /*
                 * Some device discovery might still be in progress; we need
                 * to wait for this to finish.
                 */
                wait_for_device_probe();
+                /*
+                 * We can't depend on SCSI devices being available after loading
+                 * one of their modules until scsi_complete_async_scans() is
+                 * called and the resume device usually is a SCSI one.
+                 */
+                scsi_complete_async_scans();
                swsusp_resume_device = name_to_dev_t(resume_file);
-                pr_debug("PM: Resume from partition %s\n", resume_file);
+                if (!swsusp_resume_device) {
-        } else {
+                        error = -ENODEV;
-                pr_debug("PM: Resume from partition %d:%d\n",
+                        goto Unlock;
-                                MAJOR(swsusp_resume_device),
+                }
-                                MINOR(swsusp_resume_device));
        }
-        if (noresume) {
+ Check_image:
-                /**
+        pr_debug("PM: Resume from partition %d:%d\n",
-                 * FIXME: If noresume is specified, we need to find the
+                MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
-                 * partition and reset it back to normal swap space.
-                 */
-                mutex_unlock(&pm_mutex);
-                return 0;
-        }
        pr_debug("PM: Checking hibernation image.\n");
        error = swsusp_check();
diff --git a/kernel/power/main.c b/kernel/power/main.c
index f172f41858bb..f99ed6a75eac 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -291,20 +291,26 @@ static int suspend_enter(suspend_state_t state)
        device_pm_lock();
+        if (suspend_ops->prepare) {
+                error = suspend_ops->prepare();
+                if (error)
+                        goto Done;
+        }
        error = device_power_down(PMSG_SUSPEND);
        if (error) {
                printk(KERN_ERR "PM: Some devices failed to power down\n");
-                goto Done;
+                goto Platfrom_finish;
        }
-        if (suspend_ops->prepare) {
+        if (suspend_ops->prepare_late) {
-                error = suspend_ops->prepare();
+                error = suspend_ops->prepare_late();
                if (error)
                        goto Power_up_devices;
        }
        if (suspend_test(TEST_PLATFORM))
-                goto Platfrom_finish;
+                goto Platform_wake;
        error = disable_nonboot_cpus();
        if (error || suspend_test(TEST_CPUS))
@@ -326,13 +332,17 @@ static int suspend_enter(suspend_state_t state)
 Enable_cpus:
        enable_nonboot_cpus();
- Platfrom_finish:
+ Platform_wake:
-        if (suspend_ops->finish)
+        if (suspend_ops->wake)
-                suspend_ops->finish();
+                suspend_ops->wake();
 Power_up_devices:
        device_power_up(PMSG_RESUME);
+ Platfrom_finish:
+        if (suspend_ops->finish)
+                suspend_ops->finish();
 Done:
        device_pm_unlock();
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 505f319e489c..8ba052c86d48 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -64,8 +64,6 @@ static int submit(int rw, pgoff_t page_off, struct page *page,
        struct bio *bio;
        bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
-        if (!bio)
-                return -ENOMEM;
        bio->bi_sector = page_off * (PAGE_SIZE >> 9);
        bio->bi_bdev = resume_bdev;
        bio->bi_end_io = end_swap_bio_read;
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 64191fa09b7e..0692ab5a0d67 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -188,7 +188,7 @@ int ptrace_attach(struct task_struct *task)
        /* Protect exec's credential calculations against our interference;
         * SUID, SGID and LSM creds get determined differently under ptrace.
         */
-        retval = mutex_lock_interruptible(&current->cred_exec_mutex);
+        retval = mutex_lock_interruptible(&task->cred_exec_mutex);
        if (retval  < 0)
                goto out;
@@ -232,7 +232,7 @@ repeat:
 bad:
        write_unlock_irqrestore(&tasklist_lock, flags);
        task_unlock(task);
-        mutex_unlock(&current->cred_exec_mutex);
+        mutex_unlock(&task->cred_exec_mutex);
 out:
        return retval;
 }
@@ -604,10 +604,11 @@ repeat:
                ret = security_ptrace_traceme(current->parent);
                /*
-                 * Set the ptrace bit in the process ptrace flags.
+                 * Check PF_EXITING to ensure ->real_parent has not passed
-                 * Then link us on our parent's ptraced list.
+                 * exit_ptrace(). Otherwise we don't report the error but
+                 * pretend ->real_parent untraces us right after return.
                 */
-                if (!ret) {
+                if (!ret && !(current->real_parent->flags & PF_EXITING)) {
                        current->ptrace |= PT_PTRACED;
                        __ptrace_link(current, current->real_parent);
                }
diff --git a/kernel/rcupdate.c b/kernel/rcupdate.c
index 2c7b8457d0d2..a967c9feb90a 100644
--- a/kernel/rcupdate.c
+++ b/kernel/rcupdate.c
@@ -58,6 +58,10 @@ static DEFINE_MUTEX(rcu_barrier_mutex);
 static struct completion rcu_barrier_completion;
 int rcu_scheduler_active __read_mostly;
+static atomic_t rcu_migrate_type_count = ATOMIC_INIT(0);
+static struct rcu_head rcu_migrate_head[3];
+static DECLARE_WAIT_QUEUE_HEAD(rcu_migrate_wq);
 /*
 * Awaken the corresponding synchronize_rcu() instance now that a
 * grace period has elapsed.
@@ -122,7 +126,10 @@ static void rcu_barrier_func(void *type)
        }
 }
-static inline void wait_migrated_callbacks(void);
+static inline void wait_migrated_callbacks(void)
+{
+        wait_event(rcu_migrate_wq, !atomic_read(&rcu_migrate_type_count));
+}
 /*
 * Orchestrate the specified type of RCU barrier, waiting for all
@@ -179,21 +186,12 @@ void rcu_barrier_sched(void)
 }
 EXPORT_SYMBOL_GPL(rcu_barrier_sched);
-static atomic_t rcu_migrate_type_count = ATOMIC_INIT(0);
-static struct rcu_head rcu_migrate_head[3];
-static DECLARE_WAIT_QUEUE_HEAD(rcu_migrate_wq);
 static void rcu_migrate_callback(struct rcu_head *notused)
 {
        if (atomic_dec_and_test(&rcu_migrate_type_count))
                wake_up(&rcu_migrate_wq);
 }
-static inline void wait_migrated_callbacks(void)
-{
-        wait_event(rcu_migrate_wq, !atomic_read(&rcu_migrate_type_count));
-}
 static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
                unsigned long action, void *hcpu)
 {
diff --git a/kernel/rcutree.c b/kernel/rcutree.c
index 7f3266922572..d2a372fb0b9b 100644
--- a/kernel/rcutree.c
+++ b/kernel/rcutree.c
@@ -530,8 +530,6 @@ static void note_new_gpnum(struct rcu_state *rsp, struct rcu_data *rdp)
        rdp->qs_pending = 1;
        rdp->passed_quiesc = 0;
        rdp->gpnum = rsp->gpnum;
-        rdp->n_rcu_pending_force_qs = rdp->n_rcu_pending +
-                                      RCU_JIFFIES_TILL_FORCE_QS;
 }
 /*
@@ -578,8 +576,6 @@ rcu_start_gp(struct rcu_state *rsp, unsigned long flags)
        rsp->gpnum++;
        rsp->signaled = RCU_GP_INIT; /* Hold off force_quiescent_state. */
        rsp->jiffies_force_qs = jiffies + RCU_JIFFIES_TILL_FORCE_QS;
-        rdp->n_rcu_pending_force_qs = rdp->n_rcu_pending +
-                                      RCU_JIFFIES_TILL_FORCE_QS;
        record_gp_stall_check_time(rsp);
        dyntick_record_completed(rsp, rsp->completed - 1);
        note_new_gpnum(rsp, rdp);
@@ -1055,7 +1051,6 @@ static void force_quiescent_state(struct rcu_state *rsp, int relaxed)
 {
        unsigned long flags;
        long lastcomp;
-        struct rcu_data *rdp = rsp->rda[smp_processor_id()];
        struct rcu_node *rnp = rcu_get_root(rsp);
        u8 signaled;
@@ -1066,16 +1061,13 @@ static void force_quiescent_state(struct rcu_state *rsp, int relaxed)
                return; /* Someone else is already on the job. */
        }
        if (relaxed &&
-            (long)(rsp->jiffies_force_qs - jiffies) >= 0 &&
+            (long)(rsp->jiffies_force_qs - jiffies) >= 0)
-            (rdp->n_rcu_pending_force_qs - rdp->n_rcu_pending) >= 0)
                goto unlock_ret; /* no emergency and done recently. */
        rsp->n_force_qs++;
        spin_lock(&rnp->lock);
        lastcomp = rsp->completed;
        signaled = rsp->signaled;
        rsp->jiffies_force_qs = jiffies + RCU_JIFFIES_TILL_FORCE_QS;
-        rdp->n_rcu_pending_force_qs = rdp->n_rcu_pending +
-                                      RCU_JIFFIES_TILL_FORCE_QS;
        if (lastcomp == rsp->gpnum) {
                rsp->n_force_qs_ngp++;
                spin_unlock(&rnp->lock);
@@ -1144,8 +1136,7 @@ __rcu_process_callbacks(struct rcu_state *rsp, struct rcu_data *rdp)
         * If an RCU GP has gone long enough, go check for dyntick
         * idle CPUs and, if needed, send resched IPIs.
         */
-        if ((long)(ACCESS_ONCE(rsp->jiffies_force_qs) - jiffies) < 0 ||
+        if ((long)(ACCESS_ONCE(rsp->jiffies_force_qs) - jiffies) < 0)
-            (rdp->n_rcu_pending_force_qs - rdp->n_rcu_pending) < 0)
                force_quiescent_state(rsp, 1);
        /*
@@ -1230,8 +1221,7 @@ __call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu),
        if (unlikely(++rdp->qlen > qhimark)) {
                rdp->blimit = LONG_MAX;
                force_quiescent_state(rsp, 0);
-        } else if ((long)(ACCESS_ONCE(rsp->jiffies_force_qs) - jiffies) < 0 ||
+        } else if ((long)(ACCESS_ONCE(rsp->jiffies_force_qs) - jiffies) < 0)
-                   (rdp->n_rcu_pending_force_qs - rdp->n_rcu_pending) < 0)
                force_quiescent_state(rsp, 1);
        local_irq_restore(flags);
 }
@@ -1290,8 +1280,7 @@ static int __rcu_pending(struct rcu_state *rsp, struct rcu_data *rdp)
        /* Has an RCU GP gone long enough to send resched IPIs &c? */
        if (ACCESS_ONCE(rsp->completed) != ACCESS_ONCE(rsp->gpnum) &&
-            ((long)(ACCESS_ONCE(rsp->jiffies_force_qs) - jiffies) < 0 ||
+            ((long)(ACCESS_ONCE(rsp->jiffies_force_qs) - jiffies) < 0))
-             (rdp->n_rcu_pending_force_qs - rdp->n_rcu_pending) < 0))
                return 1;
        /* nothing to do */
diff --git a/kernel/rcutree_trace.c b/kernel/rcutree_trace.c
index 4ee954f6a8d5..4b1875ba9404 100644
--- a/kernel/rcutree_trace.c
+++ b/kernel/rcutree_trace.c
@@ -49,14 +49,12 @@ static void print_one_rcu_data(struct seq_file *m, struct rcu_data *rdp)
 {
        if (!rdp->beenonline)
                return;
-        seq_printf(m, "%3d%cc=%ld g=%ld pq=%d pqc=%ld qp=%d rpfq=%ld rp=%x",
+        seq_printf(m, "%3d%cc=%ld g=%ld pq=%d pqc=%ld qp=%d",
                   rdp->cpu,
                   cpu_is_offline(rdp->cpu) ? '!' : ' ',
                   rdp->completed, rdp->gpnum,
                   rdp->passed_quiesc, rdp->passed_quiesc_completed,
-                   rdp->qs_pending,
+                   rdp->qs_pending);
-                   rdp->n_rcu_pending_force_qs - rdp->n_rcu_pending,
-                   (int)(rdp->n_rcu_pending & 0xffff));
 #ifdef CONFIG_NO_HZ
        seq_printf(m, " dt=%d/%d dn=%d df=%lu",
                   rdp->dynticks->dynticks,
@@ -102,14 +100,12 @@ static void print_one_rcu_data_csv(struct seq_file *m, struct rcu_data *rdp)
 {
        if (!rdp->beenonline)
                return;
-        seq_printf(m, "%d,%s,%ld,%ld,%d,%ld,%d,%ld,%ld",
+        seq_printf(m, "%d,%s,%ld,%ld,%d,%ld,%d",
                   rdp->cpu,
                   cpu_is_offline(rdp->cpu) ? "\"Y\"" : "\"N\"",
                   rdp->completed, rdp->gpnum,
                   rdp->passed_quiesc, rdp->passed_quiesc_completed,
-                   rdp->qs_pending,
+                   rdp->qs_pending);
-                   rdp->n_rcu_pending_force_qs - rdp->n_rcu_pending,
-                   rdp->n_rcu_pending);
 #ifdef CONFIG_NO_HZ
        seq_printf(m, ",%d,%d,%d,%lu",
                   rdp->dynticks->dynticks,
@@ -123,7 +119,7 @@ static void print_one_rcu_data_csv(struct seq_file *m, struct rcu_data *rdp)
 static int show_rcudata_csv(struct seq_file *m, void *unused)
 {
-        seq_puts(m, "\"CPU\",\"Online?\",\"c\",\"g\",\"pq\",\"pqc\",\"pq\",\"rpfq\",\"rp\",");
+        seq_puts(m, "\"CPU\",\"Online?\",\"c\",\"g\",\"pq\",\"pqc\",\"pq\",");
 #ifdef CONFIG_NO_HZ
        seq_puts(m, "\"dt\",\"dt nesting\",\"dn\",\"df\",");
 #endif /* #ifdef CONFIG_NO_HZ */
diff --git a/kernel/resource.c b/kernel/resource.c
index fd5d7d574bb9..ac5f3a36923f 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -533,43 +533,21 @@ static void __init __reserve_region_with_split(struct resource *root,
        res->end = end;
        res->flags = IORESOURCE_BUSY;
-        for (;;) {
+        conflict = __request_resource(parent, res);
-                conflict = __request_resource(parent, res);
+        if (!conflict)
-                if (!conflict)
+                return;
-                        break;
-                if (conflict != parent) {
-                        parent = conflict;
-                        if (!(conflict->flags & IORESOURCE_BUSY))
-                                continue;
-                }
-                /* Uhhuh, that didn't work out.. */
-                kfree(res);
-                res = NULL;
-                break;
-        }
-        if (!res) {
-                /* failed, split and try again */
-                /* conflict covered whole area */
-                if (conflict->start <= start && conflict->end >= end)
-                        return;
-                if (conflict->start > start)
+        /* failed, split and try again */
-                        __reserve_region_with_split(root, start, conflict->start-1, name);
+        kfree(res);
-                if (!(conflict->flags & IORESOURCE_BUSY)) {
-                        resource_size_t common_start, common_end;
-                        common_start = max(conflict->start, start);
+        /* conflict covered whole area */
-                        common_end = min(conflict->end, end);
+        if (conflict->start <= start && conflict->end >= end)
-                        if (common_start < common_end)
+                return;
-                                __reserve_region_with_split(root, common_start, common_end, name);
-                }
-                if (conflict->end < end)
-                        __reserve_region_with_split(root, conflict->end+1, end, name);
-        }
+        if (conflict->start > start)
+                __reserve_region_with_split(root, start, conflict->start-1, name);
+        if (conflict->end < end)
+                __reserve_region_with_split(root, conflict->end+1, end, name);
 }
 void __init reserve_region_with_split(struct resource *root,
diff --git a/kernel/sched.c b/kernel/sched.c
index 9cdedbd181ce..14a19b17674e 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4728,7 +4728,7 @@ void account_process_tick(struct task_struct *p, int user_tick)
        if (user_tick)
                account_user_time(p, one_jiffy, one_jiffy_scaled);
-        else if (p != rq->idle)
+        else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
                account_system_time(p, HARDIRQ_OFFSET, one_jiffy,
                                    one_jiffy_scaled);
        else
@@ -4842,7 +4842,7 @@ void scheduler_tick(void)
 #endif
 }
-unsigned long get_parent_ip(unsigned long addr)
+notrace unsigned long get_parent_ip(unsigned long addr)
 {
        if (in_lock_functions(addr)) {
                addr = CALLER_ADDR2;
@@ -7363,8 +7363,12 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                cpumask_or(groupmask, groupmask, sched_group_cpus(group));
                cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
-                printk(KERN_CONT " %s (__cpu_power = %d)", str,
-                                                group->__cpu_power);
+                printk(KERN_CONT " %s", str);
+                if (group->__cpu_power != SCHED_LOAD_SCALE) {
+                        printk(KERN_CONT " (__cpu_power = %d)",
+                                group->__cpu_power);
+                }
                group = group->next;
        } while (group != sd->groups);
diff --git a/kernel/slow-work.c b/kernel/slow-work.c
index cf2bc01186ef..b28d19135f43 100644
--- a/kernel/slow-work.c
+++ b/kernel/slow-work.c
@@ -609,14 +609,14 @@ void slow_work_unregister_user(void)
        if (slow_work_user_count == 0) {
                printk(KERN_NOTICE "Slow work thread pool: Shutting down\n");
                slow_work_threads_should_exit = true;
+                del_timer_sync(&slow_work_cull_timer);
+                del_timer_sync(&slow_work_oom_timer);
                wake_up_all(&slow_work_thread_wq);
                wait_for_completion(&slow_work_last_thread_exited);
                printk(KERN_NOTICE "Slow work thread pool:"
                       " Shut down complete\n");
        }
-        del_timer_sync(&slow_work_cull_timer);
        mutex_unlock(&slow_work_user_lock);
 }
 EXPORT_SYMBOL(slow_work_unregister_user);
diff --git a/kernel/softirq.c b/kernel/softirq.c
index d4ba347a872d..dc4d0cfdcb2d 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -471,9 +471,9 @@ void tasklet_kill(struct tasklet_struct *t)
                printk("Attempt to kill tasklet from interrupt\n");
        while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {
-                do
+                do {
                        yield();
-                while (test_bit(TASKLET_STATE_SCHED, &t->state));
+                } while (test_bit(TASKLET_STATE_SCHED, &t->state));
        }
        tasklet_unlock_wait(t);
        clear_bit(TASKLET_STATE_SCHED, &t->state);
diff --git a/kernel/sys.c b/kernel/sys.c
index 51dbb55604e8..e7998cf31498 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -360,6 +360,7 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
                void __user *, arg)
 {
        char buffer[256];
+        int ret = 0;
        /* We only trust the superuser with rebooting the system. */
        if (!capable(CAP_SYS_BOOT))
@@ -397,7 +398,7 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
                kernel_halt();
                unlock_kernel();
                do_exit(0);
-                break;
+                panic("cannot halt");
        case LINUX_REBOOT_CMD_POWER_OFF:
                kernel_power_off();
@@ -417,29 +418,22 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
 #ifdef CONFIG_KEXEC
        case LINUX_REBOOT_CMD_KEXEC:
-                {
+                ret = kernel_kexec();
-                        int ret;
+                break;
-                        ret = kernel_kexec();
-                        unlock_kernel();
-                        return ret;
-                }
 #endif
 #ifdef CONFIG_HIBERNATION
        case LINUX_REBOOT_CMD_SW_SUSPEND:
-                {
+                ret = hibernate();
-                        int ret = hibernate();
+                break;
-                        unlock_kernel();
-                        return ret;
-                }
 #endif
        default:
-                unlock_kernel();
+                ret = -EINVAL;
-                return -EINVAL;
+                break;
        }
        unlock_kernel();
-        return 0;
+        return ret;
 }
 static void deferred_cad(struct work_struct *dummy)
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 4286b62b34a0..ea78fa101ad6 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -103,6 +103,9 @@ static unsigned long one_ul = 1;
 static int one_hundred = 100;
 static int one_thousand = 1000;
+/* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
+static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
 static int maxolduid = 65535;
 static int minolduid;
@@ -902,16 +905,6 @@ static struct ctl_table kern_table[] = {
                .proc_handler   = &proc_dointvec,
        },
 #endif
-#ifdef CONFIG_UNEVICTABLE_LRU
-        {
-                .ctl_name       = CTL_UNNUMBERED,
-                .procname       = "scan_unevictable_pages",
-                .data           = &scan_unevictable_pages,
-                .maxlen         = sizeof(scan_unevictable_pages),
-                .mode           = 0644,
-                .proc_handler   = &scan_unevictable_handler,
-        },
-#endif
 #ifdef CONFIG_SLOW_WORK
        {
                .ctl_name       = CTL_UNNUMBERED,
@@ -1016,7 +1009,7 @@ static struct ctl_table vm_table[] = {
                .mode           = 0644,
                .proc_handler   = &dirty_bytes_handler,
                .strategy       = &sysctl_intvec,
-                .extra1         = &one_ul,
+                .extra1         = &dirty_bytes_min,
        },
        {
                .procname       = "dirty_writeback_centisecs",
@@ -1302,6 +1295,16 @@ static struct ctl_table vm_table[] = {
                .extra2         = &one,
        },
 #endif
+#ifdef CONFIG_UNEVICTABLE_LRU
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "scan_unevictable_pages",
+                .data           = &scan_unevictable_pages,
+                .maxlen         = sizeof(scan_unevictable_pages),
+                .mode           = 0644,
+                .proc_handler   = &scan_unevictable_handler,
+        },
+#endif
 /*
 * NOTE: do not add new entries to this table unless you have read
 * Documentation/sysctl/ctl_unnumbered.txt
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index c46c931a7fe7..ecfd7b5187e0 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -181,12 +181,12 @@ static void clocksource_watchdog(unsigned long data)
        resumed = test_and_clear_bit(0, &watchdog_resumed);
-        wdnow = watchdog->read();
+        wdnow = watchdog->read(watchdog);
        wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
        watchdog_last = wdnow;
        list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
-                csnow = cs->read();
+                csnow = cs->read(cs);
                if (unlikely(resumed)) {
                        cs->wd_last = csnow;
@@ -247,7 +247,7 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                list_add(&cs->wd_list, &watchdog_list);
                if (!started && watchdog) {
-                        watchdog_last = watchdog->read();
+                        watchdog_last = watchdog->read(watchdog);
                        watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
                        add_timer_on(&watchdog_timer,
                                     cpumask_first(cpu_online_mask));
@@ -268,7 +268,7 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                                cse->flags &= ~CLOCK_SOURCE_WATCHDOG;
                        /* Start if list is not empty */
                        if (!list_empty(&watchdog_list)) {
-                                watchdog_last = watchdog->read();
+                                watchdog_last = watchdog->read(watchdog);
                                watchdog_timer.expires =
                                        jiffies + WATCHDOG_INTERVAL;
                                add_timer_on(&watchdog_timer,
diff --git a/kernel/time/jiffies.c b/kernel/time/jiffies.c
index 06f197560f3b..c3f6c30816e3 100644
--- a/kernel/time/jiffies.c
+++ b/kernel/time/jiffies.c
@@ -50,7 +50,7 @@
 */
 #define JIFFIES_SHIFT   8
-static cycle_t jiffies_read(void)
+static cycle_t jiffies_read(struct clocksource *cs)
 {
        return (cycle_t) jiffies;
 }
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 21a5ca849514..83c4417b6a3c 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -93,7 +93,17 @@ void tick_handle_periodic(struct clock_event_device *dev)
        for (;;) {
                if (!clockevents_program_event(dev, next, ktime_get()))
                        return;
-                tick_periodic(cpu);
+                /*
+                 * Have to be careful here. If we're in oneshot mode,
+                 * before we call tick_periodic() in a loop, we need
+                 * to be sure we're using a real hardware clocksource.
+                 * Otherwise we could get trapped in an infinite
+                 * loop, as the tick_periodic() increments jiffies,
+                 * when then will increment time, posibly causing
+                 * the loop to trigger again and again.
+                 */
+                if (timekeeping_valid_for_hres())
+                        tick_periodic(cpu);
                next = ktime_add(next, tick_period);
        }
 }
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 900f1b6598d1..687dff49f6e7 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -182,7 +182,7 @@ EXPORT_SYMBOL(do_settimeofday);
 */
 static void change_clocksource(void)
 {
-        struct clocksource *new;
+        struct clocksource *new, *old;
        new = clocksource_get_next();
@@ -191,11 +191,16 @@ static void change_clocksource(void)
        clocksource_forward_now();
-        new->raw_time = clock->raw_time;
+        if (clocksource_enable(new))
+                return;
+        new->raw_time = clock->raw_time;
+        old = clock;
        clock = new;
+        clocksource_disable(old);
        clock->cycle_last = 0;
-        clock->cycle_last = clocksource_read(new);
+        clock->cycle_last = clocksource_read(clock);
        clock->error = 0;
        clock->xtime_nsec = 0;
        clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
@@ -292,6 +297,7 @@ void __init timekeeping_init(void)
        ntp_init();
        clock = clocksource_get_next();
+        clocksource_enable(clock);
        clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
        clock->cycle_last = clocksource_read(clock);
diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
index 8e64e604f5a7..7a7a9fd249a9 100644
--- a/kernel/trace/trace_branch.c
+++ b/kernel/trace/trace_branch.c
@@ -157,6 +157,13 @@ static enum print_line_t trace_branch_print(struct trace_iterator *iter,
        return TRACE_TYPE_HANDLED;
 }
+static void branch_print_header(struct seq_file *s)
+{
+        seq_puts(s, "#           TASK-PID    CPU#    TIMESTAMP  CORRECT"
+                "  FUNC:FILE:LINE\n");
+        seq_puts(s, "#              | |       |          |         |   "
+                "    |\n");
+}
 static struct trace_event trace_branch_event = {
        .type           = TRACE_BRANCH,
@@ -171,6 +178,7 @@ static struct tracer branch_trace __read_mostly =
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest       = trace_selftest_startup_branch,
 #endif /* CONFIG_FTRACE_SELFTEST */
+        .print_header   = branch_print_header,
 };
 __init static int init_branch_tracer(void)
diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
index 810a5b7cf1c5..8a30d9874cd4 100644
--- a/kernel/trace/trace_power.c
+++ b/kernel/trace/trace_power.c
@@ -190,6 +190,12 @@ static enum print_line_t power_print_line(struct trace_iterator *iter)
        return TRACE_TYPE_UNHANDLED;
 }
+static void power_print_header(struct seq_file *s)
+{
+        seq_puts(s, "#   TIMESTAMP      STATE  EVENT\n");
+        seq_puts(s, "#       |            |      |\n");
+}
 static struct tracer power_tracer __read_mostly =
 {
        .name           = "power",
@@ -198,6 +204,7 @@ static struct tracer power_tracer __read_mostly =
        .stop           = stop_power_trace,
        .reset          = power_trace_reset,
        .print_line     = power_print_line,
+        .print_header   = power_print_header,
 };
 static int init_power_trace(void)