Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git

Signed-off-by: Steve French <sfrench@us.ibm.com>

1 files changed, 169 insertions, 718 deletions

diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index 5870efb3e200..9e66e614862a 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -48,21 +48,6 @@
 #include <linux/workqueue.h>
 #include <linux/module.h>
 
-#ifndef div_long_long_rem
-#include <asm/div64.h>
-
-#define div_long_long_rem(dividend,divisor,remainder) ({ \
-                       u64 result = dividend;           \
-                       *remainder = do_div(result,divisor); \
-                       result; })
-
-#endif
-#define CLOCK_REALTIME_RES TICK_NSEC  /* In nano seconds. */
-
-static inline u64  mpy_l_X_l_ll(unsigned long mpy1,unsigned long mpy2)
-{
-        return (u64)mpy1 * mpy2;
-}
 /*
  * Management arrays for POSIX timers.   Timers are kept in slab memory
  * Timer ids are allocated by an external routine that keeps track of the
@@ -148,18 +133,18 @@ static DEFINE_SPINLOCK(idr_lock);
  */
 
 static struct k_clock posix_clocks[MAX_CLOCKS];
+
 /*
- * We only have one real clock that can be set so we need only one abs list,
- * even if we should want to have several clocks with differing resolutions.
+ * These ones are defined below.
  */
-static struct k_clock_abs abs_list = {.list = LIST_HEAD_INIT(abs_list.list),
-                                      .lock = SPIN_LOCK_UNLOCKED};
+static int common_nsleep(const clockid_t, int flags, struct timespec *t,
+                         struct timespec __user *rmtp);
+static void common_timer_get(struct k_itimer *, struct itimerspec *);
+static int common_timer_set(struct k_itimer *, int,
+                            struct itimerspec *, struct itimerspec *);
+static int common_timer_del(struct k_itimer *timer);
 
-static void posix_timer_fn(unsigned long);
-static u64 do_posix_clock_monotonic_gettime_parts(
-        struct timespec *tp, struct timespec *mo);
-int do_posix_clock_monotonic_gettime(struct timespec *tp);
-static int do_posix_clock_monotonic_get(clockid_t, struct timespec *tp);
+static int posix_timer_fn(void *data);
 
 static struct k_itimer *lock_timer(timer_t timer_id, unsigned long *flags);
 
@@ -184,7 +169,7 @@ static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
  * the function pointer CALL in struct k_clock.
  */
 
