1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * 2002-10-15 Posix Clocks & timers 4 * by George Anzinger george@mvista.com 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 34 #include "timekeeping.h" 35 #include "posix-timers.h" 36 37 /* 38 * Management arrays for POSIX timers. Timers are now kept in static hash table 39 * with 512 entries. 40 * Timer ids are allocated by local routine, which selects proper hash head by 41 * key, constructed from current->signal address and per signal struct counter. 42 * This keeps timer ids unique per process, but now they can intersect between 43 * processes. 44 */ 45 46 /* 47 * Lets keep our timers in a slab cache :-) 48 */ 49 static struct kmem_cache *posix_timers_cache; 50 51 static DEFINE_HASHTABLE(posix_timers_hashtable, 9); 52 static DEFINE_SPINLOCK(hash_lock); 53 54 static const struct k_clock * const posix_clocks[]; 55 static const struct k_clock *clockid_to_kclock(const clockid_t id); 56 static const struct k_clock clock_realtime, clock_monotonic; 57 58 /* 59 * we assume that the new SIGEV_THREAD_ID shares no bits with the other 60 * SIGEV values. Here we put out an error if this assumption fails. 61 */ 62 #if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \ 63 ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD)) 64 #error "SIGEV_THREAD_ID must not share bit with other SIGEV values!" 65 #endif 66 67 /* 68 * The timer ID is turned into a timer address by idr_find(). 69 * Verifying a valid ID consists of: 70 * 71 * a) checking that idr_find() returns other than -1. 72 * b) checking that the timer id matches the one in the timer itself. 73 * c) that the timer owner is in the callers thread group. 74 */ 75 76 /* 77 * CLOCKs: The POSIX standard calls for a couple of clocks and allows us 78 * to implement others. This structure defines the various 79 * clocks. 80 * 81 * RESOLUTION: Clock resolution is used to round up timer and interval 82 * times, NOT to report clock times, which are reported with as 83 * much resolution as the system can muster. In some cases this 84 * resolution may depend on the underlying clock hardware and 85 * may not be quantifiable until run time, and only then is the 86 * necessary code is written. The standard says we should say 87 * something about this issue in the documentation... 88 * 89 * FUNCTIONS: The CLOCKs structure defines possible functions to 90 * handle various clock functions. 91 * 92 * The standard POSIX timer management code assumes the 93 * following: 1.) The k_itimer struct (sched.h) is used for 94 * the timer. 2.) The list, it_lock, it_clock, it_id and 95 * it_pid fields are not modified by timer code. 96 * 97 * Permissions: It is assumed that the clock_settime() function defined 98 * for each clock will take care of permission checks. Some 99 * clocks may be set able by any user (i.e. local process 100 * clocks) others not. Currently the only set able clock we 101 * have is CLOCK_REALTIME and its high res counter part, both of 102 * which we beg off on and pass to do_sys_settimeofday(). 103 */ 104 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags); 105 106 #define lock_timer(tid, flags) \ 107 ({ struct k_itimer *__timr; \ 108 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \ 109 __timr; \ 110 }) 111 112 static int hash(struct signal_struct *sig, unsigned int nr) 113 { 114 return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable)); 115 } 116 117 static struct k_itimer *__posix_timers_find(struct hlist_head *head, 118 struct signal_struct *sig, 119 timer_t id) 120 { 121 struct k_itimer *timer; 122 123 hlist_for_each_entry_rcu(timer, head, t_hash) { 124 if ((timer->it_signal == sig) && (timer->it_id == id)) 125 return timer; 126 } 127 return NULL; 128 } 129 130 static struct k_itimer *posix_timer_by_id(timer_t id) 131 { 132 struct signal_struct *sig = current->signal; 133 struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)]; 134 135 return __posix_timers_find(head, sig, id); 136 } 137 138 static int posix_timer_add(struct k_itimer *timer) 139 { 140 struct signal_struct *sig = current->signal; 141 int first_free_id = sig->posix_timer_id; 142 struct hlist_head *head; 143 int ret = -ENOENT; 144 145 do { 146 spin_lock(&hash_lock); 147 head = &posix_timers_hashtable[hash(sig, sig->posix_timer_id)]; 148 if (!__posix_timers_find(head, sig, sig->posix_timer_id)) { 149 hlist_add_head_rcu(&timer->t_hash, head); 150 ret = sig->posix_timer_id; 151 } 152 if (++sig->posix_timer_id < 0) 153 sig->posix_timer_id = 0; 154 if ((sig->posix_timer_id == first_free_id) && (ret == -ENOENT)) 155 /* Loop over all possible ids completed */ 156 ret = -EAGAIN; 157 spin_unlock(&hash_lock); 158 } while (ret == -ENOENT); 159 return ret; 160 } 161 162 static inline void unlock_timer(struct k_itimer *timr, unsigned long flags) 163 { 164 spin_unlock_irqrestore(&timr->it_lock, flags); 165 } 166 167 /* Get clock_realtime */ 168 static int posix_clock_realtime_get(clockid_t which_clock, struct timespec64 *tp) 169 { 170 ktime_get_real_ts64(tp); 171 return 0; 172 } 173 174 /* Set clock_realtime */ 175 static int posix_clock_realtime_set(const clockid_t which_clock, 176 const struct timespec64 *tp) 177 { 178 return do_sys_settimeofday64(tp, NULL); 179 } 180 181 static int posix_clock_realtime_adj(const clockid_t which_clock, 182 struct __kernel_timex *t) 183 { 184 return do_adjtimex(t); 185 } 186 187 /* 188 * Get monotonic time for posix timers 189 */ 190 static int posix_ktime_get_ts(clockid_t which_clock, struct timespec64 *tp) 191 { 192 ktime_get_ts64(tp); 193 return 0; 194 } 195 196 /* 197 * Get monotonic-raw time for posix timers 198 */ 199 static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec64 *tp) 200 { 201 ktime_get_raw_ts64(tp); 202 return 0; 203 } 204 205 206 static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec64 *tp) 207 { 208 ktime_get_coarse_real_ts64(tp); 209 return 0; 210 } 211 212 static int posix_get_monotonic_coarse(clockid_t which_clock, 213 struct timespec64 *tp) 214 { 215 ktime_get_coarse_ts64(tp); 216 return 0; 217 } 218 219 static int posix_get_coarse_res(const clockid_t which_clock, struct timespec64 *tp) 220 { 221 *tp = ktime_to_timespec64(KTIME_LOW_RES); 222 return 0; 223 } 224 225 static int posix_get_boottime(const clockid_t which_clock, struct timespec64 *tp) 226 { 227 ktime_get_boottime_ts64(tp); 228 return 0; 229 } 230 231 static int posix_get_tai(clockid_t which_clock, struct timespec64 *tp) 232 { 233 ktime_get_clocktai_ts64(tp); 234 return 0; 235 } 236 237 static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp) 238 { 239 tp->tv_sec = 0; 240 tp->tv_nsec = hrtimer_resolution; 241 return 0; 242 } 243 244 /* 245 * Initialize everything, well, just everything in Posix clocks/timers ;) 246 */ 247 static __init int init_posix_timers(void) 248 { 249 posix_timers_cache = kmem_cache_create("posix_timers_cache", 250 sizeof (struct k_itimer), 0, SLAB_PANIC, 251 NULL); 252 return 0; 253 } 254 __initcall(init_posix_timers); 255 256 /* 257 * The siginfo si_overrun field and the return value of timer_getoverrun(2) 258 * are of type int. Clamp the overrun value to INT_MAX 259 */ 260 static inline int timer_overrun_to_int(struct k_itimer *timr, int baseval) 261 { 262 s64 sum = timr->it_overrun_last + (s64)baseval; 263 264 return sum > (s64)INT_MAX ? INT_MAX : (int)sum; 265 } 266 267 static void common_hrtimer_rearm(struct k_itimer *timr) 268 { 269 struct hrtimer *timer = &timr->it.real.timer; 270 271 timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(), 272 timr->it_interval); 273 hrtimer_restart(timer); 274 } 275 276 /* 277 * This function is exported for use by the signal deliver code. It is 278 * called just prior to the info block being released and passes that 279 * block to us. It's function is to update the overrun entry AND to 280 * restart the timer. It should only be called if the timer is to be 281 * restarted (i.e. we have flagged this in the sys_private entry of the 282 * info block). 283 * 284 * To protect against the timer going away while the interrupt is queued, 285 * we require that the it_requeue_pending flag be set. 286 */ 287 void posixtimer_rearm(struct kernel_siginfo *info) 288 { 289 struct k_itimer *timr; 290 unsigned long flags; 291 292 timr = lock_timer(info->si_tid, &flags); 293 if (!timr) 294 return; 295 296 if (timr->it_interval && timr->it_requeue_pending == info->si_sys_private) { 297 timr->kclock->timer_rearm(timr); 298 299 timr->it_active = 1; 300 timr->it_overrun_last = timr->it_overrun; 301 timr->it_overrun = -1LL; 302 ++timr->it_requeue_pending; 303 304 info->si_overrun = timer_overrun_to_int(timr, info->si_overrun); 305 } 306 307 unlock_timer(timr, flags); 308 } 309 310 int posix_timer_event(struct k_itimer *timr, int si_private) 311 { 312 enum pid_type type; 313 int ret = -1; 314 /* 315 * FIXME: if ->sigq is queued we can race with 316 * dequeue_signal()->posixtimer_rearm(). 317 * 318 * If dequeue_signal() sees the "right" value of 319 * si_sys_private it calls posixtimer_rearm(). 320 * We re-queue ->sigq and drop ->it_lock(). 321 * posixtimer_rearm() locks the timer 322 * and re-schedules it while ->sigq is pending. 323 * Not really bad, but not that we want. 324 */ 325 timr->sigq->info.si_sys_private = si_private; 326 327 type = !(timr->it_sigev_notify & SIGEV_THREAD_ID) ? PIDTYPE_TGID : PIDTYPE_PID; 328 ret = send_sigqueue(timr->sigq, timr->it_pid, type); 329 /* If we failed to send the signal the timer stops. */ 330 return ret > 0; 331 } 332 333 /* 334 * This function gets called when a POSIX.1b interval timer expires. It 335 * is used as a callback from the kernel internal timer. The 336 * run_timer_list code ALWAYS calls with interrupts on. 337 338 * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers. 339 */ 340 static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer) 341 { 342 struct k_itimer *timr; 343 unsigned long flags; 344 int si_private = 0; 345 enum hrtimer_restart ret = HRTIMER_NORESTART; 346 347 timr = container_of(timer, struct k_itimer, it.real.timer); 348 spin_lock_irqsave(&timr->it_lock, flags); 349 350 timr->it_active = 0; 351 if (timr->it_interval != 0) 352 si_private = ++timr->it_requeue_pending; 353 354 if (posix_timer_event(timr, si_private)) { 355 /* 356 * signal was not sent because of sig_ignor 357 * we will not get a call back to restart it AND 358 * it should be restarted. 359 */ 360 if (timr->it_interval != 0) { 361 ktime_t now = hrtimer_cb_get_time(timer); 362 363 /* 364 * FIXME: What we really want, is to stop this 365 * timer completely and restart it in case the 366 * SIG_IGN is removed. This is a non trivial 367 * change which involves sighand locking 368 * (sigh !), which we don't want to do late in 369 * the release cycle. 370 * 371 * For now we just let timers with an interval 372 * less than a jiffie expire every jiffie to 373 * avoid softirq starvation in case of SIG_IGN 374 * and a very small interval, which would put 375 * the timer right back on the softirq pending 376 * list. By moving now ahead of time we trick 377 * hrtimer_forward() to expire the timer 378 * later, while we still maintain the overrun 379 * accuracy, but have some inconsistency in 380 * the timer_gettime() case. This is at least 381 * better than a starved softirq. A more 382 * complex fix which solves also another related 383 * inconsistency is already in the pipeline. 384 */ 385 #ifdef CONFIG_HIGH_RES_TIMERS 386 { 387 ktime_t kj = NSEC_PER_SEC / HZ; 388 389 if (timr->it_interval < kj) 390 now = ktime_add(now, kj); 391 } 392 #endif 393 timr->it_overrun += hrtimer_forward(timer, now, 394 timr->it_interval); 395 ret = HRTIMER_RESTART; 396 ++timr->it_requeue_pending; 397 timr->it_active = 1; 398 } 399 } 400 401 unlock_timer(timr, flags); 402 return ret; 403 } 404 405 static struct pid *good_sigevent(sigevent_t * event) 406 { 407 struct pid *pid = task_tgid(current); 408 struct task_struct *rtn; 409 410 switch (event->sigev_notify) { 411 case SIGEV_SIGNAL | SIGEV_THREAD_ID: 412 pid = find_vpid(event->sigev_notify_thread_id); 413 rtn = pid_task(pid, PIDTYPE_PID); 414 if (!rtn || !same_thread_group(rtn, current)) 415 return NULL; 416 /* FALLTHRU */ 417 case SIGEV_SIGNAL: 418 case SIGEV_THREAD: 419 if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX) 420 return NULL; 421 /* FALLTHRU */ 422 case SIGEV_NONE: 423 return pid; 424 default: 425 return NULL; 426 } 427 } 428 429 static struct k_itimer * alloc_posix_timer(void) 430 { 431 struct k_itimer *tmr; 432 tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL); 433 if (!tmr) 434 return tmr; 435 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) { 436 kmem_cache_free(posix_timers_cache, tmr); 437 return NULL; 438 } 439 clear_siginfo(&tmr->sigq->info); 440 return tmr; 441 } 442 443 static void k_itimer_rcu_free(struct rcu_head *head) 444 { 445 struct k_itimer *tmr = container_of(head, struct k_itimer, rcu); 446 447 kmem_cache_free(posix_timers_cache, tmr); 448 } 449 450 #define IT_ID_SET 1 451 #define IT_ID_NOT_SET 0 452 static void release_posix_timer(struct k_itimer *tmr, int it_id_set) 453 { 454 if (it_id_set) { 455 unsigned long flags; 456 spin_lock_irqsave(&hash_lock, flags); 457 hlist_del_rcu(&tmr->t_hash); 458 spin_unlock_irqrestore(&hash_lock, flags); 459 } 460 put_pid(tmr->it_pid); 461 sigqueue_free(tmr->sigq); 462 call_rcu(&tmr->rcu, k_itimer_rcu_free); 463 } 464 465 static int common_timer_create(struct k_itimer *new_timer) 466 { 467 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0); 468 return 0; 469 } 470 471 /* Create a POSIX.1b interval timer. */ 472 static int do_timer_create(clockid_t which_clock, struct sigevent *event, 473 timer_t __user *created_timer_id) 474 { 475 const struct k_clock *kc = clockid_to_kclock(which_clock); 476 struct k_itimer *new_timer; 477 int error, new_timer_id; 478 int it_id_set = IT_ID_NOT_SET; 479 480 if (!kc) 481 return -EINVAL; 482 if (!kc->timer_create) 483 return -EOPNOTSUPP; 484 485 new_timer = alloc_posix_timer(); 486 if (unlikely(!new_timer)) 487 return -EAGAIN; 488 489 spin_lock_init(&new_timer->it_lock); 490 new_timer_id = posix_timer_add(new_timer); 491 if (new_timer_id < 0) { 492 error = new_timer_id; 493 goto out; 494 } 495 496 it_id_set = IT_ID_SET; 497 new_timer->it_id = (timer_t) new_timer_id; 498 new_timer->it_clock = which_clock; 499 new_timer->kclock = kc; 500 new_timer->it_overrun = -1LL; 501 502 if (event) { 503 rcu_read_lock(); 504 new_timer->it_pid = get_pid(good_sigevent(event)); 505 rcu_read_unlock(); 506 if (!new_timer->it_pid) { 507 error = -EINVAL; 508 goto out; 509 } 510 new_timer->it_sigev_notify = event->sigev_notify; 511 new_timer->sigq->info.si_signo = event->sigev_signo; 512 new_timer->sigq->info.si_value = event->sigev_value; 513 } else { 514 new_timer->it_sigev_notify = SIGEV_SIGNAL; 515 new_timer->sigq->info.si_signo = SIGALRM; 516 memset(&new_timer->sigq->info.si_value, 0, sizeof(sigval_t)); 517 new_timer->sigq->info.si_value.sival_int = new_timer->it_id; 518 new_timer->it_pid = get_pid(task_tgid(current)); 519 } 520 521 new_timer->sigq->info.si_tid = new_timer->it_id; 522 new_timer->sigq->info.si_code = SI_TIMER; 523 524 if (copy_to_user(created_timer_id, 525 &new_timer_id, sizeof (new_timer_id))) { 526 error = -EFAULT; 527 goto out; 528 } 529 530 error = kc->timer_create(new_timer); 531 if (error) 532 goto out; 533 534 spin_lock_irq(¤t->sighand->siglock); 535 new_timer->it_signal = current->signal; 536 list_add(&new_timer->list, ¤t->signal->posix_timers); 537 spin_unlock_irq(¤t->sighand->siglock); 538 539 return 0; 540 /* 541 * In the case of the timer belonging to another task, after 542 * the task is unlocked, the timer is owned by the other task 543 * and may cease to exist at any time. Don't use or modify 544 * new_timer after the unlock call. 545 */ 546 out: 547 release_posix_timer(new_timer, it_id_set); 548 return error; 549 } 550 551 SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock, 552 struct sigevent __user *, timer_event_spec, 553 timer_t __user *, created_timer_id) 554 { 555 if (timer_event_spec) { 556 sigevent_t event; 557 558 if (copy_from_user(&event, timer_event_spec, sizeof (event))) 559 return -EFAULT; 560 return do_timer_create(which_clock, &event, created_timer_id); 561 } 562 return do_timer_create(which_clock, NULL, created_timer_id); 563 } 564 565 #ifdef CONFIG_COMPAT 566 COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock, 567 struct compat_sigevent __user *, timer_event_spec, 568 timer_t __user *, created_timer_id) 569 { 570 if (timer_event_spec) { 571 sigevent_t event; 572 573 if (get_compat_sigevent(&event, timer_event_spec)) 574 return -EFAULT; 575 return do_timer_create(which_clock, &event, created_timer_id); 576 } 577 return do_timer_create(which_clock, NULL, created_timer_id); 578 } 579 #endif 580 581 /* 582 * Locking issues: We need to protect the result of the id look up until 583 * we get the timer locked down so it is not deleted under us. The 584 * removal is done under the idr spinlock so we use that here to bridge 585 * the find to the timer lock. To avoid a dead lock, the timer id MUST 586 * be release with out holding the timer lock. 587 */ 588 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags) 589 { 590 struct k_itimer *timr; 591 592 /* 593 * timer_t could be any type >= int and we want to make sure any 594 * @timer_id outside positive int range fails lookup. 595 */ 596 if ((unsigned long long)timer_id > INT_MAX) 597 return NULL; 598 599 rcu_read_lock(); 600 timr = posix_timer_by_id(timer_id); 601 if (timr) { 602 spin_lock_irqsave(&timr->it_lock, *flags); 603 if (timr->it_signal == current->signal) { 604 rcu_read_unlock(); 605 return timr; 606 } 607 spin_unlock_irqrestore(&timr->it_lock, *flags); 608 } 609 rcu_read_unlock(); 610 611 return NULL; 612 } 613 614 static ktime_t common_hrtimer_remaining(struct k_itimer *timr, ktime_t now) 615 { 616 struct hrtimer *timer = &timr->it.real.timer; 617 618 return __hrtimer_expires_remaining_adjusted(timer, now); 619 } 620 621 static s64 common_hrtimer_forward(struct k_itimer *timr, ktime_t now) 622 { 623 struct hrtimer *timer = &timr->it.real.timer; 624 625 return hrtimer_forward(timer, now, timr->it_interval); 626 } 627 628 /* 629 * Get the time remaining on a POSIX.1b interval timer. This function 630 * is ALWAYS called with spin_lock_irq on the timer, thus it must not 631 * mess with irq. 632 * 633 * We have a couple of messes to clean up here. First there is the case 634 * of a timer that has a requeue pending. These timers should appear to 635 * be in the timer list with an expiry as if we were to requeue them 636 * now. 637 * 638 * The second issue is the SIGEV_NONE timer which may be active but is 639 * not really ever put in the timer list (to save system resources). 640 * This timer may be expired, and if so, we will do it here. Otherwise 641 * it is the same as a requeue pending timer WRT to what we should 642 * report. 643 */ 644 void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting) 645 { 646 const struct k_clock *kc = timr->kclock; 647 ktime_t now, remaining, iv; 648 struct timespec64 ts64; 649 bool sig_none; 650 651 sig_none = timr->it_sigev_notify == SIGEV_NONE; 652 iv = timr->it_interval; 653 654 /* interval timer ? */ 655 if (iv) { 656 cur_setting->it_interval = ktime_to_timespec64(iv); 657 } else if (!timr->it_active) { 658 /* 659 * SIGEV_NONE oneshot timers are never queued. Check them 660 * below. 661 */ 662 if (!sig_none) 663 return; 664 } 665 666 /* 667 * The timespec64 based conversion is suboptimal, but it's not 668 * worth to implement yet another callback. 669 */ 670 kc->clock_get(timr->it_clock, &ts64); 671 now = timespec64_to_ktime(ts64); 672 673 /* 674 * When a requeue is pending or this is a SIGEV_NONE timer move the 675 * expiry time forward by intervals, so expiry is > now. 676 */ 677 if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || sig_none)) 678 timr->it_overrun += kc->timer_forward(timr, now); 679 680 remaining = kc->timer_remaining(timr, now); 681 /* Return 0 only, when the timer is expired and not pending */ 682 if (remaining <= 0) { 683 /* 684 * A single shot SIGEV_NONE timer must return 0, when 685 * it is expired ! 686 */ 687 if (!sig_none) 688 cur_setting->it_value.tv_nsec = 1; 689 } else { 690 cur_setting->it_value = ktime_to_timespec64(remaining); 691 } 692 } 693 694 /* Get the time remaining on a POSIX.1b interval timer. */ 695 static int do_timer_gettime(timer_t timer_id, struct itimerspec64 *setting) 696 { 697 struct k_itimer *timr; 698 const struct k_clock *kc; 699 unsigned long flags; 700 int ret = 0; 701 702 timr = lock_timer(timer_id, &flags); 703 if (!timr) 704 return -EINVAL; 705 706 memset(setting, 0, sizeof(*setting)); 707 kc = timr->kclock; 708 if (WARN_ON_ONCE(!kc || !kc->timer_get)) 709 ret = -EINVAL; 710 else 711 kc->timer_get(timr, setting); 712 713 unlock_timer(timr, flags); 714 return ret; 715 } 716 717 /* Get the time remaining on a POSIX.1b interval timer. */ 718 SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id, 719 struct __kernel_itimerspec __user *, setting) 720 { 721 struct itimerspec64 cur_setting; 722 723 int ret = do_timer_gettime(timer_id, &cur_setting); 724 if (!ret) { 725 if (put_itimerspec64(&cur_setting, setting)) 726 ret = -EFAULT; 727 } 728 return ret; 729 } 730 731 #ifdef CONFIG_COMPAT_32BIT_TIME 732 733 SYSCALL_DEFINE2(timer_gettime32, timer_t, timer_id, 734 struct old_itimerspec32 __user *, setting) 735 { 736 struct itimerspec64 cur_setting; 737 738 int ret = do_timer_gettime(timer_id, &cur_setting); 739 if (!ret) { 740 if (put_old_itimerspec32(&cur_setting, setting)) 741 ret = -EFAULT; 742 } 743 return ret; 744 } 745 746 #endif 747 748 /* 749 * Get the number of overruns of a POSIX.1b interval timer. This is to 750 * be the overrun of the timer last delivered. At the same time we are 751 * accumulating overruns on the next timer. The overrun is frozen when 752 * the signal is delivered, either at the notify time (if the info block 753 * is not queued) or at the actual delivery time (as we are informed by 754 * the call back to posixtimer_rearm(). So all we need to do is 755 * to pick up the frozen overrun. 756 */ 757 SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id) 758 { 759 struct k_itimer *timr; 760 int overrun; 761 unsigned long flags; 762 763 timr = lock_timer(timer_id, &flags); 764 if (!timr) 765 return -EINVAL; 766 767 overrun = timer_overrun_to_int(timr, 0); 768 unlock_timer(timr, flags); 769 770 return overrun; 771 } 772 773 static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires, 774 bool absolute, bool sigev_none) 775 { 776 struct hrtimer *timer = &timr->it.real.timer; 777 enum hrtimer_mode mode; 778 779 mode = absolute ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL; 780 /* 781 * Posix magic: Relative CLOCK_REALTIME timers are not affected by 782 * clock modifications, so they become CLOCK_MONOTONIC based under the 783 * hood. See hrtimer_init(). Update timr->kclock, so the generic 784 * functions which use timr->kclock->clock_get() work. 785 * 786 * Note: it_clock stays unmodified, because the next timer_set() might 787 * use ABSTIME, so it needs to switch back. 788 */ 789 if (timr->it_clock == CLOCK_REALTIME) 790 timr->kclock = absolute ? &clock_realtime : &clock_monotonic; 791 792 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode); 793 timr->it.real.timer.function = posix_timer_fn; 794 795 if (!absolute) 796 expires = ktime_add_safe(expires, timer->base->get_time()); 797 hrtimer_set_expires(timer, expires); 798 799 if (!sigev_none) 800 hrtimer_start_expires(timer, HRTIMER_MODE_ABS); 801 } 802 803 static int common_hrtimer_try_to_cancel(struct k_itimer *timr) 804 { 805 return hrtimer_try_to_cancel(&timr->it.real.timer); 806 } 807 808 static void common_timer_wait_running(struct k_itimer *timer) 809 { 810 hrtimer_cancel_wait_running(&timer->it.real.timer); 811 } 812 813 /* 814 * On PREEMPT_RT this prevent priority inversion against softirq kthread in 815 * case it gets preempted while executing a timer callback. See comments in 816 * hrtimer_cancel_wait_running. For PREEMPT_RT=n this just results in a 817 * cpu_relax(). 818 */ 819 static struct k_itimer *timer_wait_running(struct k_itimer *timer, 820 unsigned long *flags) 821 { 822 const struct k_clock *kc = READ_ONCE(timer->kclock); 823 timer_t timer_id = READ_ONCE(timer->it_id); 824 825 /* Prevent kfree(timer) after dropping the lock */ 826 rcu_read_lock(); 827 unlock_timer(timer, *flags); 828 829 if (!WARN_ON_ONCE(!kc->timer_wait_running)) 830 kc->timer_wait_running(timer); 831 832 rcu_read_unlock(); 833 /* Relock the timer. It might be not longer hashed. */ 834 return lock_timer(timer_id, flags); 835 } 836 837 /* Set a POSIX.1b interval timer. */ 838 int common_timer_set(struct k_itimer *timr, int flags, 839 struct itimerspec64 *new_setting, 840 struct itimerspec64 *old_setting) 841 { 842 const struct k_clock *kc = timr->kclock; 843 bool sigev_none; 844 ktime_t expires; 845 846 if (old_setting) 847 common_timer_get(timr, old_setting); 848 849 /* Prevent rearming by clearing the interval */ 850 timr->it_interval = 0; 851 /* 852 * Careful here. On SMP systems the timer expiry function could be 853 * active and spinning on timr->it_lock. 854 */ 855 if (kc->timer_try_to_cancel(timr) < 0) 856 return TIMER_RETRY; 857 858 timr->it_active = 0; 859 timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 860 ~REQUEUE_PENDING; 861 timr->it_overrun_last = 0; 862 863 /* Switch off the timer when it_value is zero */ 864 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec) 865 return 0; 866 867 timr->it_interval = timespec64_to_ktime(new_setting->it_interval); 868 expires = timespec64_to_ktime(new_setting->it_value); 869 sigev_none = timr->it_sigev_notify == SIGEV_NONE; 870 871 kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none); 872 timr->it_active = !sigev_none; 873 return 0; 874 } 875 876 static int do_timer_settime(timer_t timer_id, int tmr_flags, 877 struct itimerspec64 *new_spec64, 878 struct itimerspec64 *old_spec64) 879 { 880 const struct k_clock *kc; 881 struct k_itimer *timr; 882 unsigned long flags; 883 int error = 0; 884 885 if (!timespec64_valid(&new_spec64->it_interval) || 886 !timespec64_valid(&new_spec64->it_value)) 887 return -EINVAL; 888 889 if (old_spec64) 890 memset(old_spec64, 0, sizeof(*old_spec64)); 891 892 timr = lock_timer(timer_id, &flags); 893 retry: 894 if (!timr) 895 return -EINVAL; 896 897 kc = timr->kclock; 898 if (WARN_ON_ONCE(!kc || !kc->timer_set)) 899 error = -EINVAL; 900 else 901 error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64); 902 903 if (error == TIMER_RETRY) { 904 // We already got the old time... 905 old_spec64 = NULL; 906 /* Unlocks and relocks the timer if it still exists */ 907 timr = timer_wait_running(timr, &flags); 908 goto retry; 909 } 910 unlock_timer(timr, flags); 911 912 return error; 913 } 914 915 /* Set a POSIX.1b interval timer */ 916 SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags, 917 const struct __kernel_itimerspec __user *, new_setting, 918 struct __kernel_itimerspec __user *, old_setting) 919 { 920 struct itimerspec64 new_spec, old_spec; 921 struct itimerspec64 *rtn = old_setting ? &old_spec : NULL; 922 int error = 0; 923 924 if (!new_setting) 925 return -EINVAL; 926 927 if (get_itimerspec64(&new_spec, new_setting)) 928 return -EFAULT; 929 930 error = do_timer_settime(timer_id, flags, &new_spec, rtn); 931 if (!error && old_setting) { 932 if (put_itimerspec64(&old_spec, old_setting)) 933 error = -EFAULT; 934 } 935 return error; 936 } 937 938 #ifdef CONFIG_COMPAT_32BIT_TIME 939 SYSCALL_DEFINE4(timer_settime32, timer_t, timer_id, int, flags, 940 struct old_itimerspec32 __user *, new, 941 struct old_itimerspec32 __user *, old) 942 { 943 struct itimerspec64 new_spec, old_spec; 944 struct itimerspec64 *rtn = old ? &old_spec : NULL; 945 int error = 0; 946 947 if (!new) 948 return -EINVAL; 949 if (get_old_itimerspec32(&new_spec, new)) 950 return -EFAULT; 951 952 error = do_timer_settime(timer_id, flags, &new_spec, rtn); 953 if (!error && old) { 954 if (put_old_itimerspec32(&old_spec, old)) 955 error = -EFAULT; 956 } 957 return error; 958 } 959 #endif 960 961 int common_timer_del(struct k_itimer *timer) 962 { 963 const struct k_clock *kc = timer->kclock; 964 965 timer->it_interval = 0; 966 if (kc->timer_try_to_cancel(timer) < 0) 967 return TIMER_RETRY; 968 timer->it_active = 0; 969 return 0; 970 } 971 972 static inline int timer_delete_hook(struct k_itimer *timer) 973 { 974 const struct k_clock *kc = timer->kclock; 975 976 if (WARN_ON_ONCE(!kc || !kc->timer_del)) 977 return -EINVAL; 978 return kc->timer_del(timer); 979 } 980 981 /* Delete a POSIX.1b interval timer. */ 982 SYSCALL_DEFINE1(timer_delete, timer_t, timer_id) 983 { 984 struct k_itimer *timer; 985 unsigned long flags; 986 987 timer = lock_timer(timer_id, &flags); 988 989 retry_delete: 990 if (!timer) 991 return -EINVAL; 992 993 if (unlikely(timer_delete_hook(timer) == TIMER_RETRY)) { 994 /* Unlocks and relocks the timer if it still exists */ 995 timer = timer_wait_running(timer, &flags); 996 goto retry_delete; 997 } 998 999 spin_lock(¤t->sighand->siglock); 1000 list_del(&timer->list); 1001 spin_unlock(¤t->sighand->siglock); 1002 /* 1003 * This keeps any tasks waiting on the spin lock from thinking 1004 * they got something (see the lock code above). 1005 */ 1006 timer->it_signal = NULL; 1007 1008 unlock_timer(timer, flags); 1009 release_posix_timer(timer, IT_ID_SET); 1010 return 0; 1011 } 1012 1013 /* 1014 * return timer owned by the process, used by exit_itimers 1015 */ 1016 static void itimer_delete(struct k_itimer *timer) 1017 { 1018 retry_delete: 1019 spin_lock_irq(&timer->it_lock); 1020 1021 if (timer_delete_hook(timer) == TIMER_RETRY) { 1022 spin_unlock_irq(&timer->it_lock); 1023 goto retry_delete; 1024 } 1025 list_del(&timer->list); 1026 1027 spin_unlock_irq(&timer->it_lock); 1028 release_posix_timer(timer, IT_ID_SET); 1029 } 1030 1031 /* 1032 * This is called by do_exit or de_thread, only when there are no more 1033 * references to the shared signal_struct. 1034 */ 1035 void exit_itimers(struct signal_struct *sig) 1036 { 1037 struct k_itimer *tmr; 1038 1039 while (!list_empty(&sig->posix_timers)) { 1040 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list); 1041 itimer_delete(tmr); 1042 } 1043 } 1044 1045 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, 1046 const struct __kernel_timespec __user *, tp) 1047 { 1048 const struct k_clock *kc = clockid_to_kclock(which_clock); 1049 struct timespec64 new_tp; 1050 1051 if (!kc || !kc->clock_set) 1052 return -EINVAL; 1053 1054 if (get_timespec64(&new_tp, tp)) 1055 return -EFAULT; 1056 1057 return kc->clock_set(which_clock, &new_tp); 1058 } 1059 1060 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, 1061 struct __kernel_timespec __user *, tp) 1062 { 1063 const struct k_clock *kc = clockid_to_kclock(which_clock); 1064 struct timespec64 kernel_tp; 1065 int error; 1066 1067 if (!kc) 1068 return -EINVAL; 1069 1070 error = kc->clock_get(which_clock, &kernel_tp); 1071 1072 if (!error && put_timespec64(&kernel_tp, tp)) 1073 error = -EFAULT; 1074 1075 return error; 1076 } 1077 1078 int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx) 1079 { 1080 const struct k_clock *kc = clockid_to_kclock(which_clock); 1081 1082 if (!kc) 1083 return -EINVAL; 1084 if (!kc->clock_adj) 1085 return -EOPNOTSUPP; 1086 1087 return kc->clock_adj(which_clock, ktx); 1088 } 1089 1090 SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock, 1091 struct __kernel_timex __user *, utx) 1092 { 1093 struct __kernel_timex ktx; 1094 int err; 1095 1096 if (copy_from_user(&ktx, utx, sizeof(ktx))) 1097 return -EFAULT; 1098 1099 err = do_clock_adjtime(which_clock, &ktx); 1100 1101 if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx))) 1102 return -EFAULT; 1103 1104 return err; 1105 } 1106 1107 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, 1108 struct __kernel_timespec __user *, tp) 1109 { 1110 const struct k_clock *kc = clockid_to_kclock(which_clock); 1111 struct timespec64 rtn_tp; 1112 int error; 1113 1114 if (!kc) 1115 return -EINVAL; 1116 1117 error = kc->clock_getres(which_clock, &rtn_tp); 1118 1119 if (!error && tp && put_timespec64(&rtn_tp, tp)) 1120 error = -EFAULT; 1121 1122 return error; 1123 } 1124 1125 #ifdef CONFIG_COMPAT_32BIT_TIME 1126 1127 SYSCALL_DEFINE2(clock_settime32, clockid_t, which_clock, 1128 struct old_timespec32 __user *, tp) 1129 { 1130 const struct k_clock *kc = clockid_to_kclock(which_clock); 1131 struct timespec64 ts; 1132 1133 if (!kc || !kc->clock_set) 1134 return -EINVAL; 1135 1136 if (get_old_timespec32(&ts, tp)) 1137 return -EFAULT; 1138 1139 return kc->clock_set(which_clock, &ts); 1140 } 1141 1142 SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock, 1143 struct old_timespec32 __user *, tp) 1144 { 1145 const struct k_clock *kc = clockid_to_kclock(which_clock); 1146 struct timespec64 ts; 1147 int err; 1148 1149 if (!kc) 1150 return -EINVAL; 1151 1152 err = kc->clock_get(which_clock, &ts); 1153 1154 if (!err && put_old_timespec32(&ts, tp)) 1155 err = -EFAULT; 1156 1157 return err; 1158 } 1159 1160 SYSCALL_DEFINE2(clock_adjtime32, clockid_t, which_clock, 1161 struct old_timex32 __user *, utp) 1162 { 1163 struct __kernel_timex ktx; 1164 int err; 1165 1166 err = get_old_timex32(&ktx, utp); 1167 if (err) 1168 return err; 1169 1170 err = do_clock_adjtime(which_clock, &ktx); 1171 1172 if (err >= 0) 1173 err = put_old_timex32(utp, &ktx); 1174 1175 return err; 1176 } 1177 1178 SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock, 1179 struct old_timespec32 __user *, tp) 1180 { 1181 const struct k_clock *kc = clockid_to_kclock(which_clock); 1182 struct timespec64 ts; 1183 int err; 1184 1185 if (!kc) 1186 return -EINVAL; 1187 1188 err = kc->clock_getres(which_clock, &ts); 1189 if (!err && tp && put_old_timespec32(&ts, tp)) 1190 return -EFAULT; 1191 1192 return err; 1193 } 1194 1195 #endif 1196 1197 /* 1198 * nanosleep for monotonic and realtime clocks 1199 */ 1200 static int common_nsleep(const clockid_t which_clock, int flags, 1201 const struct timespec64 *rqtp) 1202 { 1203 return hrtimer_nanosleep(rqtp, flags & TIMER_ABSTIME ? 1204 HRTIMER_MODE_ABS : HRTIMER_MODE_REL, 1205 which_clock); 1206 } 1207 1208 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, 1209 const struct __kernel_timespec __user *, rqtp, 1210 struct __kernel_timespec __user *, rmtp) 1211 { 1212 const struct k_clock *kc = clockid_to_kclock(which_clock); 1213 struct timespec64 t; 1214 1215 if (!kc) 1216 return -EINVAL; 1217 if (!kc->nsleep) 1218 return -EOPNOTSUPP; 1219 1220 if (get_timespec64(&t, rqtp)) 1221 return -EFAULT; 1222 1223 if (!timespec64_valid(&t)) 1224 return -EINVAL; 1225 if (flags & TIMER_ABSTIME) 1226 rmtp = NULL; 1227 current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE; 1228 current->restart_block.nanosleep.rmtp = rmtp; 1229 1230 return kc->nsleep(which_clock, flags, &t); 1231 } 1232 1233 #ifdef CONFIG_COMPAT_32BIT_TIME 1234 1235 SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags, 1236 struct old_timespec32 __user *, rqtp, 1237 struct old_timespec32 __user *, rmtp) 1238 { 1239 const struct k_clock *kc = clockid_to_kclock(which_clock); 1240 struct timespec64 t; 1241 1242 if (!kc) 1243 return -EINVAL; 1244 if (!kc->nsleep) 1245 return -EOPNOTSUPP; 1246 1247 if (get_old_timespec32(&t, rqtp)) 1248 return -EFAULT; 1249 1250 if (!timespec64_valid(&t)) 1251 return -EINVAL; 1252 if (flags & TIMER_ABSTIME) 1253 rmtp = NULL; 1254 current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE; 1255 current->restart_block.nanosleep.compat_rmtp = rmtp; 1256 1257 return kc->nsleep(which_clock, flags, &t); 1258 } 1259 1260 #endif 1261 1262 static const struct k_clock clock_realtime = { 1263 .clock_getres = posix_get_hrtimer_res, 1264 .clock_get = posix_clock_realtime_get, 1265 .clock_set = posix_clock_realtime_set, 1266 .clock_adj = posix_clock_realtime_adj, 1267 .nsleep = common_nsleep, 1268 .timer_create = common_timer_create, 1269 .timer_set = common_timer_set, 1270 .timer_get = common_timer_get, 1271 .timer_del = common_timer_del, 1272 .timer_rearm = common_hrtimer_rearm, 1273 .timer_forward = common_hrtimer_forward, 1274 .timer_remaining = common_hrtimer_remaining, 1275 .timer_try_to_cancel = common_hrtimer_try_to_cancel, 1276 .timer_wait_running = common_timer_wait_running, 1277 .timer_arm = common_hrtimer_arm, 1278 }; 1279 1280 static const struct k_clock clock_monotonic = { 1281 .clock_getres = posix_get_hrtimer_res, 1282 .clock_get = posix_ktime_get_ts, 1283 .nsleep = common_nsleep, 1284 .timer_create = common_timer_create, 1285 .timer_set = common_timer_set, 1286 .timer_get = common_timer_get, 1287 .timer_del = common_timer_del, 1288 .timer_rearm = common_hrtimer_rearm, 1289 .timer_forward = common_hrtimer_forward, 1290 .timer_remaining = common_hrtimer_remaining, 1291 .timer_try_to_cancel = common_hrtimer_try_to_cancel, 1292 .timer_wait_running = common_timer_wait_running, 1293 .timer_arm = common_hrtimer_arm, 1294 }; 1295 1296 static const struct k_clock clock_monotonic_raw = { 1297 .clock_getres = posix_get_hrtimer_res, 1298 .clock_get = posix_get_monotonic_raw, 1299 }; 1300 1301 static const struct k_clock clock_realtime_coarse = { 1302 .clock_getres = posix_get_coarse_res, 1303 .clock_get = posix_get_realtime_coarse, 1304 }; 1305 1306 static const struct k_clock clock_monotonic_coarse = { 1307 .clock_getres = posix_get_coarse_res, 1308 .clock_get = posix_get_monotonic_coarse, 1309 }; 1310 1311 static const struct k_clock clock_tai = { 1312 .clock_getres = posix_get_hrtimer_res, 1313 .clock_get = posix_get_tai, 1314 .nsleep = common_nsleep, 1315 .timer_create = common_timer_create, 1316 .timer_set = common_timer_set, 1317 .timer_get = common_timer_get, 1318 .timer_del = common_timer_del, 1319 .timer_rearm = common_hrtimer_rearm, 1320 .timer_forward = common_hrtimer_forward, 1321 .timer_remaining = common_hrtimer_remaining, 1322 .timer_try_to_cancel = common_hrtimer_try_to_cancel, 1323 .timer_wait_running = common_timer_wait_running, 1324 .timer_arm = common_hrtimer_arm, 1325 }; 1326 1327 static const struct k_clock clock_boottime = { 1328 .clock_getres = posix_get_hrtimer_res, 1329 .clock_get = posix_get_boottime, 1330 .nsleep = common_nsleep, 1331 .timer_create = common_timer_create, 1332 .timer_set = common_timer_set, 1333 .timer_get = common_timer_get, 1334 .timer_del = common_timer_del, 1335 .timer_rearm = common_hrtimer_rearm, 1336 .timer_forward = common_hrtimer_forward, 1337 .timer_remaining = common_hrtimer_remaining, 1338 .timer_try_to_cancel = common_hrtimer_try_to_cancel, 1339 .timer_wait_running = common_timer_wait_running, 1340 .timer_arm = common_hrtimer_arm, 1341 }; 1342 1343 static const struct k_clock * const posix_clocks[] = { 1344 [CLOCK_REALTIME] = &clock_realtime, 1345 [CLOCK_MONOTONIC] = &clock_monotonic, 1346 [CLOCK_PROCESS_CPUTIME_ID] = &clock_process, 1347 [CLOCK_THREAD_CPUTIME_ID] = &clock_thread, 1348 [CLOCK_MONOTONIC_RAW] = &clock_monotonic_raw, 1349 [CLOCK_REALTIME_COARSE] = &clock_realtime_coarse, 1350 [CLOCK_MONOTONIC_COARSE] = &clock_monotonic_coarse, 1351 [CLOCK_BOOTTIME] = &clock_boottime, 1352 [CLOCK_REALTIME_ALARM] = &alarm_clock, 1353 [CLOCK_BOOTTIME_ALARM] = &alarm_clock, 1354 [CLOCK_TAI] = &clock_tai, 1355 }; 1356 1357 static const struct k_clock *clockid_to_kclock(const clockid_t id) 1358 { 1359 clockid_t idx = id; 1360 1361 if (id < 0) { 1362 return (id & CLOCKFD_MASK) == CLOCKFD ? 1363 &clock_posix_dynamic : &clock_posix_cpu; 1364 } 1365 1366 if (id >= ARRAY_SIZE(posix_clocks)) 1367 return NULL; 1368 1369 return posix_clocks[array_index_nospec(idx, ARRAY_SIZE(posix_clocks))]; 1370 } 1371