10 files changed, 220 insertions, 146 deletions

diff --git a/kernel/compat.c b/kernel/compat.c
index 8c9cd88b6785..b9bdd1271f44 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -21,6 +21,7 @@
 #include <linux/syscalls.h>
 #include <linux/unistd.h>
 #include <linux/security.h>
+#include <linux/timex.h>
 
 #include <asm/uaccess.h>
 
@@ -898,3 +899,61 @@ asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset, compat
         return -ERESTARTNOHAND;
 }
 #endif /* __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND */
+
+asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp)
+{
+        struct timex txc;
+        int ret;
+
+        memset(&txc, 0, sizeof(struct timex));
+
+        if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) ||
+                        __get_user(txc.modes, &utp->modes) ||
+                        __get_user(txc.offset, &utp->offset) ||
+                        __get_user(txc.freq, &utp->freq) ||
+                        __get_user(txc.maxerror, &utp->maxerror) ||
+                        __get_user(txc.esterror, &utp->esterror) ||
+                        __get_user(txc.status, &utp->status) ||
+                        __get_user(txc.constant, &utp->constant) ||
+                        __get_user(txc.precision, &utp->precision) ||
+                        __get_user(txc.tolerance, &utp->tolerance) ||
+                        __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
+                        __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
+                        __get_user(txc.tick, &utp->tick) ||
+                        __get_user(txc.ppsfreq, &utp->ppsfreq) ||
+                        __get_user(txc.jitter, &utp->jitter) ||
+                        __get_user(txc.shift, &utp->shift) ||
+                        __get_user(txc.stabil, &utp->stabil) ||
+                        __get_user(txc.jitcnt, &utp->jitcnt) ||
+                        __get_user(txc.calcnt, &utp->calcnt) ||
+                        __get_user(txc.errcnt, &utp->errcnt) ||
+                        __get_user(txc.stbcnt, &utp->stbcnt))
+                return -EFAULT;
+
+        ret = do_adjtimex(&txc);
+
+        if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) ||
+                        __put_user(txc.modes, &utp->modes) ||
+                        __put_user(txc.offset, &utp->offset) ||
+                        __put_user(txc.freq, &utp->freq) ||
+                        __put_user(txc.maxerror, &utp->maxerror) ||
+                        __put_user(txc.esterror, &utp->esterror) ||
+                        __put_user(txc.status, &utp->status) ||
+                        __put_user(txc.constant, &utp->constant) ||
+                        __put_user(txc.precision, &utp->precision) ||
+                        __put_user(txc.tolerance, &utp->tolerance) ||
+                        __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
+                        __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
+                        __put_user(txc.tick, &utp->tick) ||
+                        __put_user(txc.ppsfreq, &utp->ppsfreq) ||
+                        __put_user(txc.jitter, &utp->jitter) ||
+                        __put_user(txc.shift, &utp->shift) ||
+                        __put_user(txc.stabil, &utp->stabil) ||
+                        __put_user(txc.jitcnt, &utp->jitcnt) ||
+                        __put_user(txc.calcnt, &utp->calcnt) ||
+                        __put_user(txc.errcnt, &utp->errcnt) ||
+                        __put_user(txc.stbcnt, &utp->stbcnt))
+                ret = -EFAULT;
+
+        return ret;
+}
diff --git a/kernel/fork.c b/kernel/fork.c
index d93ab2ba729c..e0a2b449dea6 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -847,7 +847,7 @@ static inline int copy_signal(unsigned long clone_flags, struct task_struct * ts
         hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_REL);
         sig->it_real_incr.tv64 = 0;
         sig->real_timer.function = it_real_fn;
-        sig->real_timer.data = tsk;
+        sig->tsk = tsk;
 
         sig->it_virt_expires = cputime_zero;
         sig->it_virt_incr = cputime_zero;
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 14bc9cfa6399..0237a556eb1f 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -123,6 +123,26 @@ void ktime_get_ts(struct timespec *ts)
 EXPORT_SYMBOL_GPL(ktime_get_ts);
 
 /*
+ * Get the coarse grained time at the softirq based on xtime and
+ * wall_to_monotonic.
+ */
+static void hrtimer_get_softirq_time(struct hrtimer_base *base)
+{
+        ktime_t xtim, tomono;
+        unsigned long seq;
+
+        do {
+                seq = read_seqbegin(&xtime_lock);
+                xtim = timespec_to_ktime(xtime);
+                tomono = timespec_to_ktime(wall_to_monotonic);
+
+        } while (read_seqretry(&xtime_lock, seq));
+
+        base[CLOCK_REALTIME].softirq_time = xtim;
+        base[CLOCK_MONOTONIC].softirq_time = ktime_add(xtim, tomono);
+}
+
+/*
  * Functions and macros which are different for UP/SMP systems are kept in a
  * single place
  */
