8 files changed, 149 insertions, 57 deletions

diff --git a/kernel/events/core.c b/kernel/events/core.c
index 32b48c889711..ba36013cfb21 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -2300,6 +2300,9 @@ do {					\
         return div64_u64(dividend, divisor);
 }
 
+static DEFINE_PER_CPU(int, perf_throttled_count);
+static DEFINE_PER_CPU(u64, perf_throttled_seq);
+
 static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count)
 {
         struct hw_perf_event *hwc = &event->hw;
@@ -2325,16 +2328,29 @@ static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count)
         }
 }
 
-static void perf_ctx_adjust_freq(struct perf_event_context *ctx, u64 period)
+/*
+ * combine freq adjustment with unthrottling to avoid two passes over the
+ * events. At the same time, make sure, having freq events does not change
+ * the rate of unthrottling as that would introduce bias.
+ */
+static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
+                                           int needs_unthr)
 {
         struct perf_event *event;
         struct hw_perf_event *hwc;
-        u64 interrupts, now;
+        u64 now, period = TICK_NSEC;
         s64 delta;
 
-        if (!ctx->nr_freq)
+        /*
+         * only need to iterate over all events iff:
+         * - context have events in frequency mode (needs freq adjust)
+         * - there are events to unthrottle on this cpu
+         */
+        if (!(ctx->nr_freq || needs_unthr))
                 return;
 
+        raw_spin_lock(&ctx->lock);
+
         list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
                 if (event->state != PERF_EVENT_STATE_ACTIVE)
                         continue;
@@ -2344,13 +2360,8 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx, u64 period)
 
                 hwc = &event->hw;
 
-                interrupts = hwc->interrupts;
-                hwc->interrupts = 0;
-
-                /*
-                 * unthrottle events on the tick
-                 */
-                if (interrupts == MAX_INTERRUPTS) {
+                if (needs_unthr && hwc->interrupts == MAX_INTERRUPTS) {
+                        hwc->interrupts = 0;
                         perf_log_throttle(event, 1);
                         event->pmu->start(event, 0);
                 }
@@ -2358,14 +2369,26 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx, u64 period)
                 if (!event->attr.freq || !event->attr.sample_freq)
                         continue;
 
-                event->pmu->read(event);
+                /*
+                 * stop the event and update event->count
+                 */
+                event->pmu->stop(event, PERF_EF_UPDATE);
+
                 now = local64_read(&event->count);
                 delta = now - hwc->freq_count_stamp;
                 hwc->freq_count_stamp = now;
 
+                /*
+                 * restart the event
+                 * reload only if value has changed
+                 */
                 if (delta > 0)
                         perf_adjust_period(event, period, delta);
+
+                event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);
         }
+
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -2388,16 +2411,13 @@ static void rotate_ctx(struct perf_event_context *ctx)
  */
 static void perf_rotate_context(struct perf_cpu_context *cpuctx)
 {
-        u64 interval = (u64)cpuctx->jiffies_interval * TICK_NSEC;
         struct perf_event_context *ctx = NULL;
-        int rotate = 0, remove = 1, freq = 0;
+        int rotate = 0, remove = 1;
 
         if (cpuctx->ctx.nr_events) {
                 remove = 0;
                 if (cpuctx->ctx.nr_events != cpuctx->ctx.nr_active)
                         rotate = 1;
-                if (cpuctx->ctx.nr_freq)
-                        freq = 1;
         }
 
         ctx = cpuctx->task_ctx;
@@ -2405,37 +2425,26 @@ static void perf_rotate_context(struct perf_cpu_context *cpuctx)
                 remove = 0;
                 if (ctx->nr_events != ctx->nr_active)
                         rotate = 1;
-                if (ctx->nr_freq)
-                        freq = 1;
         }
 
-        if (!rotate && !freq)
+        if (!rotate)
                 goto done;
 
         perf_ctx_lock(cpuctx, cpuctx->task_ctx);
         perf_pmu_disable(cpuctx->ctx.pmu);
 