-static inline int common_clock_getres(clockid_t which_clock,
+static inline int common_clock_getres(const clockid_t which_clock,
                                       struct timespec *tp)
 {
         tp->tv_sec = 0;
@@ -192,39 +177,33 @@ static inline int common_clock_getres(clockid_t which_clock,
         return 0;
 }
 
-static inline int common_clock_get(clockid_t which_clock, struct timespec *tp)
+/*
+ * Get real time for posix timers
+ */
+static int common_clock_get(clockid_t which_clock, struct timespec *tp)
 {
-        getnstimeofday(tp);
+        ktime_get_real_ts(tp);
         return 0;
 }
 
-static inline int common_clock_set(clockid_t which_clock, struct timespec *tp)
+static inline int common_clock_set(const clockid_t which_clock,
+                                   struct timespec *tp)
 {
         return do_sys_settimeofday(tp, NULL);
 }
 
 static inline int common_timer_create(struct k_itimer *new_timer)
 {
-        INIT_LIST_HEAD(&new_timer->it.real.abs_timer_entry);
-        init_timer(&new_timer->it.real.timer);
-        new_timer->it.real.timer.data = (unsigned long) new_timer;
+        hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock);
+        new_timer->it.real.timer.data = new_timer;
         new_timer->it.real.timer.function = posix_timer_fn;
         return 0;
 }
 
 /*
- * These ones are defined below.
- */
-static int common_nsleep(clockid_t, int flags, struct timespec *t);
-static void common_timer_get(struct k_itimer *, struct itimerspec *);
-static int common_timer_set(struct k_itimer *, int,
-                            struct itimerspec *, struct itimerspec *);
-static int common_timer_del(struct k_itimer *timer);
-
-/*
- * Return nonzero iff we know a priori this clockid_t value is bogus.
+ * Return nonzero if we know a priori this clockid_t value is bogus.
  */
-static inline int invalid_clockid(clockid_t which_clock)
+static inline int invalid_clockid(const clockid_t which_clock)
 {
         if (which_clock < 0)    /* CPU clock, posix_cpu_* will check it */
                 return 0;
@@ -232,26 +211,32 @@ static inline int invalid_clockid(clockid_t which_clock)
                 return 1;
         if (posix_clocks[which_clock].clock_getres != NULL)
                 return 0;
-#ifndef CLOCK_DISPATCH_DIRECT
         if (posix_clocks[which_clock].res != 0)
                 return 0;
-#endif
         return 1;
 }
 
+/*
+ * Get monotonic time for posix timers
+ */
+static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp)
+{
+        ktime_get_ts(tp);
+        return 0;
+}
 
 /*
  * Initialize everything, well, just everything in Posix clocks/timers ;)
  */
 static __init int init_posix_timers(void)
 {
-        struct k_clock clock_realtime = {.res = CLOCK_REALTIME_RES,
-                                         .abs_struct = &abs_list
+        struct k_clock clock_realtime = {
+                .clock_getres = hrtimer_get_res,
         };
-        struct k_clock clock_monotonic = {.res = CLOCK_REALTIME_RES,
-                .abs_struct = NULL,
-                .clock_get = do_posix_clock_monotonic_get,
-                .clock_set = do_posix_clock_nosettime
+        struct k_clock clock_monotonic = {
+                .clock_getres = hrtimer_get_res,
+                .clock_get = posix_ktime_get_ts,
+                .clock_set = do_posix_clock_nosettime,
         };
 
         register_posix_clock(CLOCK_REALTIME, &clock_realtime);
@@ -265,117 +250,17 @@ static __init int init_posix_timers(void)
 
 __initcall(init_posix_timers);
 
-static void tstojiffie(struct timespec *tp, int res, u64 *jiff)
-{
-        long sec = tp->tv_sec;
-        long nsec = tp->tv_nsec + res - 1;
-
-        if (nsec >= NSEC_PER_SEC) {
-                sec++;
-                nsec -= NSEC_PER_SEC;
-        }
-
-        /*
-         * The scaling constants are defined in <linux/time.h>
-         * The difference between there and here is that we do the
-         * res rounding and compute a 64-bit result (well so does that
-         * but it then throws away the high bits).
-         */
-        *jiff =  (mpy_l_X_l_ll(sec, SEC_CONVERSION) +
-                  (mpy_l_X_l_ll(nsec, NSEC_CONVERSION) >> 
-                   (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
-}
-
-/*
- * This function adjusts the timer as needed as a result of the clock
- * being set.  It should only be called for absolute timers, and then
- * under the abs_list lock.  It computes the time difference and sets
- * the new jiffies value in the timer.  It also updates the timers
- * reference wall_to_monotonic value.  It is complicated by the fact
- * that tstojiffies() only handles positive times and it needs to work
- * with both positive and negative times.  Also, for negative offsets,
- * we need to defeat the res round up.
- *
- * Return is true if there is a new time, else false.
- */
-static long add_clockset_delta(struct k_itimer *timr,
-                               struct timespec *new_wall_to)
-{
-        struct timespec delta;
-        int sign = 0;
-        u64 exp;
-
-        set_normalized_timespec(&delta,
-                                new_wall_to->tv_sec -
-                                timr->it.real.wall_to_prev.tv_sec,
-                                new_wall_to->tv_nsec -
-                                timr->it.real.wall_to_prev.tv_nsec);
-        if (likely(!(delta.tv_sec | delta.tv_nsec)))
-                return 0;
-        if (delta.tv_sec < 0) {
-                set_normalized_timespec(&delta,
-                                        -delta.tv_sec,
-                                        1 - delta.tv_nsec -
-                                        posix_clocks[timr->it_clock].res);
-                sign++;
-        }
-        tstojiffie(&delta, posix_clocks[timr->it_clock].res, &exp);
-        timr->it.real.wall_to_prev = *new_wall_to;
-        timr->it.real.timer.expires += (sign ? -exp : exp);
-        return 1;
-}
-
-static void remove_from_abslist(struct k_itimer *timr)
-{
-        if (!list_empty(&timr->it.real.abs_timer_entry)) {
-                spin_lock(&abs_list.lock);
-                list_del_init(&timr->it.real.abs_timer_entry);
-                spin_unlock(&abs_list.lock);
-        }
-}
-
 static void schedule_next_timer(struct k_itimer *timr)
 {
-        struct timespec new_wall_to;
-        struct now_struct now;
-        unsigned long seq;
-
-        /*
-         * Set up the timer for the next interval (if there is one).
-         * Note: this code uses the abs_timer_lock to protect
-         * it.real.wall_to_prev and must hold it until exp is set, not exactly
-         * obvious...
-
-         * This function is used for CLOCK_REALTIME* and
-         * CLOCK_MONOTONIC* timers.  If we ever want to handle other
-         * CLOCKs, the calling code (do_schedule_next_timer) would need
-         * to pull the "clock" info from the timer and dispatch the
-         * "other" CLOCKs "next timer" code (which, I suppose should
-         * also be added to the k_clock structure).
-         */
-        if (!timr->it.real.incr)
+        if (timr->it.real.interval.tv64 == 0)
                 return;
 
-        do {
-                seq = read_seqbegin(&xtime_lock);
-                new_wall_to =   wall_to_monotonic;
-                posix_get_now(&now);
-        } while (read_seqretry(&xtime_lock, seq));
-
-        if (!list_empty(&timr->it.real.abs_timer_entry)) {
-                spin_lock(&abs_list.lock);
-                add_clockset_delta(timr, &new_wall_to);
-
-                posix_bump_timer(timr, now);
-
-                spin_unlock(&abs_list.lock);
-        } else {
-                posix_bump_timer(timr, now);
-        }
+        timr->it_overrun += hrtimer_forward(&timr->it.real.timer,
+                                            timr->it.real.interval);
         timr->it_overrun_last = timr->it_overrun;
         timr->it_overrun = -1;
         ++timr->it_requeue_pending;
-        add_timer(&timr->it.real.timer);
+        hrtimer_restart(&timr->it.real.timer);
 }
 
 /*
@@ -396,31 +281,23 @@ void do_schedule_next_timer(struct siginfo *info)
 
         timr = lock_timer(info->si_tid, &flags);
 
-        if (!timr || timr->it_requeue_pending != info->si_sys_private)
-                goto exit;
+        if (timr && timr->it_requeue_pending == info->si_sys_private) {
+                if (timr->it_clock < 0)
+                        posix_cpu_timer_schedule(timr);
+                else
+                        schedule_next_timer(timr);
 
-        if (timr->it_clock < 0) /* CPU clock */
-                posix_cpu_timer_schedule(timr);
-        else
-                schedule_next_timer(timr);
-        info->si_overrun = timr->it_overrun_last;
-exit:
-        if (timr)
-                unlock_timer(timr, flags);
+                info->si_overrun = timr->it_overrun_last;
+        }
+
+        unlock_timer(timr, flags);
 }
 
 int posix_timer_event(struct k_itimer *timr,int si_private)
 {
         memset(&timr->sigq->info, 0, sizeof(siginfo_t));
         timr->sigq->info.si_sys_private = si_private;
-        /*
-         * Send signal to the process that owns this timer.
-
-         * This code assumes that all the possible abs_lists share the
-         * same lock (there is only one list at this time). If this is
-         * not the case, the CLOCK info would need to be used to find
-         * the proper abs list lock.
-         */
+        /* Send signal to the process that owns this timer.*/
 
         timr->sigq->info.si_signo = timr->it_sigev_signo;
         timr->sigq->info.si_errno = 0;
@@ -454,64 +331,35 @@ EXPORT_SYMBOL_GPL(posix_timer_event);
 
  * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
  */
-static void posix_timer_fn(unsigned long __data)
+static int posix_timer_fn(void *data)
 {
-        struct k_itimer *timr = (struct k_itimer *) __data;
+        struct k_itimer *timr = data;
         unsigned long flags;
-        unsigned long seq;
-        struct timespec delta, new_wall_to;
-        u64 exp = 0;
-        int do_notify = 1;
+        int si_private = 0;
+        int ret = HRTIMER_NORESTART;
 
         spin_lock_irqsave(&timr->it_lock, flags);
-        if (!list_empty(&timr->it.real.abs_timer_entry)) {
-                spin_lock(&abs_list.lock);
-                do {
-                        seq = read_seqbegin(&xtime_lock);
-                        new_wall_to =   wall_to_monotonic;
-                } while (read_seqretry(&xtime_lock, seq));
-                set_normalized_timespec(&delta,
-                                        new_wall_to.tv_sec -
-                                        timr->it.real.wall_to_prev.tv_sec,
-                                        new_wall_to.tv_nsec -
-                                        timr->it.real.wall_to_prev.tv_nsec);
-                if (likely((delta.tv_sec | delta.tv_nsec ) == 0)) {
-                        /* do nothing, timer is on time */
-                } else if (delta.tv_sec < 0) {
-                        /* do nothing, timer is already late */
-                } else {
-                        /* timer is early due to a clock set */
-                        tstojiffie(&delta,
-                                   posix_clocks[timr->it_clock].res,
-                                   &exp);
-                        timr->it.real.wall_to_prev = new_wall_to;
-                        timr->it.real.timer.expires += exp;
-                        add_timer(&timr->it.real.timer);
-                        do_notify = 0;
-                }
-                spin_unlock(&abs_list.lock);
 
-        }
-        if (do_notify)  {
-                int si_private=0;
+        if (timr->it.real.interval.tv64 != 0)
+                si_private = ++timr->it_requeue_pending;
 
-                if (timr->it.real.incr)
-                        si_private = ++timr->it_requeue_pending;
-                else {
-                        remove_from_abslist(timr);
+        if (posix_timer_event(timr, si_private)) {
+                /*
+                 * signal was not sent because of sig_ignor
+                 * we will not get a call back to restart it AND
+                 * it should be restarted.
+                 */
+                if (timr->it.real.interval.tv64 != 0) {
+                        timr->it_overrun +=
+                                hrtimer_forward(&timr->it.real.timer,
+                                                timr->it.real.interval);
+                        ret = HRTIMER_RESTART;
                 }
-
-                if (posix_timer_event(timr, si_private))
-                        /*
-                         * signal was not sent because of sig_ignor
-                         * we will not get a call back to restart it AND
-                         * it should be restarted.
-                         */
-                        schedule_next_timer(timr);
         }
-        unlock_timer(timr, flags); /* hold thru abs lock to keep irq off */
-}
 
+        unlock_timer(timr, flags);
+        return ret;
+}
 
 static inline struct task_struct * good_sigevent(sigevent_t * event)
 {
@@ -530,7 +378,7 @@ static inline struct task_struct * good_sigevent(sigevent_t * event)
         return rtn;
 }
 
-void register_posix_clock(clockid_t clock_id, struct k_clock *new_clock)
+void register_posix_clock(const clockid_t clock_id, struct k_clock *new_clock)
 {
         if ((unsigned) clock_id >= MAX_CLOCKS) {
                 printk("POSIX clock register failed for clock_id %d\n",
@@ -576,7 +424,7 @@ static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
 /* Create a POSIX.1b interval timer. */
 
 asmlinkage long
-sys_timer_create(clockid_t which_clock,
+sys_timer_create(const clockid_t which_clock,
                  struct sigevent __user *timer_event_spec,
                  timer_t __user * created_timer_id)
 {
@@ -602,8 +450,7 @@ sys_timer_create(clockid_t which_clock,
                 goto out;
         }
         spin_lock_irq(&idr_lock);
-        error = idr_get_new(&posix_timers_id,
-                            (void *) new_timer,
+        error = idr_get_new(&posix_timers_id, (void *) new_timer,
                             &new_timer_id);
         spin_unlock_irq(&idr_lock);
         if (error == -EAGAIN)
@@ -704,27 +551,6 @@ out:
 }
 
 /*
- * good_timespec
- *
- * This function checks the elements of a timespec structure.
- *
- * Arguments:
- * ts        : Pointer to the timespec structure to check
- *
- * Return value:
- * If a NULL pointer was passed in, or the tv_nsec field was less than 0
- * or greater than NSEC_PER_SEC, or the tv_sec field was less than 0,
- * this function returns 0. Otherwise it returns 1.
- */
-static int good_timespec(const struct timespec *ts)
-{
-        if ((!ts) || (ts->tv_sec < 0) ||
-                        ((unsigned) ts->tv_nsec >= NSEC_PER_SEC))
-                return 0;
-        return 1;
-}
-
-/*
  * Locking issues: We need to protect the result of the id look up until
  * we get the timer locked down so it is not deleted under us.  The
  * removal is done under the idr spinlock so we use that here to bridge
@@ -776,39 +602,39 @@ 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)
 {
-        unsigned long expires;
-        struct now_struct now;
-
-        do
-                expires = timr->it.real.timer.expires;
-        while ((volatile long) (timr->it.real.timer.expires) != expires);
-
-        posix_get_now(&now);
-
-        if (expires &&
-            ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) &&
-            !timr->it.real.incr &&
-            posix_time_before(&timr->it.real.timer, &now))
-                timr->it.real.timer.expires = expires = 0;
-        if (expires) {
-                if (timr->it_requeue_pending & REQUEUE_PENDING ||
-                    (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
-                        posix_bump_timer(timr, now);
-                        expires = timr->it.real.timer.expires;
-                }
-                else
-                        if (!timer_pending(&timr->it.real.timer))
-                                expires = 0;
-                if (expires)
-                        expires -= now.jiffies;
-        }
-        jiffies_to_timespec(expires, &cur_setting->it_value);
-        jiffies_to_timespec(timr->it.real.incr, &cur_setting->it_interval);
+        ktime_t remaining;
+        struct hrtimer *timer = &timr->it.real.timer;
+
+        memset(cur_setting, 0, sizeof(struct itimerspec));
+        remaining = hrtimer_get_remaining(timer);
 
-        if (cur_setting->it_value.tv_sec < 0) {
+        /* Time left ? or timer pending */
+        if (remaining.tv64 > 0 || hrtimer_active(timer))
+                goto calci;
+        /* interval timer ? */
+        if (timr->it.real.interval.tv64 == 0)
+                return;
+        /*
+         * 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);
+        /* Return 0 only, when the timer is expired and not pending */
+        if (remaining.tv64 <= 0)
                 cur_setting->it_value.tv_nsec = 1;
-                cur_setting->it_value.tv_sec = 0;
-        }
+        else
+                cur_setting->it_value = ktime_to_timespec(remaining);
 }
 
 /* Get the time remaining on a POSIX.1b interval timer. */
@@ -832,6 +658,7 @@ sys_timer_gettime(timer_t timer_id, struct itimerspec __user *setting)
 
         return 0;
 }
+
 /*
  * Get the number of overruns of a POSIX.1b interval timer.  This is to
  * be the overrun of the timer last delivered.  At the same time we are
@@ -841,7 +668,6 @@ 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
 sys_timer_getoverrun(timer_t timer_id)
 {
@@ -858,84 +684,6 @@ sys_timer_getoverrun(timer_t timer_id)
 
         return overrun;
 }
-/*
- * Adjust for absolute time
- *
- * If absolute time is given and it is not CLOCK_MONOTONIC, we need to
- * adjust for the offset between the timer clock (CLOCK_MONOTONIC) and
- * what ever clock he is using.
- *
- * If it is relative time, we need to add the current (CLOCK_MONOTONIC)
- * time to it to get the proper time for the timer.
- */
-static int adjust_abs_time(struct k_clock *clock, struct timespec *tp, 
-                           int abs, u64 *exp, struct timespec *wall_to)
-{
-        struct timespec now;
-        struct timespec oc = *tp;
-        u64 jiffies_64_f;
-        int rtn =0;
-
-        if (abs) {
-                /*
-                 * The mask pick up the 4 basic clocks 
-                 */
-                if (!((clock - &posix_clocks[0]) & ~CLOCKS_MASK)) {
-                        jiffies_64_f = do_posix_clock_monotonic_gettime_parts(
-                                &now,  wall_to);
-                        /*
-                         * If we are doing a MONOTONIC clock
-                         */
-                        if((clock - &posix_clocks[0]) & CLOCKS_MONO){
-                                now.tv_sec += wall_to->tv_sec;
-                                now.tv_nsec += wall_to->tv_nsec;
-                        }
-                } else {
-                        /*
-                         * Not one of the basic clocks
-                         */
-                        clock->clock_get(clock - posix_clocks, &now);
-                        jiffies_64_f = get_jiffies_64();
-                }
-                /*
-                 * Take away now to get delta and normalize
-                 */
-                set_normalized_timespec(&oc, oc.tv_sec - now.tv_sec,
-                                        oc.tv_nsec - now.tv_nsec);
-        }else{
-                jiffies_64_f = get_jiffies_64();
-        }
-        /*
-         * Check if the requested time is prior to now (if so set now)
-         */
-        if (oc.tv_sec < 0)
-                oc.tv_sec = oc.tv_nsec = 0;
-
-        if (oc.tv_sec | oc.tv_nsec)
-                set_normalized_timespec(&oc, oc.tv_sec,
-                                        oc.tv_nsec + clock->res);
-        tstojiffie(&oc, clock->res, exp);
-
-        /*
-         * Check if the requested time is more than the timer code
-         * can handle (if so we error out but return the value too).
-         */
-        if (*exp > ((u64)MAX_JIFFY_OFFSET))
-                        /*
-                         * This is a considered response, not exactly in
-                         * line with the standard (in fact it is silent on
-                         * possible overflows).  We assume such a large 
-                         * value is ALMOST always a programming error and
-                         * try not to compound it by setting a really dumb
-                         * value.
-                         */
-                        rtn = -EINVAL;
-        /*
-         * return the actual jiffies expire time, full 64 bits
-         */
-        *exp += jiffies_64_f;
-        return rtn;
-}
 
 /* Set a POSIX.1b interval timer. */
 /* timr->it_lock is taken. */
@@ -943,68 +691,48 @@ static inline int
 common_timer_set(struct k_itimer *timr, int flags,
                  struct itimerspec *new_setting, struct itimerspec *old_setting)
 {
-        struct k_clock *clock = &posix_clocks[timr->it_clock];
-        u64 expire_64;
+        struct hrtimer *timer = &timr->it.real.timer;
 
         if (old_setting)
                 common_timer_get(timr, old_setting);
 
         /* disable the timer */
-        timr->it.real.incr = 0;
+        timr->it.real.interval.tv64 = 0;
         /*
          * careful here.  If smp we could be in the "fire" routine which will
          * be spinning as we hold the lock.  But this is ONLY an SMP issue.
          */
-        if (try_to_del_timer_sync(&timr->it.real.timer) < 0) {
-#ifdef CONFIG_SMP
-                /*
-                 * It can only be active if on an other cpu.  Since
-                 * we have cleared the interval stuff above, it should
-                 * clear once we release the spin lock.  Of course once
-                 * we do that anything could happen, including the
-                 * complete melt down of the timer.  So return with
-                 * a "retry" exit status.
-                 */
+        if (hrtimer_try_to_cancel(timer) < 0)
                 return TIMER_RETRY;
-#endif
-        }
-
-        remove_from_abslist(timr);
 
         timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 
                 ~REQUEUE_PENDING;
         timr->it_overrun_last = 0;
-        timr->it_overrun = -1;
-        /*
-         *switch off the timer when it_value is zero
-         */
-        if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec) {
-                timr->it.real.timer.expires = 0;
-                return 0;
-        }
 
-        if (adjust_abs_time(clock,
-                            &new_setting->it_value, flags & TIMER_ABSTIME, 
-                            &expire_64, &(timr->it.real.wall_to_prev))) {
-                return -EINVAL;
-        }
-        timr->it.real.timer.expires = (unsigned long)expire_64;
-        tstojiffie(&new_setting->it_interval, clock->res, &expire_64);
-        timr->it.real.incr = (unsigned long)expire_64;
+        /* switch off the timer when it_value is zero */
+        if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
+                return 0;
 
-        /*
-         * We do not even queue SIGEV_NONE timers!  But we do put them
-         * in the abs list so we can do that right.
+        /* Posix madness. Only absolute CLOCK_REALTIME timers
+         * are affected by clock sets. So we must reiniatilize
+         * the timer.
          */
-        if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE))
-                add_timer(&timr->it.real.timer);
-
-        if (flags & TIMER_ABSTIME && clock->abs_struct) {
-                spin_lock(&clock->abs_struct->lock);
-                list_add_tail(&(timr->it.real.abs_timer_entry),
-                              &(clock->abs_struct->list));
-                spin_unlock(&clock->abs_struct->lock);
-        }
+        if (timr->it_clock == CLOCK_REALTIME && (flags & TIMER_ABSTIME))
+                hrtimer_rebase(timer, CLOCK_REALTIME);
+        else
+                hrtimer_rebase(timer, CLOCK_MONOTONIC);
+
+        timer->expires = timespec_to_ktime(new_setting->it_value);
+
+        /* Convert interval */
+        timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
+
+        /* SIGEV_NONE timers are not queued ! See common_timer_get */
+        if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
+                return 0;
+
+        hrtimer_start(timer, timer->expires, (flags & TIMER_ABSTIME) ?
+                      HRTIMER_ABS : HRTIMER_REL);
         return 0;
 }
 
@@ -1026,8 +754,8 @@ sys_timer_settime(timer_t timer_id, int flags,
         if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
                 return -EFAULT;
 
-        if ((!good_timespec(&new_spec.it_interval)) ||
-            (!good_timespec(&new_spec.it_value)))
+        if (!timespec_valid(&new_spec.it_interval) ||
+            !timespec_valid(&new_spec.it_value))
                 return -EINVAL;
 retry:
         timr = lock_timer(timer_id, &flag);
@@ -1043,8 +771,8 @@ retry:
                 goto retry;
         }
 
-        if (old_setting && !error && copy_to_user(old_setting,
-                                                  &old_spec, sizeof (old_spec)))
+        if (old_setting && !error &&
+            copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
                 error = -EFAULT;
 
         return error;
@@ -1052,24 +780,10 @@ retry:
 
 static inline int common_timer_del(struct k_itimer *timer)
 {
-        timer->it.real.incr = 0;
+        timer->it.real.interval.tv64 = 0;
 
-        if (try_to_del_timer_sync(&timer->it.real.timer) < 0) {
-#ifdef CONFIG_SMP
-                /*
-                 * It can only be active if on an other cpu.  Since
-                 * we have cleared the interval stuff above, it should
-                 * clear once we release the spin lock.  Of course once
-                 * we do that anything could happen, including the
-                 * complete melt down of the timer.  So return with
-                 * a "retry" exit status.
-                 */
+        if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
                 return TIMER_RETRY;
-#endif
-        }
-
-        remove_from_abslist(timer);
-
         return 0;
 }
 
@@ -1085,24 +799,16 @@ sys_timer_delete(timer_t timer_id)
         struct k_itimer *timer;
         long flags;
 
-#ifdef CONFIG_SMP
-        int error;
 retry_delete:
-#endif
         timer = lock_timer(timer_id, &flags);
         if (!timer)
                 return -EINVAL;
 
-#ifdef CONFIG_SMP
-        error = timer_delete_hook(timer);
-
-        if (error == TIMER_RETRY) {
+        if (timer_delete_hook(timer) == TIMER_RETRY) {
                 unlock_timer(timer, flags);
                 goto retry_delete;
         }
-#else
-        timer_delete_hook(timer);
-#endif
+
         spin_lock(&current->sighand->siglock);
         list_del(&timer->list);
         spin_unlock(&current->sighand->siglock);
@@ -1119,6 +825,7 @@ retry_delete:
         release_posix_timer(timer, IT_ID_SET);
         return 0;
 }
+
 /*
  * return timer owned by the process, used by exit_itimers
  */
@@ -1126,22 +833,13 @@ static inline void itimer_delete(struct k_itimer *timer)
 {
         unsigned long flags;
 
-#ifdef CONFIG_SMP
-        int error;
 retry_delete:
-#endif
         spin_lock_irqsave(&timer->it_lock, flags);
 
-#ifdef CONFIG_SMP
-        error = timer_delete_hook(timer);
-
-        if (error == TIMER_RETRY) {
+        if (timer_delete_hook(timer) == TIMER_RETRY) {
                 unlock_timer(timer, flags);
                 goto retry_delete;
         }
-#else
-        timer_delete_hook(timer);
-#endif
         list_del(&timer->list);
         /*
          * This keeps any tasks waiting on the spin lock from thinking
@@ -1170,57 +868,8 @@ void exit_itimers(struct signal_struct *sig)
         }
 }
 
-/*
- * And now for the "clock" calls
- *
- * These functions are called both from timer functions (with the timer
- * spin_lock_irq() held and from clock calls with no locking.   They must
- * use the save flags versions of locks.
- */
-
-/*
- * We do ticks here to avoid the irq lock ( they take sooo long).
- * The seqlock is great here.  Since we a reader, we don't really care
- * if we are interrupted since we don't take lock that will stall us or
- * any other cpu. Voila, no irq lock is needed.
- *
- */
-
-static u64 do_posix_clock_monotonic_gettime_parts(
-        struct timespec *tp, struct timespec *mo)
-{
-        u64 jiff;
-        unsigned int seq;
-
-        do {
-                seq = read_seqbegin(&xtime_lock);
-                getnstimeofday(tp);
-                *mo = wall_to_monotonic;
-                jiff = jiffies_64;
-
-        } while(read_seqretry(&xtime_lock, seq));
-
-        return jiff;
-}
-
-static int do_posix_clock_monotonic_get(clockid_t clock, struct timespec *tp)
-{
-        struct timespec wall_to_mono;
-
-        do_posix_clock_monotonic_gettime_parts(tp, &wall_to_mono);
-
-        set_normalized_timespec(tp, tp->tv_sec + wall_to_mono.tv_sec,
-                                tp->tv_nsec + wall_to_mono.tv_nsec);
-
-        return 0;
-}
-
-int do_posix_clock_monotonic_gettime(struct timespec *tp)
-{
-        return do_posix_clock_monotonic_get(CLOCK_MONOTONIC, tp);
-}
-
-int do_posix_clock_nosettime(clockid_t clockid, struct timespec *tp)
+/* Not available / possible... functions */
+int do_posix_clock_nosettime(const clockid_t clockid, struct timespec *tp)
 {
         return -EINVAL;
 }
@@ -1232,7 +881,8 @@ int do_posix_clock_notimer_create(struct k_itimer *timer)
 }
 EXPORT_SYMBOL_GPL(do_posix_clock_notimer_create);
 
-int do_posix_clock_nonanosleep(clockid_t clock, int flags, struct timespec *t)
+int do_posix_clock_nonanosleep(const clockid_t clock, int flags,
+                               struct timespec *t, struct timespec __user *r)
 {
 #ifndef ENOTSUP
         return -EOPNOTSUPP;     /* aka ENOTSUP in userland for POSIX */
@@ -1242,8 +892,8 @@ int do_posix_clock_nonanosleep(clockid_t clock, int flags, struct timespec *t)
 }
 EXPORT_SYMBOL_GPL(do_posix_clock_nonanosleep);
 
-asmlinkage long
-sys_clock_settime(clockid_t which_clock, const struct timespec __user *tp)
+asmlinkage long sys_clock_settime(const clockid_t which_clock,
+                                  const struct timespec __user *tp)
 {
         struct timespec new_tp;
 
@@ -1256,7 +906,7 @@ sys_clock_settime(clockid_t which_clock, const struct timespec __user *tp)
 }
 
 asmlinkage long
-sys_clock_gettime(clockid_t which_clock, struct timespec __user *tp)
+sys_clock_gettime(const clockid_t which_clock, struct timespec __user *tp)
 {
         struct timespec kernel_tp;
         int error;
@@ -1273,7 +923,7 @@ sys_clock_gettime(clockid_t which_clock, struct timespec __user *tp)
 }
 
 asmlinkage long
-sys_clock_getres(clockid_t which_clock, struct timespec __user *tp)
+sys_clock_getres(const clockid_t which_clock, struct timespec __user *tp)
 {
         struct timespec rtn_tp;
         int error;
@@ -1292,117 +942,34 @@ sys_clock_getres(clockid_t which_clock, struct timespec __user *tp)
 }
 
 /*
- * The standard says that an absolute nanosleep call MUST wake up at
- * the requested time in spite of clock settings.  Here is what we do:
- * For each nanosleep call that needs it (only absolute and not on
- * CLOCK_MONOTONIC* (as it can not be set)) we thread a little structure
- * into the "nanosleep_abs_list".  All we need is the task_struct pointer.
- * When ever the clock is set we just wake up all those tasks.   The rest
- * is done by the while loop in clock_nanosleep().
- *
- * On locking, clock_was_set() is called from update_wall_clock which
- * holds (or has held for it) a write_lock_irq( xtime_lock) and is
- * called from the timer bh code.  Thus we need the irq save locks.
- *
- * Also, on the call from update_wall_clock, that is done as part of a
- * softirq thing.  We don't want to delay the system that much (possibly
- * long list of timers to fix), so we defer that work to keventd.
+ * nanosleep for monotonic and realtime clocks
  */
-
-static DECLARE_WAIT_QUEUE_HEAD(nanosleep_abs_wqueue);
-static DECLARE_WORK(clock_was_set_work, (void(*)(void*))clock_was_set, NULL);
-
-static DECLARE_MUTEX(clock_was_set_lock);
-
-void clock_was_set(void)
-{
-        struct k_itimer *timr;
-        struct timespec new_wall_to;
-        LIST_HEAD(cws_list);
-        unsigned long seq;
-
-
-        if (unlikely(in_interrupt())) {
-                schedule_work(&clock_was_set_work);
-                return;
+static int common_nsleep(const clockid_t which_clock, int flags,
+                         struct timespec *tsave, struct timespec __user *rmtp)
+{
+        int mode = flags & TIMER_ABSTIME ? HRTIMER_ABS : HRTIMER_REL;
+        int clockid = which_clock;
+
+        switch (which_clock) {
+        case CLOCK_REALTIME:
+                /* Posix madness. Only absolute timers on clock realtime
+                   are affected by clock set. */
+                if (mode != HRTIMER_ABS)
+                        clockid = CLOCK_MONOTONIC;
+        case CLOCK_MONOTONIC:
+                break;
+        default:
+                return -EINVAL;
         }
-        wake_up_all(&nanosleep_abs_wqueue);
-
-        /*
-         * Check if there exist TIMER_ABSTIME timers to correct.
-         *
-         * Notes on locking: This code is run in task context with irq
-         * on.  We CAN be interrupted!  All other usage of the abs list
-         * lock is under the timer lock which holds the irq lock as
-         * well.  We REALLY don't want to scan the whole list with the
-         * interrupt system off, AND we would like a sequence lock on
-         * this code as well.  Since we assume that the clock will not
-         * be set often, it seems ok to take and release the irq lock
-         * for each timer.  In fact add_timer will do this, so this is
-         * not an issue.  So we know when we are done, we will move the
-         * whole list to a new location.  Then as we process each entry,
-         * we will move it to the actual list again.  This way, when our
-         * copy is empty, we are done.  We are not all that concerned
-         * about preemption so we will use a semaphore lock to protect
-         * aginst reentry.  This way we will not stall another
-         * processor.  It is possible that this may delay some timers
-         * that should have expired, given the new clock, but even this
-         * will be minimal as we will always update to the current time,
-         * even if it was set by a task that is waiting for entry to
-         * this code.  Timers that expire too early will be caught by
-         * the expire code and restarted.
-
-         * Absolute timers that repeat are left in the abs list while
-         * waiting for the task to pick up the signal.  This means we
-         * may find timers that are not in the "add_timer" list, but are
-         * in the abs list.  We do the same thing for these, save
-         * putting them back in the "add_timer" list.  (Note, these are
-         * left in the abs list mainly to indicate that they are
-         * ABSOLUTE timers, a fact that is used by the re-arm code, and
-         * for which we have no other flag.)
-
-         */
-
-        down(&clock_was_set_lock);
-        spin_lock_irq(&abs_list.lock);
-        list_splice_init(&abs_list.list, &cws_list);
-        spin_unlock_irq(&abs_list.lock);
-        do {
-                do {
-                        seq = read_seqbegin(&xtime_lock);
-                        new_wall_to =   wall_to_monotonic;
-                } while (read_seqretry(&xtime_lock, seq));
-
-                spin_lock_irq(&abs_list.lock);
-                if (list_empty(&cws_list)) {
-                        spin_unlock_irq(&abs_list.lock);
-                        break;
-                }
-                timr = list_entry(cws_list.next, struct k_itimer,
-                                  it.real.abs_timer_entry);
-
-                list_del_init(&timr->it.real.abs_timer_entry);
-                if (add_clockset_delta(timr, &new_wall_to) &&
-                    del_timer(&timr->it.real.timer))  /* timer run yet? */
-                        add_timer(&timr->it.real.timer);
-                list_add(&timr->it.real.abs_timer_entry, &abs_list.list);
-                spin_unlock_irq(&abs_list.lock);
-        } while (1);
-
-        up(&clock_was_set_lock);
+        return hrtimer_nanosleep(tsave, rmtp, mode, clockid);
 }
 
-long clock_nanosleep_restart(struct restart_block *restart_block);
-
 asmlinkage long
-sys_clock_nanosleep(clockid_t which_clock, int flags,
+sys_clock_nanosleep(const clockid_t which_clock, int flags,
                     const struct timespec __user *rqtp,
                     struct timespec __user *rmtp)
 {
         struct timespec t;
-        struct restart_block *restart_block =
-            &(current_thread_info()->restart_block);
-        int ret;
 
         if (invalid_clockid(which_clock))
                 return -EINVAL;
@@ -1410,125 +977,9 @@ sys_clock_nanosleep(clockid_t which_clock, int flags,
         if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
                 return -EFAULT;
 
-        if ((unsigned) t.tv_nsec >= NSEC_PER_SEC || t.tv_sec < 0)
+        if (!timespec_valid(&t))
                 return -EINVAL;
 
-        /*
-         * Do this here as nsleep function does not have the real address.
-         */
-        restart_block->arg1 = (unsigned long)rmtp;
-
-        ret = CLOCK_DISPATCH(which_clock, nsleep, (which_clock, flags, &t));
-
-        if ((ret == -ERESTART_RESTARTBLOCK) && rmtp &&
-                                        copy_to_user(rmtp, &t, sizeof (t)))
-                return -EFAULT;
-        return ret;
-}
-
-
-static int common_nsleep(clockid_t which_clock,
-                         int flags, struct timespec *tsave)
-{
-        struct timespec t, dum;
-        DECLARE_WAITQUEUE(abs_wqueue, current);
-        u64 rq_time = (u64)0;
-        s64 left;
-        int abs;
-        struct restart_block *restart_block =
-            &current_thread_info()->restart_block;
-
-        abs_wqueue.flags = 0;
-        abs = flags & TIMER_ABSTIME;
-
-        if (restart_block->fn == clock_nanosleep_restart) {
-                /*
-                 * Interrupted by a non-delivered signal, pick up remaining
-                 * time and continue.  Remaining time is in arg2 & 3.
-                 */
-                restart_block->fn = do_no_restart_syscall;
-
-                rq_time = restart_block->arg3;
-                rq_time = (rq_time << 32) + restart_block->arg2;
-                if (!rq_time)
-                        return -EINTR;
-                left = rq_time - get_jiffies_64();
-                if (left <= (s64)0)
-                        return 0;       /* Already passed */
-        }
-
-        if (abs && (posix_clocks[which_clock].clock_get !=
-                            posix_clocks[CLOCK_MONOTONIC].clock_get))
-                add_wait_queue(&nanosleep_abs_wqueue, &abs_wqueue);
-
-        do {
-                t = *tsave;
-                if (abs || !rq_time) {
-                        adjust_abs_time(&posix_clocks[which_clock], &t, abs,
-                                        &rq_time, &dum);
-                }
-
-                left = rq_time - get_jiffies_64();
-                if (left >= (s64)MAX_JIFFY_OFFSET)
-                        left = (s64)MAX_JIFFY_OFFSET;
-                if (left < (s64)0)
-                        break;
-
-                schedule_timeout_interruptible(left);
-
-                left = rq_time - get_jiffies_64();
-        } while (left > (s64)0 && !test_thread_flag(TIF_SIGPENDING));
-
-        if (abs_wqueue.task_list.next)
-                finish_wait(&nanosleep_abs_wqueue, &abs_wqueue);
-
-        if (left > (s64)0) {
-
-                /*
-                 * Always restart abs calls from scratch to pick up any
-                 * clock shifting that happened while we are away.
-                 */
-                if (abs)
-                        return -ERESTARTNOHAND;
-
-                left *= TICK_NSEC;
-                tsave->tv_sec = div_long_long_rem(left, 
-                                                  NSEC_PER_SEC, 
-                                                  &tsave->tv_nsec);
-                /*
-                 * Restart works by saving the time remaing in 
-                 * arg2 & 3 (it is 64-bits of jiffies).  The other
-                 * info we need is the clock_id (saved in arg0). 
-                 * The sys_call interface needs the users 
-                 * timespec return address which _it_ saves in arg1.
-                 * Since we have cast the nanosleep call to a clock_nanosleep
-                 * both can be restarted with the same code.
-                 */
-                restart_block->fn = clock_nanosleep_restart;
-                restart_block->arg0 = which_clock;
-                /*
-                 * Caller sets arg1
-                 */
-                restart_block->arg2 = rq_time & 0xffffffffLL;
-                restart_block->arg3 = rq_time >> 32;
-
-                return -ERESTART_RESTARTBLOCK;
-        }
-
-        return 0;
-}
-/*
- * This will restart clock_nanosleep.
- */
-long
-clock_nanosleep_restart(struct restart_block *restart_block)
-{
-        struct timespec t;
-        int ret = common_nsleep(restart_block->arg0, 0, &t);
-
-        if ((ret == -ERESTART_RESTARTBLOCK) && restart_block->arg1 &&
-            copy_to_user((struct timespec __user *)(restart_block->arg1), &t,
-                         sizeof (t)))
-                return -EFAULT;
-        return ret;
+        return CLOCK_DISPATCH(which_clock, nsleep,
+                              (which_clock, flags, &t, rmtp));
 }