@@ -246,7 +266,7 @@ ktime_t ktime_add_ns(const ktime_t kt, u64 nsec)
 /*
  * Divide a ktime value by a nanosecond value
  */
-static unsigned long ktime_divns(const ktime_t kt, nsec_t div)
+static unsigned long ktime_divns(const ktime_t kt, s64 div)
 {
         u64 dclc, inc, dns;
         int sft = 0;
@@ -281,18 +301,17 @@ void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
  * hrtimer_forward - forward the timer expiry
  *
  * @timer:      hrtimer to forward
+ * @now:        forward past this time
  * @interval:   the interval to forward
  *
  * Forward the timer expiry so it will expire in the future.
  * Returns the number of overruns.
  */
 unsigned long
-hrtimer_forward(struct hrtimer *timer, ktime_t interval)
+hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)
 {
         unsigned long orun = 1;
-        ktime_t delta, now;
-
-        now = timer->base->get_time();
+        ktime_t delta;
 
         delta = ktime_sub(now, timer->expires);
 
@@ -303,7 +322,7 @@ hrtimer_forward(struct hrtimer *timer, ktime_t interval)
                 interval.tv64 = timer->base->resolution.tv64;
 
         if (unlikely(delta.tv64 >= interval.tv64)) {
-                nsec_t incr = ktime_to_ns(interval);
+                s64 incr = ktime_to_ns(interval);
 
                 orun = ktime_divns(delta, incr);
                 timer->expires = ktime_add_ns(timer->expires, incr * orun);
@@ -355,8 +374,6 @@ static void enqueue_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
         rb_link_node(&timer->node, parent, link);
         rb_insert_color(&timer->node, &base->active);
 
-        timer->state = HRTIMER_PENDING;
-
         if (!base->first || timer->expires.tv64 <
             rb_entry(base->first, struct hrtimer, node)->expires.tv64)
                 base->first = &timer->node;
@@ -376,6 +393,7 @@ static void __remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
         if (base->first == &timer->node)
                 base->first = rb_next(&timer->node);
         rb_erase(&timer->node, &base->active);
+        timer->node.rb_parent = HRTIMER_INACTIVE;
 }
 
 /*
@@ -386,7 +404,6 @@ remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
 {
         if (hrtimer_active(timer)) {
                 __remove_hrtimer(timer, base);
-                timer->state = HRTIMER_INACTIVE;
                 return 1;
         }
         return 0;
@@ -560,6 +577,7 @@ void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
                 clock_id = CLOCK_MONOTONIC;
 
         timer->base = &bases[clock_id];
+        timer->node.rb_parent = HRTIMER_INACTIVE;
 }
 
 /**
@@ -586,48 +604,35 @@ int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
  */
 static inline void run_hrtimer_queue(struct hrtimer_base *base)
 {
-        ktime_t now = base->get_time();
         struct rb_node *node;
 
+        if (base->get_softirq_time)
+                base->softirq_time = base->get_softirq_time();
+
         spin_lock_irq(&base->lock);
 
         while ((node = base->first)) {
                 struct hrtimer *timer;
-                int (*fn)(void *);
+                int (*fn)(struct hrtimer *);
                 int restart;
-                void *data;
 
                 timer = rb_entry(node, struct hrtimer, node);
-                if (now.tv64 <= timer->expires.tv64)
+                if (base->softirq_time.tv64 <= timer->expires.tv64)
                         break;
 
                 fn = timer->function;
-                data = timer->data;
                 set_curr_timer(base, timer);
-                timer->state = HRTIMER_RUNNING;
                 __remove_hrtimer(timer, base);
                 spin_unlock_irq(&base->lock);
 
-                /*
-                 * fn == NULL is special case for the simplest timer
-                 * variant - wake up process and do not restart:
-                 */
-                if (!fn) {
-                        wake_up_process(data);
-                        restart = HRTIMER_NORESTART;
-                } else
-                        restart = fn(data);
+                restart = fn(timer);
 
                 spin_lock_irq(&base->lock);
 
-                /* Another CPU has added back the timer */
-                if (timer->state != HRTIMER_RUNNING)
-                        continue;
-
-                if (restart == HRTIMER_RESTART)
+                if (restart != HRTIMER_NORESTART) {
+                        BUG_ON(hrtimer_active(timer));
                         enqueue_hrtimer(timer, base);
-                else
-                        timer->state = HRTIMER_EXPIRED;
+                }
         }
         set_curr_timer(base, NULL);
         spin_unlock_irq(&base->lock);
@@ -641,6 +646,8 @@ void hrtimer_run_queues(void)
         struct hrtimer_base *base = __get_cpu_var(hrtimer_bases);
         int i;
 
+        hrtimer_get_softirq_time(base);
+
         for (i = 0; i < MAX_HRTIMER_BASES; i++)
                 run_hrtimer_queue(&base[i]);
 }
@@ -649,79 +656,70 @@ void hrtimer_run_queues(void)
  * Sleep related functions:
  */
 
-/**
- * schedule_hrtimer - sleep until timeout
- *
- * @timer:      hrtimer variable initialized with the correct clock base
- * @mode:       timeout value is abs/rel
- *
- * Make the current task sleep until @timeout is
- * elapsed.
- *
- * You can set the task state as follows -
- *
- * %TASK_UNINTERRUPTIBLE - at least @timeout is guaranteed to
- * pass before the routine returns. The routine will return 0
- *
- * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
- * delivered to the current task. In this case the remaining time
- * will be returned
- *
- * The current task state is guaranteed to be TASK_RUNNING when this
- * routine returns.
- */
-static ktime_t __sched
-schedule_hrtimer(struct hrtimer *timer, const enum hrtimer_mode mode)
-{
-        /* fn stays NULL, meaning single-shot wakeup: */
-        timer->data = current;
+struct sleep_hrtimer {
+        struct hrtimer timer;
+        struct task_struct *task;
+        int expired;
+};
 
-        hrtimer_start(timer, timer->expires, mode);
+static int nanosleep_wakeup(struct hrtimer *timer)
+{
+        struct sleep_hrtimer *t =
+                container_of(timer, struct sleep_hrtimer, timer);
 
-        schedule();
-        hrtimer_cancel(timer);
+        t->expired = 1;
+        wake_up_process(t->task);
 
-        /* Return the remaining time: */
-        if (timer->state != HRTIMER_EXPIRED)
-                return ktime_sub(timer->expires, timer->base->get_time());
-        else
-                return (ktime_t) {.tv64 = 0 };
+        return HRTIMER_NORESTART;
 }
 
-static inline ktime_t __sched
-schedule_hrtimer_interruptible(struct hrtimer *timer,
-                               const enum hrtimer_mode mode)
+static int __sched do_nanosleep(struct sleep_hrtimer *t, enum hrtimer_mode mode)
 {
-        set_current_state(TASK_INTERRUPTIBLE);
+        t->timer.function = nanosleep_wakeup;
+        t->task = current;
+        t->expired = 0;
+
+        do {
+                set_current_state(TASK_INTERRUPTIBLE);
+                hrtimer_start(&t->timer, t->timer.expires, mode);
+
+                schedule();
+
+                if (unlikely(!t->expired)) {
+                        hrtimer_cancel(&t->timer);
+                        mode = HRTIMER_ABS;
+                }
+        } while (!t->expired && !signal_pending(current));
 
-        return schedule_hrtimer(timer, mode);
+        return t->expired;
 }
 
 static long __sched nanosleep_restart(struct restart_block *restart)
 {
+        struct sleep_hrtimer t;
         struct timespec __user *rmtp;
         struct timespec tu;
-        void *rfn_save = restart->fn;
-        struct hrtimer timer;
-        ktime_t rem;
+        ktime_t time;
 
         restart->fn = do_no_restart_syscall;
 
-        hrtimer_init(&timer, (clockid_t) restart->arg3, HRTIMER_ABS);
-
-        timer.expires.tv64 = ((u64)restart->arg1 << 32) | (u64) restart->arg0;
-
-        rem = schedule_hrtimer_interruptible(&timer, HRTIMER_ABS);
+        hrtimer_init(&t.timer, restart->arg3, HRTIMER_ABS);
+        t.timer.expires.tv64 = ((u64)restart->arg1 << 32) | (u64) restart->arg0;
 
-        if (rem.tv64 <= 0)
+        if (do_nanosleep(&t, HRTIMER_ABS))
                 return 0;
 
         rmtp = (struct timespec __user *) restart->arg2;
-        tu = ktime_to_timespec(rem);
-        if (rmtp && copy_to_user(rmtp, &tu, sizeof(tu)))
-                return -EFAULT;
+        if (rmtp) {
+                time = ktime_sub(t.timer.expires, t.timer.base->get_time());
+                if (time.tv64 <= 0)
+                        return 0;
+                tu = ktime_to_timespec(time);
+                if (copy_to_user(rmtp, &tu, sizeof(tu)))
+                        return -EFAULT;
+        }
 
-        restart->fn = rfn_save;
+        restart->fn = nanosleep_restart;
 
         /* The other values in restart are already filled in */
         return -ERESTART_RESTARTBLOCK;
@@ -731,33 +729,34 @@ long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
                        const enum hrtimer_mode mode, const clockid_t clockid)
 {
         struct restart_block *restart;
-        struct hrtimer timer;
+        struct sleep_hrtimer t;
         struct timespec tu;
         ktime_t rem;
 
-        hrtimer_init(&timer, clockid, mode);
-
-        timer.expires = timespec_to_ktime(*rqtp);
-
-        rem = schedule_hrtimer_interruptible(&timer, mode);
-        if (rem.tv64 <= 0)
+        hrtimer_init(&t.timer, clockid, mode);
+        t.timer.expires = timespec_to_ktime(*rqtp);
+        if (do_nanosleep(&t, mode))
                 return 0;
 
         /* Absolute timers do not update the rmtp value and restart: */
         if (mode == HRTIMER_ABS)
                 return -ERESTARTNOHAND;
 
-        tu = ktime_to_timespec(rem);
-
-        if (rmtp && copy_to_user(rmtp, &tu, sizeof(tu)))
-                return -EFAULT;
+        if (rmtp) {
+                rem = ktime_sub(t.timer.expires, t.timer.base->get_time());
+                if (rem.tv64 <= 0)
+                        return 0;
+                tu = ktime_to_timespec(rem);
+                if (copy_to_user(rmtp, &tu, sizeof(tu)))
+                        return -EFAULT;
+        }
 
         restart = &current_thread_info()->restart_block;
         restart->fn = nanosleep_restart;
-        restart->arg0 = timer.expires.tv64 & 0xFFFFFFFF;
-        restart->arg1 = timer.expires.tv64 >> 32;
+        restart->arg0 = t.timer.expires.tv64 & 0xFFFFFFFF;
+        restart->arg1 = t.timer.expires.tv64 >> 32;
         restart->arg2 = (unsigned long) rmtp;
-        restart->arg3 = (unsigned long) timer.base->index;
+        restart->arg3 = (unsigned long) t.timer.base->index;
 
         return -ERESTART_RESTARTBLOCK;
 }
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 6edfcef291e8..ac766ad573e8 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -271,6 +271,7 @@ void free_irq(unsigned int irq, void *dev_id)
         struct irqaction **p;
         unsigned long flags;
 
+        WARN_ON(in_interrupt());
         if (irq >= NR_IRQS)
                 return;
 
diff --git a/kernel/itimer.c b/kernel/itimer.c
index 680e6b70c872..204ed7939e75 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -128,16 +128,16 @@ asmlinkage long sys_getitimer(int which, struct itimerval __user *value)
 /*
  * The timer is automagically restarted, when interval != 0
  */
-int it_real_fn(void *data)
+int it_real_fn(struct hrtimer *timer)
 {
-        struct task_struct *tsk = (struct task_struct *) data;
+        struct signal_struct *sig =
+            container_of(timer, struct signal_struct, real_timer);
 
-        send_group_sig_info(SIGALRM, SEND_SIG_PRIV, tsk);
-
-        if (tsk->signal->it_real_incr.tv64 != 0) {
-                hrtimer_forward(&tsk->signal->real_timer,
-                               tsk->signal->it_real_incr);
+        send_group_sig_info(SIGALRM, SEND_SIG_PRIV, sig->tsk);
 
+        if (sig->it_real_incr.tv64 != 0) {
+                hrtimer_forward(timer, timer->base->softirq_time,
+                                sig->it_real_incr);
                 return HRTIMER_RESTART;
         }
         return HRTIMER_NORESTART;
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 1fb9f753ef60..1156eb0977d0 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -323,10 +323,10 @@ struct hlist_head __kprobes *kretprobe_inst_table_head(struct task_struct *tsk)
 }
 
 /*
- * This function is called from exit_thread or flush_thread when task tk's
- * stack is being recycled so that we can recycle any function-return probe
- * instances associated with this task. These left over instances represent
- * probed functions that have been called but will never return.
+ * This function is called from finish_task_switch when task tk becomes dead,
+ * so that we can recycle any function-return probe instances associated
+ * with this task. These left over instances represent probed functions
+ * that have been called but will never return.
  */
 void __kprobes kprobe_flush_task(struct task_struct *tk)
 {
@@ -336,7 +336,7 @@ void __kprobes kprobe_flush_task(struct task_struct *tk)
         unsigned long flags = 0;
 
         spin_lock_irqsave(&kretprobe_lock, flags);
-        head = kretprobe_inst_table_head(current);
+        head = kretprobe_inst_table_head(tk);
         hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
                 if (ri->task == tk)
                         recycle_rp_inst(ri);
diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index 9944379360b5..ac6dc8744429 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -145,7 +145,7 @@ static int common_timer_set(struct k_itimer *, int,
                             struct itimerspec *, struct itimerspec *);
 static int common_timer_del(struct k_itimer *timer);
 
-static int posix_timer_fn(void *data);
+static int posix_timer_fn(struct hrtimer *data);
 
 static struct k_itimer *lock_timer(timer_t timer_id, unsigned long *flags);
 
@@ -251,15 +251,18 @@ __initcall(init_posix_timers);
 
 static void schedule_next_timer(struct k_itimer *timr)
 {
+        struct hrtimer *timer = &timr->it.real.timer;
+
         if (timr->it.real.interval.tv64 == 0)
                 return;
 
-        timr->it_overrun += hrtimer_forward(&timr->it.real.timer,
+        timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(),
                                             timr->it.real.interval);
+
         timr->it_overrun_last = timr->it_overrun;
         timr->it_overrun = -1;
         ++timr->it_requeue_pending;
-        hrtimer_restart(&timr->it.real.timer);
+        hrtimer_restart(timer);
 }
 
 /*
@@ -331,13 +334,14 @@ EXPORT_SYMBOL_GPL(posix_timer_event);
 
  * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
  */
-static int posix_timer_fn(void *data)
+static int posix_timer_fn(struct hrtimer *timer)
 {
-        struct k_itimer *timr = data;
+        struct k_itimer *timr;
         unsigned long flags;
         int si_private = 0;
         int ret = HRTIMER_NORESTART;
 
+        timr = container_of(timer, struct k_itimer, it.real.timer);
         spin_lock_irqsave(&timr->it_lock, flags);
 
         if (timr->it.real.interval.tv64 != 0)
@@ -351,7 +355,8 @@ static int posix_timer_fn(void *data)
                  */
                 if (timr->it.real.interval.tv64 != 0) {
                         timr->it_overrun +=
-                                hrtimer_forward(&timr->it.real.timer,
+                                hrtimer_forward(timer,
+                                                timer->base->softirq_time,
                                                 timr->it.real.interval);
                         ret = HRTIMER_RESTART;
                         ++timr->it_requeue_pending;
@@ -603,38 +608,41 @@ static struct k_itimer * lock_timer(timer_t timer_id, unsigned long *flags)
 static void
 common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
 {
-        ktime_t remaining;
+        ktime_t now, remaining, iv;
         struct hrtimer *timer = &timr->it.real.timer;
 
         memset(cur_setting, 0, sizeof(struct itimerspec));
-        remaining = hrtimer_get_remaining(timer);
 
-        /* Time left ? or timer pending */
-        if (remaining.tv64 > 0 || hrtimer_active(timer))
-                goto calci;
+        iv = timr->it.real.interval;
+
         /* interval timer ? */
-        if (timr->it.real.interval.tv64 == 0)
+        if (iv.tv64)
+                cur_setting->it_interval = ktime_to_timespec(iv);
+        else if (!hrtimer_active(timer) &&
+                 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
                 return;
+
+        now = timer->base->get_time();
+
         /*
-         * When a requeue is pending or this is a SIGEV_NONE timer
-         * move the expiry time forward by intervals, so expiry is >
-         * now.
+         * When a requeue is pending or this is a SIGEV_NONE
+         * timer move the expiry time forward by intervals, so
+         * expiry is > now.
          */
-        if (timr->it_requeue_pending & REQUEUE_PENDING ||
-            (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
-                timr->it_overrun +=
-                        hrtimer_forward(timer, timr->it.real.interval);
-                remaining = hrtimer_get_remaining(timer);
-        }
- calci:
-        /* interval timer ? */
-        if (timr->it.real.interval.tv64 != 0)
-                cur_setting->it_interval =
-                        ktime_to_timespec(timr->it.real.interval);
+        if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
+            (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
+                timr->it_overrun += hrtimer_forward(timer, now, iv);
+
+        remaining = ktime_sub(timer->expires, now);
         /* Return 0 only, when the timer is expired and not pending */
-        if (remaining.tv64 <= 0)
-                cur_setting->it_value.tv_nsec = 1;
-        else
+        if (remaining.tv64 <= 0) {
+                /*
+                 * A single shot SIGEV_NONE timer must return 0, when
+                 * it is expired !
+                 */
+                if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
+                        cur_setting->it_value.tv_nsec = 1;
+        } else
                 cur_setting->it_value = ktime_to_timespec(remaining);
 }
 
@@ -717,7 +725,6 @@ common_timer_set(struct k_itimer *timr, int flags,
 
         mode = flags & TIMER_ABSTIME ? HRTIMER_ABS : HRTIMER_REL;
         hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
-        timr->it.real.timer.data = timr;
         timr->it.real.timer.function = posix_timer_fn;
 
         timer->expires = timespec_to_ktime(new_setting->it_value);
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 9177f3f73a6c..044b8e0c1025 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -454,10 +454,11 @@ static int load_image(struct swap_map_handle *handle,
                         nr_pages++;
                 }
         } while (ret > 0);
-        if (!error)
+        if (!error) {
                 printk("\b\b\b\bdone\n");
-        if (!snapshot_image_loaded(snapshot))
-                error = -ENODATA;
+                if (!snapshot_image_loaded(snapshot))
+                        error = -ENODATA;
+        }
         return error;
 }
 
diff --git a/kernel/sched.c b/kernel/sched.c
index 7ffaabd64f89..78acdefeccca 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -49,6 +49,7 @@
 #include <linux/syscalls.h>
 #include <linux/times.h>
 #include <linux/acct.h>
+#include <linux/kprobes.h>
 #include <asm/tlb.h>
 
 #include <asm/unistd.h>
@@ -1546,8 +1547,14 @@ static inline void finish_task_switch(runqueue_t *rq, task_t *prev)
         finish_lock_switch(rq, prev);
         if (mm)
                 mmdrop(mm);
-        if (unlikely(prev_task_flags & PF_DEAD))
+        if (unlikely(prev_task_flags & PF_DEAD)) {
+                /*
+                 * Remove function-return probe instances associated with this
+                 * task and put them back on the free list.
+                 */
+                kprobe_flush_task(prev);
                 put_task_struct(prev);
+        }
 }
 
 /**
diff --git a/kernel/time.c b/kernel/time.c
index e00a97b77241..ff8e7019c4c4 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -610,7 +610,7 @@ void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
  *
  * Returns the timespec representation of the nsec parameter.
  */
-struct timespec ns_to_timespec(const nsec_t nsec)
+struct timespec ns_to_timespec(const s64 nsec)
 {
         struct timespec ts;
 
@@ -630,7 +630,7 @@ struct timespec ns_to_timespec(const nsec_t nsec)
  *
  * Returns the timeval representation of the nsec parameter.
  */
-struct timeval ns_to_timeval(const nsec_t nsec)
+struct timeval ns_to_timeval(const s64 nsec)
 {
         struct timespec ts = ns_to_timespec(nsec);
         struct timeval tv;