kernel/time/posix-timers.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * 2002-10-15  Posix Clocks & timers
   4  *                           by George Anzinger [email protected]
   5  *                           Copyright (C) 2002 2003 by MontaVista Software.
   6  *
   7  * 2004-06-01  Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
   8  *                           Copyright (C) 2004 Boris Hu
   9  *
  10  * These are all the functions necessary to implement POSIX clocks & timers
  11  */
  12 #include <linux/mm.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/slab.h>
  15 #include <linux/time.h>
  16 #include <linux/mutex.h>
  17 #include <linux/sched/task.h>
  18
  19 #include <linux/uaccess.h>
  20 #include <linux/list.h>
  21 #include <linux/init.h>
  22 #include <linux/compiler.h>
  23 #include <linux/hash.h>
  24 #include <linux/posix-clock.h>
  25 #include <linux/posix-timers.h>
  26 #include <linux/syscalls.h>
  27 #include <linux/wait.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/export.h>
  30 #include <linux/hashtable.h>
  31 #include <linux/compat.h>
  32 #include <linux/nospec.h>
  33 #include <linux/time_namespace.h>
  34
  35 #include "timekeeping.h"
  36 #include "posix-timers.h"
  37
  38 static struct kmem_cache *posix_timers_cache;
  39
  40 /*
  41  * Timers are managed in a hash table for lockless lookup. The hash key is
  42  * constructed from current::signal and the timer ID and the timer is
  43  * matched against current::signal and the timer ID when walking the hash
  44  * bucket list.
  45  *
  46  * This allows checkpoint/restore to reconstruct the exact timer IDs for
  47  * a process.
  48  */
  49 static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
  50 static DEFINE_SPINLOCK(hash_lock);
  51
  52 static const struct k_clock * const posix_clocks[];
  53 static const struct k_clock *clockid_to_kclock(const clockid_t id);
  54 static const struct k_clock clock_realtime, clock_monotonic;
  55
  56 /* SIGEV_THREAD_ID cannot share a bit with the other SIGEV values. */
  57 #if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
  58                         ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
  59 #error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
  60 #endif
  61
  62 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
  63
  64 #define lock_timer(tid, flags)                                             \
  65 ({      struct k_itimer *__timr;                                           \
  66         __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags));  \
  67         __timr;                                                            \
  68 })
  69
  70 static int hash(struct signal_struct *sig, unsigned int nr)
  71 {
  72         return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable));
  73 }
  74
  75 static struct k_itimer *__posix_timers_find(struct hlist_head *head,
  76                                             struct signal_struct *sig,
  77                                             timer_t id)
  78 {
  79         struct k_itimer *timer;
  80
  81         hlist_for_each_entry_rcu(timer, head, t_hash, lockdep_is_held(&hash_lock)) {
  82                 /* timer->it_signal can be set concurrently */
  83                 if ((READ_ONCE(timer->it_signal) == sig) && (timer->it_id == id))
  84                         return timer;
  85         }
  86         return NULL;
  87 }
  88
  89 static struct k_itimer *posix_timer_by_id(timer_t id)
  90 {
  91         struct signal_struct *sig = current->signal;
  92         struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)];
  93
  94         return __posix_timers_find(head, sig, id);
  95 }
  96
  97 static int posix_timer_add(struct k_itimer *timer)
  98 {
  99         struct signal_struct *sig = current->signal;
 100         struct hlist_head *head;
 101         unsigned int cnt, id;
 102
 103         /*
 104          * FIXME: Replace this by a per signal struct xarray once there is
 105          * a plan to handle the resulting CRIU regression gracefully.
 106          */
 107         for (cnt = 0; cnt <= INT_MAX; cnt++) {
 108                 spin_lock(&hash_lock);
 109                 id = sig->next_posix_timer_id;
 110
 111                 /* Write the next ID back. Clamp it to the positive space */
 112                 sig->next_posix_timer_id = (id + 1) & INT_MAX;
 113
 114                 head = &posix_timers_hashtable[hash(sig, id)];
 115                 if (!__posix_timers_find(head, sig, id)) {
 116                         hlist_add_head_rcu(&timer->t_hash, head);
 117                         spin_unlock(&hash_lock);
 118                         return id;
 119                 }
 120                 spin_unlock(&hash_lock);
 121         }
 122         /* POSIX return code when no timer ID could be allocated */
 123         return -EAGAIN;
 124 }
 125
 126 static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
 127 {
 128         spin_unlock_irqrestore(&timr->it_lock, flags);
 129 }
 130
 131 static int posix_get_realtime_timespec(clockid_t which_clock, struct timespec64 *tp)
 132 {
 133         ktime_get_real_ts64(tp);
 134         return 0;
 135 }
 136
 137 static ktime_t posix_get_realtime_ktime(clockid_t which_clock)
 138 {
 139         return ktime_get_real();
 140 }
 141
 142 static int posix_clock_realtime_set(const clockid_t which_clock,
 143                                     const struct timespec64 *tp)
 144 {
 145         return do_sys_settimeofday64(tp, NULL);
 146 }
 147
 148 static int posix_clock_realtime_adj(const clockid_t which_clock,
 149                                     struct __kernel_timex *t)
 150 {
 151         return do_adjtimex(t);
 152 }
 153
 154 static int posix_get_monotonic_timespec(clockid_t which_clock, struct timespec64 *tp)
 155 {
 156         ktime_get_ts64(tp);
 157         timens_add_monotonic(tp);
 158         return 0;
 159 }
 160
 161 static ktime_t posix_get_monotonic_ktime(clockid_t which_clock)
 162 {
 163         return ktime_get();
 164 }
 165
 166 static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec64 *tp)
 167 {
 168         ktime_get_raw_ts64(tp);
 169         timens_add_monotonic(tp);
 170         return 0;
 171 }
 172
 173 static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec64 *tp)
 174 {
 175         ktime_get_coarse_real_ts64(tp);
 176         return 0;
 177 }
 178
 179 static int posix_get_monotonic_coarse(clockid_t which_clock,
 180                                                 struct timespec64 *tp)
 181 {
 182         ktime_get_coarse_ts64(tp);
 183         timens_add_monotonic(tp);
 184         return 0;
 185 }
 186
 187 static int posix_get_coarse_res(const clockid_t which_clock, struct timespec64 *tp)
 188 {
 189         *tp = ktime_to_timespec64(KTIME_LOW_RES);
 190         return 0;
 191 }
 192
 193 static int posix_get_boottime_timespec(const clockid_t which_clock, struct timespec64 *tp)
 194 {
 195         ktime_get_boottime_ts64(tp);
 196         timens_add_boottime(tp);
 197         return 0;
 198 }
 199
 200 static ktime_t posix_get_boottime_ktime(const clockid_t which_clock)
 201 {
 202         return ktime_get_boottime();
 203 }
 204
 205 static int posix_get_tai_timespec(clockid_t which_clock, struct timespec64 *tp)
 206 {
 207         ktime_get_clocktai_ts64(tp);
 208         return 0;
 209 }
 210
 211 static ktime_t posix_get_tai_ktime(clockid_t which_clock)
 212 {
 213         return ktime_get_clocktai();
 214 }
 215
 216 static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp)
 217 {
 218         tp->tv_sec = 0;
 219         tp->tv_nsec = hrtimer_resolution;
 220         return 0;
 221 }
 222
 223 static __init int init_posix_timers(void)
 224 {
 225         posix_timers_cache = kmem_cache_create("posix_timers_cache",
 226                                         sizeof(struct k_itimer), 0,
 227                                         SLAB_PANIC | SLAB_ACCOUNT, NULL);
 228         return 0;
 229 }
 230 __initcall(init_posix_timers);
 231
 232 /*
 233  * The siginfo si_overrun field and the return value of timer_getoverrun(2)
 234  * are of type int. Clamp the overrun value to INT_MAX
 235  */
 236 static inline int timer_overrun_to_int(struct k_itimer *timr)
 237 {
 238         if (timr->it_overrun_last > (s64)INT_MAX)
 239                 return INT_MAX;
 240
 241         return (int)timr->it_overrun_last;
 242 }
 243
 244 static void common_hrtimer_rearm(struct k_itimer *timr)
 245 {
 246         struct hrtimer *timer = &timr->it.real.timer;
 247
 248         timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(),
 249                                             timr->it_interval);
 250         hrtimer_restart(timer);
 251 }
 252
 253 static bool __posixtimer_deliver_signal(struct kernel_siginfo *info, struct k_itimer *timr)
 254 {
 255         guard(spinlock)(&timr->it_lock);
 256
 257         /*
 258          * Check if the timer is still alive or whether it got modified
 259          * since the signal was queued. In either case, don't rearm and
 260          * drop the signal.
 261          */
 262         if (timr->it_signal_seq != timr->it_sigqueue_seq || WARN_ON_ONCE(!timr->it_signal))
 263                 return false;
 264
 265         if (!timr->it_interval || WARN_ON_ONCE(timr->it_status != POSIX_TIMER_REQUEUE_PENDING))
 266                 return true;
 267
 268         timr->kclock->timer_rearm(timr);
 269         timr->it_status = POSIX_TIMER_ARMED;
 270         timr->it_overrun_last = timr->it_overrun;
 271         timr->it_overrun = -1LL;
 272         ++timr->it_signal_seq;
 273         info->si_overrun = timer_overrun_to_int(timr);
 274         return true;
 275 }
 276
 277 /*
 278  * This function is called from the signal delivery code. It decides
 279  * whether the signal should be dropped and rearms interval timers.  The
 280  * timer can be unconditionally accessed as there is a reference held on
 281  * it.
 282  */
 283 bool posixtimer_deliver_signal(struct kernel_siginfo *info, struct sigqueue *timer_sigq)
 284 {
 285         struct k_itimer *timr = container_of(timer_sigq, struct k_itimer, sigq);
 286         bool ret;
 287
 288         /*
 289          * Release siglock to ensure proper locking order versus
 290          * timr::it_lock. Keep interrupts disabled.
 291          */
 292         spin_unlock(&current->sighand->siglock);
 293
 294         ret = __posixtimer_deliver_signal(info, timr);
 295
 296         /* Drop the reference which was acquired when the signal was queued */
 297         posixtimer_putref(timr);
 298
 299         spin_lock(&current->sighand->siglock);
 300         return ret;
 301 }
 302
 303 void posix_timer_queue_signal(struct k_itimer *timr)
 304 {
 305         lockdep_assert_held(&timr->it_lock);
 306
 307         timr->it_status = timr->it_interval ? POSIX_TIMER_REQUEUE_PENDING : POSIX_TIMER_DISARMED;
 308         posixtimer_send_sigqueue(timr);
 309 }
 310
 311 /*
 312  * This function gets called when a POSIX.1b interval timer expires from
 313  * the HRTIMER interrupt (soft interrupt on RT kernels).
 314  *
 315  * Handles CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_BOOTTIME and CLOCK_TAI
 316  * based timers.
 317  */
 318 static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
 319 {
 320         struct k_itimer *timr = container_of(timer, struct k_itimer, it.real.timer);
 321
 322         guard(spinlock_irqsave)(&timr->it_lock);
 323         posix_timer_queue_signal(timr);
 324         return HRTIMER_NORESTART;
 325 }
 326
 327 static struct pid *good_sigevent(sigevent_t * event)
 328 {
 329         struct pid *pid = task_tgid(current);
 330         struct task_struct *rtn;
 331
 332         switch (event->sigev_notify) {
 333         case SIGEV_SIGNAL | SIGEV_THREAD_ID:
 334                 pid = find_vpid(event->sigev_notify_thread_id);
 335                 rtn = pid_task(pid, PIDTYPE_PID);
 336                 if (!rtn || !same_thread_group(rtn, current))
 337                         return NULL;
 338                 fallthrough;
 339         case SIGEV_SIGNAL:
 340         case SIGEV_THREAD:
 341                 if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX)
 342                         return NULL;
 343                 fallthrough;
 344         case SIGEV_NONE:
 345                 return pid;
 346         default:
 347                 return NULL;
 348         }
 349 }
 350
 351 static struct k_itimer *alloc_posix_timer(void)
 352 {
 353         struct k_itimer *tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
 354
 355         if (!tmr)
 356                 return tmr;
 357
 358         if (unlikely(!posixtimer_init_sigqueue(&tmr->sigq))) {
 359                 kmem_cache_free(posix_timers_cache, tmr);
 360                 return NULL;
 361         }
 362         rcuref_init(&tmr->rcuref, 1);
 363         return tmr;
 364 }
 365
 366 void posixtimer_free_timer(struct k_itimer *tmr)
 367 {
 368         put_pid(tmr->it_pid);
 369         if (tmr->sigq.ucounts)
 370                 dec_rlimit_put_ucounts(tmr->sigq.ucounts, UCOUNT_RLIMIT_SIGPENDING);
 371         kfree_rcu(tmr, rcu);
 372 }
 373
 374 static void posix_timer_unhash_and_free(struct k_itimer *tmr)
 375 {
 376         spin_lock(&hash_lock);
 377         hlist_del_rcu(&tmr->t_hash);
 378         spin_unlock(&hash_lock);
 379         posixtimer_putref(tmr);
 380 }
 381
 382 static int common_timer_create(struct k_itimer *new_timer)
 383 {
 384         hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
 385         return 0;
 386 }
 387
 388 /* Create a POSIX.1b interval timer. */
 389 static int do_timer_create(clockid_t which_clock, struct sigevent *event,
 390                            timer_t __user *created_timer_id)
 391 {
 392         const struct k_clock *kc = clockid_to_kclock(which_clock);
 393         struct k_itimer *new_timer;
 394         int error, new_timer_id;
 395
 396         if (!kc)
 397                 return -EINVAL;
 398         if (!kc->timer_create)
 399                 return -EOPNOTSUPP;
 400
 401         new_timer = alloc_posix_timer();
 402         if (unlikely(!new_timer))
 403                 return -EAGAIN;
 404
 405         spin_lock_init(&new_timer->it_lock);
 406
 407         /*
 408          * Add the timer to the hash table. The timer is not yet valid
 409          * because new_timer::it_signal is still NULL. The timer id is also
 410          * not yet visible to user space.
 411          */
 412         new_timer_id = posix_timer_add(new_timer);
 413         if (new_timer_id < 0) {
 414                 posixtimer_free_timer(new_timer);
 415                 return new_timer_id;
 416         }
 417
 418         new_timer->it_id = (timer_t) new_timer_id;
 419         new_timer->it_clock = which_clock;
 420         new_timer->kclock = kc;
 421         new_timer->it_overrun = -1LL;
 422
 423         if (event) {
 424                 rcu_read_lock();
 425                 new_timer->it_pid = get_pid(good_sigevent(event));
 426                 rcu_read_unlock();
 427                 if (!new_timer->it_pid) {
 428                         error = -EINVAL;
 429                         goto out;
 430                 }
 431                 new_timer->it_sigev_notify     = event->sigev_notify;
 432                 new_timer->sigq.info.si_signo = event->sigev_signo;
 433                 new_timer->sigq.info.si_value = event->sigev_value;
 434         } else {
 435                 new_timer->it_sigev_notify     = SIGEV_SIGNAL;
 436                 new_timer->sigq.info.si_signo = SIGALRM;
 437                 memset(&new_timer->sigq.info.si_value, 0, sizeof(sigval_t));
 438                 new_timer->sigq.info.si_value.sival_int = new_timer->it_id;
 439                 new_timer->it_pid = get_pid(task_tgid(current));
 440         }
 441
 442         if (new_timer->it_sigev_notify & SIGEV_THREAD_ID)
 443                 new_timer->it_pid_type = PIDTYPE_PID;
 444         else
 445                 new_timer->it_pid_type = PIDTYPE_TGID;
 446
 447         new_timer->sigq.info.si_tid = new_timer->it_id;
 448         new_timer->sigq.info.si_code = SI_TIMER;
 449
 450         if (copy_to_user(created_timer_id, &new_timer_id, sizeof (new_timer_id))) {
 451                 error = -EFAULT;
 452                 goto out;
 453         }
 454         /*
 455          * After succesful copy out, the timer ID is visible to user space
 456          * now but not yet valid because new_timer::signal is still NULL.
 457          *
 458          * Complete the initialization with the clock specific create
 459          * callback.
 460          */
 461         error = kc->timer_create(new_timer);
 462         if (error)
 463                 goto out;
 464
 465         spin_lock_irq(&current->sighand->siglock);
 466         /* This makes the timer valid in the hash table */
 467         WRITE_ONCE(new_timer->it_signal, current->signal);
 468         hlist_add_head(&new_timer->list, &current->signal->posix_timers);
 469         spin_unlock_irq(&current->sighand->siglock);
 470         /*
 471          * After unlocking sighand::siglock @new_timer is subject to
 472          * concurrent removal and cannot be touched anymore
 473          */
 474         return 0;
 475 out:
 476         posix_timer_unhash_and_free(new_timer);
 477         return error;
 478 }
 479
 480 SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
 481                 struct sigevent __user *, timer_event_spec,
 482                 timer_t __user *, created_timer_id)
 483 {
 484         if (timer_event_spec) {
 485                 sigevent_t event;
 486
 487                 if (copy_from_user(&event, timer_event_spec, sizeof (event)))
 488                         return -EFAULT;
 489                 return do_timer_create(which_clock, &event, created_timer_id);
 490         }
 491         return do_timer_create(which_clock, NULL, created_timer_id);
 492 }
 493
 494 #ifdef CONFIG_COMPAT
 495 COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
 496                        struct compat_sigevent __user *, timer_event_spec,
 497                        timer_t __user *, created_timer_id)
 498 {
 499         if (timer_event_spec) {
 500                 sigevent_t event;
 501
 502                 if (get_compat_sigevent(&event, timer_event_spec))
 503                         return -EFAULT;
 504                 return do_timer_create(which_clock, &event, created_timer_id);
 505         }
 506         return do_timer_create(which_clock, NULL, created_timer_id);
 507 }
 508 #endif
 509
 510 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
 511 {
 512         struct k_itimer *timr;
 513
 514         /*
 515          * timer_t could be any type >= int and we want to make sure any
 516          * @timer_id outside positive int range fails lookup.
 517          */
 518         if ((unsigned long long)timer_id > INT_MAX)
 519                 return NULL;
 520
 521         /*
 522          * The hash lookup and the timers are RCU protected.
 523          *
 524          * Timers are added to the hash in invalid state where
 525          * timr::it_signal == NULL. timer::it_signal is only set after the
 526          * rest of the initialization succeeded.
 527          *
 528          * Timer destruction happens in steps:
 529          *  1) Set timr::it_signal to NULL with timr::it_lock held
 530          *  2) Release timr::it_lock
 531          *  3) Remove from the hash under hash_lock
 532          *  4) Put the reference count.
 533          *
 534          * The reference count might not drop to zero if timr::sigq is
 535          * queued. In that case the signal delivery or flush will put the
 536          * last reference count.
 537          *
 538          * When the reference count reaches zero, the timer is scheduled
 539          * for RCU removal after the grace period.
 540          *
 541          * Holding rcu_read_lock() accross the lookup ensures that
 542          * the timer cannot be freed.
 543          *
 544          * The lookup validates locklessly that timr::it_signal ==
 545          * current::it_signal and timr::it_id == @timer_id. timr::it_id
 546          * can't change, but timr::it_signal becomes NULL during
 547          * destruction.
 548          */
 549         rcu_read_lock();
 550         timr = posix_timer_by_id(timer_id);
 551         if (timr) {
 552                 spin_lock_irqsave(&timr->it_lock, *flags);
 553                 /*
 554                  * Validate under timr::it_lock that timr::it_signal is
 555                  * still valid. Pairs with #1 above.
 556                  */
 557                 if (timr->it_signal == current->signal) {
 558                         rcu_read_unlock();
 559                         return timr;
 560                 }
 561                 spin_unlock_irqrestore(&timr->it_lock, *flags);
 562         }
 563         rcu_read_unlock();
 564
 565         return NULL;
 566 }
 567
 568 static ktime_t common_hrtimer_remaining(struct k_itimer *timr, ktime_t now)
 569 {
 570         struct hrtimer *timer = &timr->it.real.timer;
 571
 572         return __hrtimer_expires_remaining_adjusted(timer, now);
 573 }
 574
 575 static s64 common_hrtimer_forward(struct k_itimer *timr, ktime_t now)
 576 {
 577         struct hrtimer *timer = &timr->it.real.timer;
 578
 579         return hrtimer_forward(timer, now, timr->it_interval);
 580 }
 581
 582 /*
 583  * Get the time remaining on a POSIX.1b interval timer.
 584  *
 585  * Two issues to handle here:
 586  *
 587  *  1) The timer has a requeue pending. The return value must appear as
 588  *     if the timer has been requeued right now.
 589  *
 590  *  2) The timer is a SIGEV_NONE timer. These timers are never enqueued
 591  *     into the hrtimer queue and therefore never expired. Emulate expiry
 592  *     here taking #1 into account.
 593  */
 594 void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
 595 {
 596         const struct k_clock *kc = timr->kclock;
 597         ktime_t now, remaining, iv;
 598         bool sig_none;
 599
 600         sig_none = timr->it_sigev_notify == SIGEV_NONE;
 601         iv = timr->it_interval;
 602
 603         /* interval timer ? */
 604         if (iv) {
 605                 cur_setting->it_interval = ktime_to_timespec64(iv);
 606         } else if (timr->it_status == POSIX_TIMER_DISARMED) {
 607                 /*
 608                  * SIGEV_NONE oneshot timers are never queued and therefore
 609                  * timr->it_status is always DISARMED. The check below
 610                  * vs. remaining time will handle this case.
 611                  *
 612                  * For all other timers there is nothing to update here, so
 613                  * return.
 614                  */
 615                 if (!sig_none)
 616                         return;
 617         }
 618
 619         now = kc->clock_get_ktime(timr->it_clock);
 620
 621         /*
 622          * If this is an interval timer and either has requeue pending or
 623          * is a SIGEV_NONE timer move the expiry time forward by intervals,
 624          * so expiry is > now.
 625          */
 626         if (iv && timr->it_status != POSIX_TIMER_ARMED)
 627                 timr->it_overrun += kc->timer_forward(timr, now);
 628
 629         remaining = kc->timer_remaining(timr, now);
 630         /*
 631          * As @now is retrieved before a possible timer_forward() and
 632          * cannot be reevaluated by the compiler @remaining is based on the
 633          * same @now value. Therefore @remaining is consistent vs. @now.
 634          *
 635          * Consequently all interval timers, i.e. @iv > 0, cannot have a
 636          * remaining time <= 0 because timer_forward() guarantees to move
 637          * them forward so that the next timer expiry is > @now.
 638          */
 639         if (remaining <= 0) {
 640                 /*
 641                  * A single shot SIGEV_NONE timer must return 0, when it is
 642                  * expired! Timers which have a real signal delivery mode
 643                  * must return a remaining time greater than 0 because the
 644                  * signal has not yet been delivered.
 645                  */
 646                 if (!sig_none)
 647                         cur_setting->it_value.tv_nsec = 1;
 648         } else {
 649                 cur_setting->it_value = ktime_to_timespec64(remaining);
 650         }
 651 }
 652
 653 static int do_timer_gettime(timer_t timer_id,  struct itimerspec64 *setting)
 654 {
 655         const struct k_clock *kc;
 656         struct k_itimer *timr;
 657         unsigned long flags;
 658         int ret = 0;
 659
 660         timr = lock_timer(timer_id, &flags);
 661         if (!timr)
 662                 return -EINVAL;
 663
 664         memset(setting, 0, sizeof(*setting));
 665         kc = timr->kclock;
 666         if (WARN_ON_ONCE(!kc || !kc->timer_get))
 667                 ret = -EINVAL;
 668         else
 669                 kc->timer_get(timr, setting);
 670
 671         unlock_timer(timr, flags);
 672         return ret;
 673 }
 674
 675 /* Get the time remaining on a POSIX.1b interval timer. */
 676 SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
 677                 struct __kernel_itimerspec __user *, setting)
 678 {
 679         struct itimerspec64 cur_setting;
 680
 681         int ret = do_timer_gettime(timer_id, &cur_setting);
 682         if (!ret) {
 683                 if (put_itimerspec64(&cur_setting, setting))
 684                         ret = -EFAULT;
 685         }
 686         return ret;
 687 }
 688
 689 #ifdef CONFIG_COMPAT_32BIT_TIME
 690
 691 SYSCALL_DEFINE2(timer_gettime32, timer_t, timer_id,
 692                 struct old_itimerspec32 __user *, setting)
 693 {
 694         struct itimerspec64 cur_setting;
 695
 696         int ret = do_timer_gettime(timer_id, &cur_setting);
 697         if (!ret) {
 698                 if (put_old_itimerspec32(&cur_setting, setting))
 699                         ret = -EFAULT;
 700         }
 701         return ret;
 702 }
 703
 704 #endif
 705
 706 /**
 707  * sys_timer_getoverrun - Get the number of overruns of a POSIX.1b interval timer
 708  * @timer_id:   The timer ID which identifies the timer
 709  *
 710  * The "overrun count" of a timer is one plus the number of expiration
 711  * intervals which have elapsed between the first expiry, which queues the
 712  * signal and the actual signal delivery. On signal delivery the "overrun
 713  * count" is calculated and cached, so it can be returned directly here.
 714  *
 715  * As this is relative to the last queued signal the returned overrun count
 716  * is meaningless outside of the signal delivery path and even there it
 717  * does not accurately reflect the current state when user space evaluates
 718  * it.
 719  *
 720  * Returns:
 721  *      -EINVAL         @timer_id is invalid
 722  *      1..INT_MAX      The number of overruns related to the last delivered signal
 723  */
 724 SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
 725 {
 726         struct k_itimer *timr;
 727         unsigned long flags;
 728         int overrun;
 729
 730         timr = lock_timer(timer_id, &flags);
 731         if (!timr)
 732                 return -EINVAL;
 733
 734         overrun = timer_overrun_to_int(timr);
 735         unlock_timer(timr, flags);
 736
 737         return overrun;
 738 }
 739
 740 static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
 741                                bool absolute, bool sigev_none)
 742 {
 743         struct hrtimer *timer = &timr->it.real.timer;
 744         enum hrtimer_mode mode;
 745
 746         mode = absolute ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
 747         /*
 748          * Posix magic: Relative CLOCK_REALTIME timers are not affected by
 749          * clock modifications, so they become CLOCK_MONOTONIC based under the
 750          * hood. See hrtimer_init(). Update timr->kclock, so the generic
 751          * functions which use timr->kclock->clock_get_*() work.
 752          *
 753          * Note: it_clock stays unmodified, because the next timer_set() might
 754          * use ABSTIME, so it needs to switch back.
 755          */
 756         if (timr->it_clock == CLOCK_REALTIME)
 757                 timr->kclock = absolute ? &clock_realtime : &clock_monotonic;
 758
 759         hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
 760         timr->it.real.timer.function = posix_timer_fn;
 761
 762         if (!absolute)
 763                 expires = ktime_add_safe(expires, timer->base->get_time());
 764         hrtimer_set_expires(timer, expires);
 765
 766         if (!sigev_none)
 767                 hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
 768 }
 769
 770 static int common_hrtimer_try_to_cancel(struct k_itimer *timr)
 771 {
 772         return hrtimer_try_to_cancel(&timr->it.real.timer);
 773 }
 774
 775 static void common_timer_wait_running(struct k_itimer *timer)
 776 {
 777         hrtimer_cancel_wait_running(&timer->it.real.timer);
 778 }
 779
 780 /*
 781  * On PREEMPT_RT this prevents priority inversion and a potential livelock
 782  * against the ksoftirqd thread in case that ksoftirqd gets preempted while
 783  * executing a hrtimer callback.
 784  *
 785  * See the comments in hrtimer_cancel_wait_running(). For PREEMPT_RT=n this
 786  * just results in a cpu_relax().
 787  *
 788  * For POSIX CPU timers with CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n this is
 789  * just a cpu_relax(). With CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y this
 790  * prevents spinning on an eventually scheduled out task and a livelock
 791  * when the task which tries to delete or disarm the timer has preempted
 792  * the task which runs the expiry in task work context.
 793  */
 794 static struct k_itimer *timer_wait_running(struct k_itimer *timer,
 795                                            unsigned long *flags)
 796 {
 797         const struct k_clock *kc = READ_ONCE(timer->kclock);
 798         timer_t timer_id = READ_ONCE(timer->it_id);
 799
 800         /* Prevent kfree(timer) after dropping the lock */
 801         rcu_read_lock();
 802         unlock_timer(timer, *flags);
 803
 804         /*
 805          * kc->timer_wait_running() might drop RCU lock. So @timer
 806          * cannot be touched anymore after the function returns!
 807          */
 808         if (!WARN_ON_ONCE(!kc->timer_wait_running))
 809                 kc->timer_wait_running(timer);
 810
 811         rcu_read_unlock();
 812         /* Relock the timer. It might be not longer hashed. */
 813         return lock_timer(timer_id, flags);
 814 }
 815
 816 /*
 817  * Set up the new interval and reset the signal delivery data
 818  */
 819 void posix_timer_set_common(struct k_itimer *timer, struct itimerspec64 *new_setting)
 820 {
 821         if (new_setting->it_value.tv_sec || new_setting->it_value.tv_nsec)
 822                 timer->it_interval = timespec64_to_ktime(new_setting->it_interval);
 823         else
 824                 timer->it_interval = 0;
 825
 826         /* Reset overrun accounting */
 827         timer->it_overrun_last = 0;
 828         timer->it_overrun = -1LL;
 829 }
 830
 831 /* Set a POSIX.1b interval timer. */
 832 int common_timer_set(struct k_itimer *timr, int flags,
 833                      struct itimerspec64 *new_setting,
 834                      struct itimerspec64 *old_setting)
 835 {
 836         const struct k_clock *kc = timr->kclock;
 837         bool sigev_none;
 838         ktime_t expires;
 839
 840         if (old_setting)
 841                 common_timer_get(timr, old_setting);
 842
 843         /*
 844          * Careful here. On SMP systems the timer expiry function could be
 845          * active and spinning on timr->it_lock.
 846          */
 847         if (kc->timer_try_to_cancel(timr) < 0)
 848                 return TIMER_RETRY;
 849
 850         timr->it_status = POSIX_TIMER_DISARMED;
 851         posix_timer_set_common(timr, new_setting);
 852
 853         /* Keep timer disarmed when it_value is zero */
 854         if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
 855                 return 0;
 856
 857         expires = timespec64_to_ktime(new_setting->it_value);
 858         if (flags & TIMER_ABSTIME)
 859                 expires = timens_ktime_to_host(timr->it_clock, expires);
 860         sigev_none = timr->it_sigev_notify == SIGEV_NONE;
 861
 862         kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
 863         if (!sigev_none)
 864                 timr->it_status = POSIX_TIMER_ARMED;
 865         return 0;
 866 }
 867
 868 static int do_timer_settime(timer_t timer_id, int tmr_flags,
 869                             struct itimerspec64 *new_spec64,
 870                             struct itimerspec64 *old_spec64)
 871 {
 872         const struct k_clock *kc;
 873         struct k_itimer *timr;
 874         unsigned long flags;
 875         int error;
 876
 877         if (!timespec64_valid(&new_spec64->it_interval) ||
 878             !timespec64_valid(&new_spec64->it_value))
 879                 return -EINVAL;
 880
 881         if (old_spec64)
 882                 memset(old_spec64, 0, sizeof(*old_spec64));
 883
 884         timr = lock_timer(timer_id, &flags);
 885 retry:
 886         if (!timr)
 887                 return -EINVAL;
 888
 889         if (old_spec64)
 890                 old_spec64->it_interval = ktime_to_timespec64(timr->it_interval);
 891
 892         /* Prevent signal delivery and rearming. */
 893         timr->it_signal_seq++;
 894
 895         kc = timr->kclock;
 896         if (WARN_ON_ONCE(!kc || !kc->timer_set))
 897                 error = -EINVAL;
 898         else
 899                 error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64);
 900
 901         if (error == TIMER_RETRY) {
 902                 // We already got the old time...
 903                 old_spec64 = NULL;
 904                 /* Unlocks and relocks the timer if it still exists */
 905                 timr = timer_wait_running(timr, &flags);
 906                 goto retry;
 907         }
 908         unlock_timer(timr, flags);
 909
 910         return error;
 911 }
 912
 913 /* Set a POSIX.1b interval timer */
 914 SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
 915                 const struct __kernel_itimerspec __user *, new_setting,
 916                 struct __kernel_itimerspec __user *, old_setting)
 917 {
 918         struct itimerspec64 new_spec, old_spec, *rtn;
 919         int error = 0;
 920
 921         if (!new_setting)
 922                 return -EINVAL;
 923
 924         if (get_itimerspec64(&new_spec, new_setting))
 925                 return -EFAULT;
 926
 927         rtn = old_setting ? &old_spec : NULL;
 928         error = do_timer_settime(timer_id, flags, &new_spec, rtn);
 929         if (!error && old_setting) {
 930                 if (put_itimerspec64(&old_spec, old_setting))
 931                         error = -EFAULT;
 932         }
 933         return error;
 934 }
 935
 936 #ifdef CONFIG_COMPAT_32BIT_TIME
 937 SYSCALL_DEFINE4(timer_settime32, timer_t, timer_id, int, flags,
 938                 struct old_itimerspec32 __user *, new,
 939                 struct old_itimerspec32 __user *, old)
 940 {
 941         struct itimerspec64 new_spec, old_spec;
 942         struct itimerspec64 *rtn = old ? &old_spec : NULL;
 943         int error = 0;
 944
 945         if (!new)
 946                 return -EINVAL;
 947         if (get_old_itimerspec32(&new_spec, new))
 948                 return -EFAULT;
 949
 950         error = do_timer_settime(timer_id, flags, &new_spec, rtn);
 951         if (!error && old) {
 952                 if (put_old_itimerspec32(&old_spec, old))
 953                         error = -EFAULT;
 954         }
 955         return error;
 956 }
 957 #endif
 958
 959 int common_timer_del(struct k_itimer *timer)
 960 {
 961         const struct k_clock *kc = timer->kclock;
 962
 963         if (kc->timer_try_to_cancel(timer) < 0)
 964                 return TIMER_RETRY;
 965         timer->it_status = POSIX_TIMER_DISARMED;
 966         return 0;
 967 }
 968
 969 /*
 970  * If the deleted timer is on the ignored list, remove it and
 971  * drop the associated reference.
 972  */
 973 static inline void posix_timer_cleanup_ignored(struct k_itimer *tmr)
 974 {
 975         if (!hlist_unhashed(&tmr->ignored_list)) {
 976                 hlist_del_init(&tmr->ignored_list);
 977                 posixtimer_putref(tmr);
 978         }
 979 }
 980
 981 static inline int timer_delete_hook(struct k_itimer *timer)
 982 {
 983         const struct k_clock *kc = timer->kclock;
 984
 985         /* Prevent signal delivery and rearming. */
 986         timer->it_signal_seq++;
 987
 988         if (WARN_ON_ONCE(!kc || !kc->timer_del))
 989                 return -EINVAL;
 990         return kc->timer_del(timer);
 991 }
 992
 993 /* Delete a POSIX.1b interval timer. */
 994 SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
 995 {
 996         struct k_itimer *timer;
 997         unsigned long flags;
 998
 999         timer = lock_timer(timer_id, &flags);
1000
1001 retry_delete:
1002         if (!timer)
1003                 return -EINVAL;
1004
1005         if (unlikely(timer_delete_hook(timer) == TIMER_RETRY)) {
1006                 /* Unlocks and relocks the timer if it still exists */
1007                 timer = timer_wait_running(timer, &flags);
1008                 goto retry_delete;
1009         }
1010
1011         spin_lock(&current->sighand->siglock);
1012         hlist_del(&timer->list);
1013         posix_timer_cleanup_ignored(timer);
1014         /*
1015          * A concurrent lookup could check timer::it_signal lockless. It
1016          * will reevaluate with timer::it_lock held and observe the NULL.
1017          *
1018          * It must be written with siglock held so that the signal code
1019          * observes timer->it_signal == NULL in do_sigaction(SIG_IGN),
1020          * which prevents it from moving a pending signal of a deleted
1021          * timer to the ignore list.
1022          */
1023         WRITE_ONCE(timer->it_signal, NULL);
1024         spin_unlock(&current->sighand->siglock);
1025
1026         unlock_timer(timer, flags);
1027         posix_timer_unhash_and_free(timer);
1028         return 0;
1029 }
1030
1031 /*
1032  * Delete a timer if it is armed, remove it from the hash and schedule it
1033  * for RCU freeing.
1034  */
1035 static void itimer_delete(struct k_itimer *timer)
1036 {
1037         unsigned long flags;
1038
1039         /*
1040          * irqsave is required to make timer_wait_running() work.
1041          */
1042         spin_lock_irqsave(&timer->it_lock, flags);
1043
1044 retry_delete:
1045         /*
1046          * Even if the timer is not longer accessible from other tasks
1047          * it still might be armed and queued in the underlying timer
1048          * mechanism. Worse, that timer mechanism might run the expiry
1049          * function concurrently.
1050          */
1051         if (timer_delete_hook(timer) == TIMER_RETRY) {
1052                 /*
1053                  * Timer is expired concurrently, prevent livelocks
1054                  * and pointless spinning on RT.
1055                  *
1056                  * timer_wait_running() drops timer::it_lock, which opens
1057                  * the possibility for another task to delete the timer.
1058                  *
1059                  * That's not possible here because this is invoked from
1060                  * do_exit() only for the last thread of the thread group.
1061                  * So no other task can access and delete that timer.
1062                  */
1063                 if (WARN_ON_ONCE(timer_wait_running(timer, &flags) != timer))
1064                         return;
1065
1066                 goto retry_delete;
1067         }
1068         hlist_del(&timer->list);
1069
1070         posix_timer_cleanup_ignored(timer);
1071
1072         /*
1073          * Setting timer::it_signal to NULL is technically not required
1074          * here as nothing can access the timer anymore legitimately via
1075          * the hash table. Set it to NULL nevertheless so that all deletion
1076          * paths are consistent.
1077          */
1078         WRITE_ONCE(timer->it_signal, NULL);
1079
1080         spin_unlock_irqrestore(&timer->it_lock, flags);
1081         posix_timer_unhash_and_free(timer);
1082 }
1083
1084 /*
1085  * Invoked from do_exit() when the last thread of a thread group exits.
1086  * At that point no other task can access the timers of the dying
1087  * task anymore.
1088  */
1089 void exit_itimers(struct task_struct *tsk)
1090 {
1091         struct hlist_head timers;
1092
1093         if (hlist_empty(&tsk->signal->posix_timers))
1094                 return;
1095
1096         /* Protect against concurrent read via /proc/$PID/timers */
1097         spin_lock_irq(&tsk->sighand->siglock);
1098         hlist_move_list(&tsk->signal->posix_timers, &timers);
1099         spin_unlock_irq(&tsk->sighand->siglock);
1100
1101         /* The timers are not longer accessible via tsk::signal */
1102         while (!hlist_empty(&timers))
1103                 itimer_delete(hlist_entry(timers.first, struct k_itimer, list));
1104
1105         /*
1106          * There should be no timers on the ignored list. itimer_delete() has
1107          * mopped them up.
1108          */
1109         if (!WARN_ON_ONCE(!hlist_empty(&tsk->signal->ignored_posix_timers)))
1110                 return;
1111
1112         hlist_move_list(&tsk->signal->ignored_posix_timers, &timers);
1113         while (!hlist_empty(&timers)) {
1114                 posix_timer_cleanup_ignored(hlist_entry(timers.first, struct k_itimer,
1115                                                         ignored_list));
1116         }
1117 }
1118
1119 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
1120                 const struct __kernel_timespec __user *, tp)
1121 {
1122         const struct k_clock *kc = clockid_to_kclock(which_clock);
1123         struct timespec64 new_tp;
1124
1125         if (!kc || !kc->clock_set)
1126                 return -EINVAL;
1127
1128         if (get_timespec64(&new_tp, tp))
1129                 return -EFAULT;
1130
1131         /*
1132          * Permission checks have to be done inside the clock specific
1133          * setter callback.
1134          */
1135         return kc->clock_set(which_clock, &new_tp);
1136 }
1137
1138 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
1139                 struct __kernel_timespec __user *, tp)
1140 {
1141         const struct k_clock *kc = clockid_to_kclock(which_clock);
1142         struct timespec64 kernel_tp;
1143         int error;
1144
1145         if (!kc)
1146                 return -EINVAL;
1147
1148         error = kc->clock_get_timespec(which_clock, &kernel_tp);
1149
1150         if (!error && put_timespec64(&kernel_tp, tp))
1151                 error = -EFAULT;
1152
1153         return error;
1154 }
1155
1156 int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx)
1157 {
1158         const struct k_clock *kc = clockid_to_kclock(which_clock);
1159
1160         if (!kc)
1161                 return -EINVAL;
1162         if (!kc->clock_adj)
1163                 return -EOPNOTSUPP;
1164
1165         return kc->clock_adj(which_clock, ktx);
1166 }
1167
1168 SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1169                 struct __kernel_timex __user *, utx)
1170 {
1171         struct __kernel_timex ktx;
1172         int err;
1173
1174         if (copy_from_user(&ktx, utx, sizeof(ktx)))
1175                 return -EFAULT;
1176
1177         err = do_clock_adjtime(which_clock, &ktx);
1178
1179         if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
1180                 return -EFAULT;
1181
1182         return err;
1183 }
1184
1185 /**
1186  * sys_clock_getres - Get the resolution of a clock
1187  * @which_clock:        The clock to get the resolution for
1188  * @tp:                 Pointer to a a user space timespec64 for storage
1189  *
1190  * POSIX defines:
1191  *
1192  * "The clock_getres() function shall return the resolution of any
1193  * clock. Clock resolutions are implementation-defined and cannot be set by
1194  * a process. If the argument res is not NULL, the resolution of the
1195  * specified clock shall be stored in the location pointed to by res. If
1196  * res is NULL, the clock resolution is not returned. If the time argument
1197  * of clock_settime() is not a multiple of res, then the value is truncated
1198  * to a multiple of res."
1199  *
1200  * Due to the various hardware constraints the real resolution can vary
1201  * wildly and even change during runtime when the underlying devices are
1202  * replaced. The kernel also can use hardware devices with different
1203  * resolutions for reading the time and for arming timers.
1204  *
1205  * The kernel therefore deviates from the POSIX spec in various aspects:
1206  *
1207  * 1) The resolution returned to user space
1208  *
1209  *    For CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_BOOTTIME, CLOCK_TAI,
1210  *    CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALAREM and CLOCK_MONOTONIC_RAW
1211  *    the kernel differentiates only two cases:
1212  *
1213  *    I)  Low resolution mode:
1214  *
1215  *        When high resolution timers are disabled at compile or runtime
1216  *        the resolution returned is nanoseconds per tick, which represents
1217  *        the precision at which timers expire.
1218  *
1219  *    II) High resolution mode:
1220  *
1221  *        When high resolution timers are enabled the resolution returned
1222  *        is always one nanosecond independent of the actual resolution of
1223  *        the underlying hardware devices.
1224  *
1225  *        For CLOCK_*_ALARM the actual resolution depends on system
1226  *        state. When system is running the resolution is the same as the
1227  *        resolution of the other clocks. During suspend the actual
1228  *        resolution is the resolution of the underlying RTC device which
1229  *        might be way less precise than the clockevent device used during
1230  *        running state.
1231  *
1232  *   For CLOCK_REALTIME_COARSE and CLOCK_MONOTONIC_COARSE the resolution
1233  *   returned is always nanoseconds per tick.
1234  *
1235  *   For CLOCK_PROCESS_CPUTIME and CLOCK_THREAD_CPUTIME the resolution
1236  *   returned is always one nanosecond under the assumption that the
1237  *   underlying scheduler clock has a better resolution than nanoseconds
1238  *   per tick.
1239  *
1240  *   For dynamic POSIX clocks (PTP devices) the resolution returned is
1241  *   always one nanosecond.
1242  *
1243  * 2) Affect on sys_clock_settime()
1244  *
1245  *    The kernel does not truncate the time which is handed in to
1246  *    sys_clock_settime(). The kernel internal timekeeping is always using
1247  *    nanoseconds precision independent of the clocksource device which is
1248  *    used to read the time from. The resolution of that device only
1249  *    affects the presicion of the time returned by sys_clock_gettime().
1250  *
1251  * Returns:
1252  *      0               Success. @tp contains the resolution
1253  *      -EINVAL         @which_clock is not a valid clock ID
1254  *      -EFAULT         Copying the resolution to @tp faulted
1255  *      -ENODEV         Dynamic POSIX clock is not backed by a device
1256  *      -EOPNOTSUPP     Dynamic POSIX clock does not support getres()
1257  */
1258 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
1259                 struct __kernel_timespec __user *, tp)
1260 {
1261         const struct k_clock *kc = clockid_to_kclock(which_clock);
1262         struct timespec64 rtn_tp;
1263         int error;
1264
1265         if (!kc)
1266                 return -EINVAL;
1267
1268         error = kc->clock_getres(which_clock, &rtn_tp);
1269
1270         if (!error && tp && put_timespec64(&rtn_tp, tp))
1271                 error = -EFAULT;
1272
1273         return error;
1274 }
1275
1276 #ifdef CONFIG_COMPAT_32BIT_TIME
1277
1278 SYSCALL_DEFINE2(clock_settime32, clockid_t, which_clock,
1279                 struct old_timespec32 __user *, tp)
1280 {
1281         const struct k_clock *kc = clockid_to_kclock(which_clock);
1282         struct timespec64 ts;
1283
1284         if (!kc || !kc->clock_set)
1285                 return -EINVAL;
1286
1287         if (get_old_timespec32(&ts, tp))
1288                 return -EFAULT;
1289
1290         return kc->clock_set(which_clock, &ts);
1291 }
1292
1293 SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock,
1294                 struct old_timespec32 __user *, tp)
1295 {
1296         const struct k_clock *kc = clockid_to_kclock(which_clock);
1297         struct timespec64 ts;
1298         int err;
1299
1300         if (!kc)
1301                 return -EINVAL;
1302
1303         err = kc->clock_get_timespec(which_clock, &ts);
1304
1305         if (!err && put_old_timespec32(&ts, tp))
1306                 err = -EFAULT;
1307
1308         return err;
1309 }
1310
1311 SYSCALL_DEFINE2(clock_adjtime32, clockid_t, which_clock,
1312                 struct old_timex32 __user *, utp)
1313 {
1314         struct __kernel_timex ktx;
1315         int err;
1316
1317         err = get_old_timex32(&ktx, utp);
1318         if (err)
1319                 return err;
1320
1321         err = do_clock_adjtime(which_clock, &ktx);
1322
1323         if (err >= 0 && put_old_timex32(utp, &ktx))
1324                 return -EFAULT;
1325
1326         return err;
1327 }
1328
1329 SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock,
1330                 struct old_timespec32 __user *, tp)
1331 {
1332         const struct k_clock *kc = clockid_to_kclock(which_clock);
1333         struct timespec64 ts;
1334         int err;
1335
1336         if (!kc)
1337                 return -EINVAL;
1338
1339         err = kc->clock_getres(which_clock, &ts);
1340         if (!err && tp && put_old_timespec32(&ts, tp))
1341                 return -EFAULT;
1342
1343         return err;
1344 }
1345
1346 #endif
1347
1348 /*
1349  * sys_clock_nanosleep() for CLOCK_REALTIME and CLOCK_TAI
1350  */
1351 static int common_nsleep(const clockid_t which_clock, int flags,
1352                          const struct timespec64 *rqtp)
1353 {
1354         ktime_t texp = timespec64_to_ktime(*rqtp);
1355
1356         return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
1357                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1358                                  which_clock);
1359 }
1360
1361 /*
1362  * sys_clock_nanosleep() for CLOCK_MONOTONIC and CLOCK_BOOTTIME
1363  *
1364  * Absolute nanosleeps for these clocks are time-namespace adjusted.
1365  */
1366 static int common_nsleep_timens(const clockid_t which_clock, int flags,
1367                                 const struct timespec64 *rqtp)
1368 {
1369         ktime_t texp = timespec64_to_ktime(*rqtp);
1370
1371         if (flags & TIMER_ABSTIME)
1372                 texp = timens_ktime_to_host(which_clock, texp);
1373
1374         return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
1375                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1376                                  which_clock);
1377 }
1378
1379 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
1380                 const struct __kernel_timespec __user *, rqtp,
1381                 struct __kernel_timespec __user *, rmtp)
1382 {
1383         const struct k_clock *kc = clockid_to_kclock(which_clock);
1384         struct timespec64 t;
1385
1386         if (!kc)
1387                 return -EINVAL;
1388         if (!kc->nsleep)
1389                 return -EOPNOTSUPP;
1390
1391         if (get_timespec64(&t, rqtp))
1392                 return -EFAULT;
1393
1394         if (!timespec64_valid(&t))
1395                 return -EINVAL;
1396         if (flags & TIMER_ABSTIME)
1397                 rmtp = NULL;
1398         current->restart_block.fn = do_no_restart_syscall;
1399         current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
1400         current->restart_block.nanosleep.rmtp = rmtp;
1401
1402         return kc->nsleep(which_clock, flags, &t);
1403 }
1404
1405 #ifdef CONFIG_COMPAT_32BIT_TIME
1406
1407 SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags,
1408                 struct old_timespec32 __user *, rqtp,
1409                 struct old_timespec32 __user *, rmtp)
1410 {
1411         const struct k_clock *kc = clockid_to_kclock(which_clock);
1412         struct timespec64 t;
1413
1414         if (!kc)
1415                 return -EINVAL;
1416         if (!kc->nsleep)
1417                 return -EOPNOTSUPP;
1418
1419         if (get_old_timespec32(&t, rqtp))
1420                 return -EFAULT;
1421
1422         if (!timespec64_valid(&t))
1423                 return -EINVAL;
1424         if (flags & TIMER_ABSTIME)
1425                 rmtp = NULL;
1426         current->restart_block.fn = do_no_restart_syscall;
1427         current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
1428         current->restart_block.nanosleep.compat_rmtp = rmtp;
1429
1430         return kc->nsleep(which_clock, flags, &t);
1431 }
1432
1433 #endif
1434
1435 static const struct k_clock clock_realtime = {
1436         .clock_getres           = posix_get_hrtimer_res,
1437         .clock_get_timespec     = posix_get_realtime_timespec,
1438         .clock_get_ktime        = posix_get_realtime_ktime,
1439         .clock_set              = posix_clock_realtime_set,
1440         .clock_adj              = posix_clock_realtime_adj,
1441         .nsleep                 = common_nsleep,
1442         .timer_create           = common_timer_create,
1443         .timer_set              = common_timer_set,
1444         .timer_get              = common_timer_get,
1445         .timer_del              = common_timer_del,
1446         .timer_rearm            = common_hrtimer_rearm,
1447         .timer_forward          = common_hrtimer_forward,
1448         .timer_remaining        = common_hrtimer_remaining,
1449         .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
1450         .timer_wait_running     = common_timer_wait_running,
1451         .timer_arm              = common_hrtimer_arm,
1452 };
1453
1454 static const struct k_clock clock_monotonic = {
1455         .clock_getres           = posix_get_hrtimer_res,
1456         .clock_get_timespec     = posix_get_monotonic_timespec,
1457         .clock_get_ktime        = posix_get_monotonic_ktime,
1458         .nsleep                 = common_nsleep_timens,
1459         .timer_create           = common_timer_create,
1460         .timer_set              = common_timer_set,
1461         .timer_get              = common_timer_get,
1462         .timer_del              = common_timer_del,
1463         .timer_rearm            = common_hrtimer_rearm,
1464         .timer_forward          = common_hrtimer_forward,
1465         .timer_remaining        = common_hrtimer_remaining,
1466         .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
1467         .timer_wait_running     = common_timer_wait_running,
1468         .timer_arm              = common_hrtimer_arm,
1469 };
1470
1471 static const struct k_clock clock_monotonic_raw = {
1472         .clock_getres           = posix_get_hrtimer_res,
1473         .clock_get_timespec     = posix_get_monotonic_raw,
1474 };
1475
1476 static const struct k_clock clock_realtime_coarse = {
1477         .clock_getres           = posix_get_coarse_res,
1478         .clock_get_timespec     = posix_get_realtime_coarse,
1479 };
1480
1481 static const struct k_clock clock_monotonic_coarse = {
1482         .clock_getres           = posix_get_coarse_res,
1483         .clock_get_timespec     = posix_get_monotonic_coarse,
1484 };
1485
1486 static const struct k_clock clock_tai = {
1487         .clock_getres           = posix_get_hrtimer_res,
1488         .clock_get_ktime        = posix_get_tai_ktime,
1489         .clock_get_timespec     = posix_get_tai_timespec,
1490         .nsleep                 = common_nsleep,
1491         .timer_create           = common_timer_create,
1492         .timer_set              = common_timer_set,
1493         .timer_get              = common_timer_get,
1494         .timer_del              = common_timer_del,
1495         .timer_rearm            = common_hrtimer_rearm,
1496         .timer_forward          = common_hrtimer_forward,
1497         .timer_remaining        = common_hrtimer_remaining,
1498         .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
1499         .timer_wait_running     = common_timer_wait_running,
1500         .timer_arm              = common_hrtimer_arm,
1501 };
1502
1503 static const struct k_clock clock_boottime = {
1504         .clock_getres           = posix_get_hrtimer_res,
1505         .clock_get_ktime        = posix_get_boottime_ktime,
1506         .clock_get_timespec     = posix_get_boottime_timespec,
1507         .nsleep                 = common_nsleep_timens,
1508         .timer_create           = common_timer_create,
1509         .timer_set              = common_timer_set,
1510         .timer_get              = common_timer_get,
1511         .timer_del              = common_timer_del,
1512         .timer_rearm            = common_hrtimer_rearm,
1513         .timer_forward          = common_hrtimer_forward,
1514         .timer_remaining        = common_hrtimer_remaining,
1515         .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
1516         .timer_wait_running     = common_timer_wait_running,
1517         .timer_arm              = common_hrtimer_arm,
1518 };
1519
1520 static const struct k_clock * const posix_clocks[] = {
1521         [CLOCK_REALTIME]                = &clock_realtime,
1522         [CLOCK_MONOTONIC]               = &clock_monotonic,
1523         [CLOCK_PROCESS_CPUTIME_ID]      = &clock_process,
1524         [CLOCK_THREAD_CPUTIME_ID]       = &clock_thread,
1525         [CLOCK_MONOTONIC_RAW]           = &clock_monotonic_raw,
1526         [CLOCK_REALTIME_COARSE]         = &clock_realtime_coarse,
1527         [CLOCK_MONOTONIC_COARSE]        = &clock_monotonic_coarse,
1528         [CLOCK_BOOTTIME]                = &clock_boottime,
1529         [CLOCK_REALTIME_ALARM]          = &alarm_clock,
1530         [CLOCK_BOOTTIME_ALARM]          = &alarm_clock,
1531         [CLOCK_TAI]                     = &clock_tai,
1532 };
1533
1534 static const struct k_clock *clockid_to_kclock(const clockid_t id)
1535 {
1536         clockid_t idx = id;
1537
1538         if (id < 0) {
1539                 return (id & CLOCKFD_MASK) == CLOCKFD ?
1540                         &clock_posix_dynamic : &clock_posix_cpu;
1541         }
1542
1543         if (id >= ARRAY_SIZE(posix_clocks))
1544                 return NULL;
1545
1546         return posix_clocks[array_index_nospec(idx, ARRAY_SIZE(posix_clocks))];
1547 }