-        if (freq) {
-                perf_ctx_adjust_freq(&cpuctx->ctx, interval);
-                if (ctx)
-                        perf_ctx_adjust_freq(ctx, interval);
-        }
-
-        if (rotate) {
-                cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
-                if (ctx)
-                        ctx_sched_out(ctx, cpuctx, EVENT_FLEXIBLE);
+        cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
+        if (ctx)
+                ctx_sched_out(ctx, cpuctx, EVENT_FLEXIBLE);
 
-                rotate_ctx(&cpuctx->ctx);
-                if (ctx)
-                        rotate_ctx(ctx);
+        rotate_ctx(&cpuctx->ctx);
+        if (ctx)
+                rotate_ctx(ctx);
 
-                perf_event_sched_in(cpuctx, ctx, current);
-        }
+        perf_event_sched_in(cpuctx, ctx, current);
 
         perf_pmu_enable(cpuctx->ctx.pmu);
         perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
-
 done:
         if (remove)
                 list_del_init(&cpuctx->rotation_list);
@@ -2445,10 +2454,22 @@ void perf_event_task_tick(void)
 {
         struct list_head *head = &__get_cpu_var(rotation_list);
         struct perf_cpu_context *cpuctx, *tmp;
+        struct perf_event_context *ctx;
+        int throttled;
 
         WARN_ON(!irqs_disabled());
 
+        __this_cpu_inc(perf_throttled_seq);
+        throttled = __this_cpu_xchg(perf_throttled_count, 0);
+
         list_for_each_entry_safe(cpuctx, tmp, head, rotation_list) {
+                ctx = &cpuctx->ctx;
+                perf_adjust_freq_unthr_context(ctx, throttled);
+
+                ctx = cpuctx->task_ctx;
+                if (ctx)
+                        perf_adjust_freq_unthr_context(ctx, throttled);
+
                 if (cpuctx->jiffies_interval == 1 ||
                                 !(jiffies % cpuctx->jiffies_interval))
                         perf_rotate_context(cpuctx);
@@ -4509,6 +4530,7 @@ static int __perf_event_overflow(struct perf_event *event,
 {
         int events = atomic_read(&event->event_limit);
         struct hw_perf_event *hwc = &event->hw;
+        u64 seq;
         int ret = 0;
 
         /*
@@ -4518,14 +4540,20 @@ static int __perf_event_overflow(struct perf_event *event,
         if (unlikely(!is_sampling_event(event)))
                 return 0;
 
-        if (unlikely(hwc->interrupts >= max_samples_per_tick)) {
-                if (throttle) {
+        seq = __this_cpu_read(perf_throttled_seq);
+        if (seq != hwc->interrupts_seq) {
+                hwc->interrupts_seq = seq;
+                hwc->interrupts = 1;
+        } else {
+                hwc->interrupts++;
+                if (unlikely(throttle
+                             && hwc->interrupts >= max_samples_per_tick)) {
+                        __this_cpu_inc(perf_throttled_count);
                         hwc->interrupts = MAX_INTERRUPTS;
                         perf_log_throttle(event, 0);
                         ret = 1;
                 }
-        } else
-                hwc->interrupts++;
+        }
 
         if (event->attr.freq) {
                 u64 now = perf_clock();
diff --git a/kernel/exit.c b/kernel/exit.c
index 294b1709170d..4b4042f9bc6a 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1038,6 +1038,22 @@ void do_exit(long code)
         if (tsk->nr_dirtied)
                 __this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);
         exit_rcu();
+
+        /*
+         * The setting of TASK_RUNNING by try_to_wake_up() may be delayed
+         * when the following two conditions become true.
+         *   - There is race condition of mmap_sem (It is acquired by
+         *     exit_mm()), and
+         *   - SMI occurs before setting TASK_RUNINNG.
+         *     (or hypervisor of virtual machine switches to other guest)
+         *  As a result, we may become TASK_RUNNING after becoming TASK_DEAD
+         *
+         * To avoid it, we have to wait for releasing tsk->pi_lock which
+         * is held by try_to_wake_up()
+         */
+        smp_mb();
+        raw_spin_unlock_wait(&tsk->pi_lock);
+
         /* causes final put_task_struct in finish_task_switch(). */
         tsk->state = TASK_DEAD;
         tsk->flags |= PF_NOFREEZE;      /* tell freezer to ignore us */
diff --git a/kernel/fork.c b/kernel/fork.c
index 051f090d40c1..1b2ef3c23ae4 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -647,6 +647,26 @@ struct mm_struct *get_task_mm(struct task_struct *task)
 }
 EXPORT_SYMBOL_GPL(get_task_mm);
 
+struct mm_struct *mm_access(struct task_struct *task, unsigned int mode)
+{
+        struct mm_struct *mm;
+        int err;
+
+        err =  mutex_lock_killable(&task->signal->cred_guard_mutex);
+        if (err)
+                return ERR_PTR(err);
+
+        mm = get_task_mm(task);
+        if (mm && mm != current->mm &&
+                        !ptrace_may_access(task, mode)) {
+                mmput(mm);
+                mm = ERR_PTR(-EACCES);
+        }
+        mutex_unlock(&task->signal->cred_guard_mutex);
+
+        return mm;
+}
+
 /* Please note the differences between mmput and mm_release.
  * mmput is called whenever we stop holding onto a mm_struct,
  * error success whatever.
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 29f5b65bee29..9788c0ec6f43 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -1673,8 +1673,12 @@ static int __kprobes pre_handler_kretprobe(struct kprobe *p,
                 ri->rp = rp;
                 ri->task = current;
 
-                if (rp->entry_handler && rp->entry_handler(ri, regs))
+                if (rp->entry_handler && rp->entry_handler(ri, regs)) {
+                        raw_spin_lock_irqsave(&rp->lock, flags);
+                        hlist_add_head(&ri->hlist, &rp->free_instances);
+                        raw_spin_unlock_irqrestore(&rp->lock, flags);
                         return 0;
+                }
 
                 arch_prepare_kretprobe(ri, regs);
 
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index df00cb09263e..5255c9d2e053 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -74,6 +74,7 @@
 
 #include <asm/tlb.h>
 #include <asm/irq_regs.h>
+#include <asm/mutex.h>
 #ifdef CONFIG_PARAVIRT
 #include <asm/paravirt.h>
 #endif
@@ -723,9 +724,6 @@ static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
         p->sched_class->dequeue_task(rq, p, flags);
 }
 
-/*
- * activate_task - move a task to the runqueue.
- */
 void activate_task(struct rq *rq, struct task_struct *p, int flags)
 {
         if (task_contributes_to_load(p))
@@ -734,9 +732,6 @@ void activate_task(struct rq *rq, struct task_struct *p, int flags)
         enqueue_task(rq, p, flags);
 }
 
-/*
- * deactivate_task - remove a task from the runqueue.
- */
 void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
 {
         if (task_contributes_to_load(p))
@@ -4134,7 +4129,7 @@ recheck:
         on_rq = p->on_rq;
         running = task_current(rq, p);
         if (on_rq)
-                deactivate_task(rq, p, 0);
+                dequeue_task(rq, p, 0);
         if (running)
                 p->sched_class->put_prev_task(rq, p);
 
@@ -4147,7 +4142,7 @@ recheck:
         if (running)
                 p->sched_class->set_curr_task(rq);
         if (on_rq)
-                activate_task(rq, p, 0);
+                enqueue_task(rq, p, 0);
 
         check_class_changed(rq, p, prev_class, oldprio);
         task_rq_unlock(rq, p, &flags);
@@ -4998,9 +4993,9 @@ static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
          * placed properly.
          */
         if (p->on_rq) {
-                deactivate_task(rq_src, p, 0);
+                dequeue_task(rq_src, p, 0);
                 set_task_cpu(p, dest_cpu);
-                activate_task(rq_dest, p, 0);
+                enqueue_task(rq_dest, p, 0);
                 check_preempt_curr(rq_dest, p, 0);
         }
 done:
@@ -7032,10 +7027,10 @@ static void normalize_task(struct rq *rq, struct task_struct *p)
 
         on_rq = p->on_rq;
         if (on_rq)
-                deactivate_task(rq, p, 0);
+                dequeue_task(rq, p, 0);
         __setscheduler(rq, p, SCHED_NORMAL, 0);
         if (on_rq) {
-                activate_task(rq, p, 0);
+                enqueue_task(rq, p, 0);
                 resched_task(rq->curr);
         }
 
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 84adb2d66cbd..7c6414fc669d 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -4866,6 +4866,15 @@ static void nohz_balancer_kick(int cpu)
         return;
 }
 
+static inline void clear_nohz_tick_stopped(int cpu)
+{
+        if (unlikely(test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu)))) {
+                cpumask_clear_cpu(cpu, nohz.idle_cpus_mask);
+                atomic_dec(&nohz.nr_cpus);
+                clear_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu));
+        }
+}
+
 static inline void set_cpu_sd_state_busy(void)
 {
         struct sched_domain *sd;
@@ -4904,6 +4913,12 @@ void select_nohz_load_balancer(int stop_tick)
 {
         int cpu = smp_processor_id();
 
+        /*
+         * If this cpu is going down, then nothing needs to be done.
+         */
+        if (!cpu_active(cpu))
+                return;
+
         if (stop_tick) {
                 if (test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu)))
                         return;
@@ -4914,6 +4929,18 @@ void select_nohz_load_balancer(int stop_tick)
         }
         return;
 }
+
+static int __cpuinit sched_ilb_notifier(struct notifier_block *nfb,
+                                        unsigned long action, void *hcpu)
+{
+        switch (action & ~CPU_TASKS_FROZEN) {
+        case CPU_DYING:
+                clear_nohz_tick_stopped(smp_processor_id());
+                return NOTIFY_OK;
+        default:
+                return NOTIFY_DONE;
+        }
+}
 #endif
 
 static DEFINE_SPINLOCK(balancing);
@@ -5070,11 +5097,7 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)
         * busy tick after returning from idle, we will update the busy stats.
         */
         set_cpu_sd_state_busy();
-        if (unlikely(test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu)))) {
-                clear_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu));
-                cpumask_clear_cpu(cpu, nohz.idle_cpus_mask);
-                atomic_dec(&nohz.nr_cpus);
-        }
+        clear_nohz_tick_stopped(cpu);
 
         /*
          * None are in tickless mode and hence no need for NOHZ idle load
@@ -5590,6 +5613,7 @@ __init void init_sched_fair_class(void)
 
 #ifdef CONFIG_NO_HZ
         zalloc_cpumask_var(&nohz.idle_cpus_mask, GFP_NOWAIT);
+        cpu_notifier(sched_ilb_notifier, 0);
 #endif
 #endif /* SMP */
 
diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c
index 3640ebbb466b..f42ae7fb5ec5 100644
--- a/kernel/sched/rt.c
+++ b/kernel/sched/rt.c
@@ -1587,6 +1587,11 @@ static int push_rt_task(struct rq *rq)
         if (!next_task)
                 return 0;
 
+#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
+       if (unlikely(task_running(rq, next_task)))
+               return 0;
+#endif
+
 retry:
         if (unlikely(next_task == rq->curr)) {
                 WARN_ON(1);
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index 1d7bca7f4f52..d117262deba3 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -296,7 +296,7 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
                 if (__this_cpu_read(soft_watchdog_warn) == true)
                         return HRTIMER_RESTART;
 
-                printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
+                printk(KERN_EMERG "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
                         smp_processor_id(), duration,
                         current->comm, task_pid_nr(current));
                 print_modules();