Lines Matching +full:no +full:- +full:tick +full:- +full:in +full:- +full:suspend
1 // SPDX-License-Identifier: GPL-2.0+
3 * 2002-10-15 Posix Clocks & timers
7 * 2004-06-01 Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
24 #include <linux/posix-clock.h>
25 #include <linux/posix-timers.h>
36 #include "posix-timers.h"
41 * Timers are managed in a hash table for lockless lookup. The hash key is
66 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \
82 /* timer->it_signal can be set concurrently */ in __posix_timers_find()
83 if ((READ_ONCE(timer->it_signal) == sig) && (timer->it_id == id)) in __posix_timers_find()
91 struct signal_struct *sig = current->signal; in posix_timer_by_id()
99 struct signal_struct *sig = current->signal; in posix_timer_add()
109 id = sig->next_posix_timer_id; in posix_timer_add()
112 sig->next_posix_timer_id = (id + 1) & INT_MAX; in posix_timer_add()
116 hlist_add_head_rcu(&timer->t_hash, head); in posix_timer_add()
122 /* POSIX return code when no timer ID could be allocated */ in posix_timer_add()
123 return -EAGAIN; in posix_timer_add()
128 spin_unlock_irqrestore(&timr->it_lock, flags); in unlock_timer()
218 tp->tv_sec = 0; in posix_get_hrtimer_res()
219 tp->tv_nsec = hrtimer_resolution; in posix_get_hrtimer_res()
238 s64 sum = timr->it_overrun_last + (s64)baseval; in timer_overrun_to_int()
245 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_rearm()
247 timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(), in common_hrtimer_rearm()
248 timr->it_interval); in common_hrtimer_rearm()
254 * info->si_sys_private is not zero, which indicates that the timer has to
262 timr = lock_timer(info->si_tid, &flags); in posixtimer_rearm()
266 if (timr->it_interval && timr->it_requeue_pending == info->si_sys_private) { in posixtimer_rearm()
267 timr->kclock->timer_rearm(timr); in posixtimer_rearm()
269 timr->it_active = 1; in posixtimer_rearm()
270 timr->it_overrun_last = timr->it_overrun; in posixtimer_rearm()
271 timr->it_overrun = -1LL; in posixtimer_rearm()
272 ++timr->it_requeue_pending; in posixtimer_rearm()
274 info->si_overrun = timer_overrun_to_int(timr, info->si_overrun); in posixtimer_rearm()
285 * FIXME: if ->sigq is queued we can race with in posix_timer_event()
286 * dequeue_signal()->posixtimer_rearm(). in posix_timer_event()
290 * We re-queue ->sigq and drop ->it_lock(). in posix_timer_event()
292 * and re-schedules it while ->sigq is pending. in posix_timer_event()
295 timr->sigq->info.si_sys_private = si_private; in posix_timer_event()
297 type = !(timr->it_sigev_notify & SIGEV_THREAD_ID) ? PIDTYPE_TGID : PIDTYPE_PID; in posix_timer_event()
298 ret = send_sigqueue(timr->sigq, timr->it_pid, type); in posix_timer_event()
318 spin_lock_irqsave(&timr->it_lock, flags); in posix_timer_fn()
320 timr->it_active = 0; in posix_timer_fn()
321 if (timr->it_interval != 0) in posix_timer_fn()
322 si_private = ++timr->it_requeue_pending; in posix_timer_fn()
331 if (timr->it_interval != 0) { in posix_timer_fn()
336 * timer completely and restart it in case the in posix_timer_fn()
344 * This avoids interrupt starvation in case of a in posix_timer_fn()
351 * for the price of a slight inconsistency in the in posix_timer_fn()
356 * enabled as the periodic tick based timers are in posix_timer_fn()
357 * automatically aligned to the next tick. in posix_timer_fn()
362 if (timr->it_interval < kj) in posix_timer_fn()
366 timr->it_overrun += hrtimer_forward(timer, now, timr->it_interval); in posix_timer_fn()
368 ++timr->it_requeue_pending; in posix_timer_fn()
369 timr->it_active = 1; in posix_timer_fn()
382 switch (event->sigev_notify) { in good_sigevent()
384 pid = find_vpid(event->sigev_notify_thread_id); in good_sigevent()
391 if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX) in good_sigevent()
407 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) { in alloc_posix_timer()
411 clear_siginfo(&tmr->sigq->info); in alloc_posix_timer()
424 put_pid(tmr->it_pid); in posix_timer_free()
425 sigqueue_free(tmr->sigq); in posix_timer_free()
426 call_rcu(&tmr->rcu, k_itimer_rcu_free); in posix_timer_free()
432 hlist_del_rcu(&tmr->t_hash); in posix_timer_unhash_and_free()
439 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0); in common_timer_create()
452 return -EINVAL; in do_timer_create()
453 if (!kc->timer_create) in do_timer_create()
454 return -EOPNOTSUPP; in do_timer_create()
458 return -EAGAIN; in do_timer_create()
460 spin_lock_init(&new_timer->it_lock); in do_timer_create()
473 new_timer->it_id = (timer_t) new_timer_id; in do_timer_create()
474 new_timer->it_clock = which_clock; in do_timer_create()
475 new_timer->kclock = kc; in do_timer_create()
476 new_timer->it_overrun = -1LL; in do_timer_create()
480 new_timer->it_pid = get_pid(good_sigevent(event)); in do_timer_create()
482 if (!new_timer->it_pid) { in do_timer_create()
483 error = -EINVAL; in do_timer_create()
486 new_timer->it_sigev_notify = event->sigev_notify; in do_timer_create()
487 new_timer->sigq->info.si_signo = event->sigev_signo; in do_timer_create()
488 new_timer->sigq->info.si_value = event->sigev_value; in do_timer_create()
490 new_timer->it_sigev_notify = SIGEV_SIGNAL; in do_timer_create()
491 new_timer->sigq->info.si_signo = SIGALRM; in do_timer_create()
492 memset(&new_timer->sigq->info.si_value, 0, sizeof(sigval_t)); in do_timer_create()
493 new_timer->sigq->info.si_value.sival_int = new_timer->it_id; in do_timer_create()
494 new_timer->it_pid = get_pid(task_tgid(current)); in do_timer_create()
497 new_timer->sigq->info.si_tid = new_timer->it_id; in do_timer_create()
498 new_timer->sigq->info.si_code = SI_TIMER; in do_timer_create()
501 error = -EFAULT; in do_timer_create()
511 error = kc->timer_create(new_timer); in do_timer_create()
515 spin_lock_irq(¤t->sighand->siglock); in do_timer_create()
516 /* This makes the timer valid in the hash table */ in do_timer_create()
517 WRITE_ONCE(new_timer->it_signal, current->signal); in do_timer_create()
518 list_add(&new_timer->list, ¤t->signal->posix_timers); in do_timer_create()
519 spin_unlock_irq(¤t->sighand->siglock); in do_timer_create()
538 return -EFAULT; in SYSCALL_DEFINE3()
553 return -EFAULT; in COMPAT_SYSCALL_DEFINE3()
574 * Timers are added to the hash in invalid state where in __lock_timer()
578 * Timer destruction happens in steps: in __lock_timer()
595 spin_lock_irqsave(&timr->it_lock, *flags); in __lock_timer()
600 if (timr->it_signal == current->signal) { in __lock_timer()
604 spin_unlock_irqrestore(&timr->it_lock, *flags); in __lock_timer()
613 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_remaining()
620 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_forward()
622 return hrtimer_forward(timer, now, timr->it_interval); in common_hrtimer_forward()
639 const struct k_clock *kc = timr->kclock; in common_timer_get()
643 sig_none = timr->it_sigev_notify == SIGEV_NONE; in common_timer_get()
644 iv = timr->it_interval; in common_timer_get()
648 cur_setting->it_interval = ktime_to_timespec64(iv); in common_timer_get()
649 } else if (!timr->it_active) { in common_timer_get()
652 * timr->it_active is always false. The check below in common_timer_get()
662 now = kc->clock_get_ktime(timr->it_clock); in common_timer_get()
669 if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || sig_none)) in common_timer_get()
670 timr->it_overrun += kc->timer_forward(timr, now); in common_timer_get()
672 remaining = kc->timer_remaining(timr, now); in common_timer_get()
690 cur_setting->it_value.tv_nsec = 1; in common_timer_get()
692 cur_setting->it_value = ktime_to_timespec64(remaining); in common_timer_get()
705 return -EINVAL; in do_timer_gettime()
708 kc = timr->kclock; in do_timer_gettime()
709 if (WARN_ON_ONCE(!kc || !kc->timer_get)) in do_timer_gettime()
710 ret = -EINVAL; in do_timer_gettime()
712 kc->timer_get(timr, setting); in do_timer_gettime()
727 ret = -EFAULT; in SYSCALL_DEFINE2()
742 ret = -EFAULT; in SYSCALL_DEFINE2()
750 * sys_timer_getoverrun - Get the number of overruns of a POSIX.1b interval timer
764 * -EINVAL @timer_id is invalid
775 return -EINVAL; in SYSCALL_DEFINE1()
786 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_arm()
793 * hood. See hrtimer_init(). Update timr->kclock, so the generic in common_hrtimer_arm()
794 * functions which use timr->kclock->clock_get_*() work. in common_hrtimer_arm()
799 if (timr->it_clock == CLOCK_REALTIME) in common_hrtimer_arm()
800 timr->kclock = absolute ? &clock_realtime : &clock_monotonic; in common_hrtimer_arm()
802 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode); in common_hrtimer_arm()
803 timr->it.real.timer.function = posix_timer_fn; in common_hrtimer_arm()
806 expires = ktime_add_safe(expires, timer->base->get_time()); in common_hrtimer_arm()
815 return hrtimer_try_to_cancel(&timr->it.real.timer); in common_hrtimer_try_to_cancel()
820 hrtimer_cancel_wait_running(&timer->it.real.timer); in common_timer_wait_running()
825 * against the ksoftirqd thread in case that ksoftirqd gets preempted while
828 * See the comments in hrtimer_cancel_wait_running(). For PREEMPT_RT=n this
829 * just results in a cpu_relax().
835 * the task which runs the expiry in task work context.
840 const struct k_clock *kc = READ_ONCE(timer->kclock); in timer_wait_running()
841 timer_t timer_id = READ_ONCE(timer->it_id); in timer_wait_running()
848 * kc->timer_wait_running() might drop RCU lock. So @timer in timer_wait_running()
851 if (!WARN_ON_ONCE(!kc->timer_wait_running)) in timer_wait_running()
852 kc->timer_wait_running(timer); in timer_wait_running()
864 const struct k_clock *kc = timr->kclock; in common_timer_set()
872 timr->it_interval = 0; in common_timer_set()
875 * active and spinning on timr->it_lock. in common_timer_set()
877 if (kc->timer_try_to_cancel(timr) < 0) in common_timer_set()
880 timr->it_active = 0; in common_timer_set()
881 timr->it_requeue_pending = (timr->it_requeue_pending + 2) & in common_timer_set()
883 timr->it_overrun_last = 0; in common_timer_set()
886 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec) in common_timer_set()
889 timr->it_interval = timespec64_to_ktime(new_setting->it_interval); in common_timer_set()
890 expires = timespec64_to_ktime(new_setting->it_value); in common_timer_set()
892 expires = timens_ktime_to_host(timr->it_clock, expires); in common_timer_set()
893 sigev_none = timr->it_sigev_notify == SIGEV_NONE; in common_timer_set()
895 kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none); in common_timer_set()
896 timr->it_active = !sigev_none; in common_timer_set()
909 if (!timespec64_valid(&new_spec64->it_interval) || in do_timer_settime()
910 !timespec64_valid(&new_spec64->it_value)) in do_timer_settime()
911 return -EINVAL; in do_timer_settime()
919 return -EINVAL; in do_timer_settime()
921 kc = timr->kclock; in do_timer_settime()
922 if (WARN_ON_ONCE(!kc || !kc->timer_set)) in do_timer_settime()
923 error = -EINVAL; in do_timer_settime()
925 error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64); in do_timer_settime()
948 return -EINVAL; in SYSCALL_DEFINE4()
951 return -EFAULT; in SYSCALL_DEFINE4()
957 error = -EFAULT; in SYSCALL_DEFINE4()
972 return -EINVAL; in SYSCALL_DEFINE4()
974 return -EFAULT; in SYSCALL_DEFINE4()
979 error = -EFAULT; in SYSCALL_DEFINE4()
987 const struct k_clock *kc = timer->kclock; in common_timer_del()
989 timer->it_interval = 0; in common_timer_del()
990 if (kc->timer_try_to_cancel(timer) < 0) in common_timer_del()
992 timer->it_active = 0; in common_timer_del()
998 const struct k_clock *kc = timer->kclock; in timer_delete_hook()
1000 if (WARN_ON_ONCE(!kc || !kc->timer_del)) in timer_delete_hook()
1001 return -EINVAL; in timer_delete_hook()
1002 return kc->timer_del(timer); in timer_delete_hook()
1015 return -EINVAL; in SYSCALL_DEFINE1()
1023 spin_lock(¤t->sighand->siglock); in SYSCALL_DEFINE1()
1024 list_del(&timer->list); in SYSCALL_DEFINE1()
1025 spin_unlock(¤t->sighand->siglock); in SYSCALL_DEFINE1()
1030 WRITE_ONCE(timer->it_signal, NULL); in SYSCALL_DEFINE1()
1048 spin_lock_irqsave(&timer->it_lock, flags); in itimer_delete()
1053 * it still might be armed and queued in the underlying timer in itimer_delete()
1067 * So no other task can access and delete that timer. in itimer_delete()
1074 list_del(&timer->list); in itimer_delete()
1082 WRITE_ONCE(timer->it_signal, NULL); in itimer_delete()
1084 spin_unlock_irqrestore(&timer->it_lock, flags); in itimer_delete()
1090 * At that point no other task can access the timers of the dying
1098 if (list_empty(&tsk->signal->posix_timers)) in exit_itimers()
1102 spin_lock_irq(&tsk->sighand->siglock); in exit_itimers()
1103 list_replace_init(&tsk->signal->posix_timers, &timers); in exit_itimers()
1104 spin_unlock_irq(&tsk->sighand->siglock); in exit_itimers()
1119 if (!kc || !kc->clock_set) in SYSCALL_DEFINE2()
1120 return -EINVAL; in SYSCALL_DEFINE2()
1123 return -EFAULT; in SYSCALL_DEFINE2()
1129 return kc->clock_set(which_clock, &new_tp); in SYSCALL_DEFINE2()
1140 return -EINVAL; in SYSCALL_DEFINE2()
1142 error = kc->clock_get_timespec(which_clock, &kernel_tp); in SYSCALL_DEFINE2()
1145 error = -EFAULT; in SYSCALL_DEFINE2()
1155 return -EINVAL; in do_clock_adjtime()
1156 if (!kc->clock_adj) in do_clock_adjtime()
1157 return -EOPNOTSUPP; in do_clock_adjtime()
1159 return kc->clock_adj(which_clock, ktx); in do_clock_adjtime()
1169 return -EFAULT; in SYSCALL_DEFINE2()
1174 return -EFAULT; in SYSCALL_DEFINE2()
1180 * sys_clock_getres - Get the resolution of a clock
1187 * clock. Clock resolutions are implementation-defined and cannot be set by
1189 * specified clock shall be stored in the location pointed to by res. If
1199 * The kernel therefore deviates from the POSIX spec in various aspects:
1210 * the resolution returned is nanoseconds per tick, which represents
1221 * resolution of the other clocks. During suspend the actual
1227 * returned is always nanoseconds per tick.
1232 * per tick.
1239 * The kernel does not truncate the time which is handed in to
1247 * -EINVAL @which_clock is not a valid clock ID
1248 * -EFAULT Copying the resolution to @tp faulted
1249 * -ENODEV Dynamic POSIX clock is not backed by a device
1250 * -EOPNOTSUPP Dynamic POSIX clock does not support getres()
1260 return -EINVAL; in SYSCALL_DEFINE2()
1262 error = kc->clock_getres(which_clock, &rtn_tp); in SYSCALL_DEFINE2()
1265 error = -EFAULT; in SYSCALL_DEFINE2()
1278 if (!kc || !kc->clock_set) in SYSCALL_DEFINE2()
1279 return -EINVAL; in SYSCALL_DEFINE2()
1282 return -EFAULT; in SYSCALL_DEFINE2()
1284 return kc->clock_set(which_clock, &ts); in SYSCALL_DEFINE2()
1295 return -EINVAL; in SYSCALL_DEFINE2()
1297 err = kc->clock_get_timespec(which_clock, &ts); in SYSCALL_DEFINE2()
1300 err = -EFAULT; in SYSCALL_DEFINE2()
1318 return -EFAULT; in SYSCALL_DEFINE2()
1331 return -EINVAL; in SYSCALL_DEFINE2()
1333 err = kc->clock_getres(which_clock, &ts); in SYSCALL_DEFINE2()
1335 return -EFAULT; in SYSCALL_DEFINE2()
1358 * Absolute nanosleeps for these clocks are time-namespace adjusted.
1381 return -EINVAL; in SYSCALL_DEFINE4()
1382 if (!kc->nsleep) in SYSCALL_DEFINE4()
1383 return -EOPNOTSUPP; in SYSCALL_DEFINE4()
1386 return -EFAULT; in SYSCALL_DEFINE4()
1389 return -EINVAL; in SYSCALL_DEFINE4()
1392 current->restart_block.fn = do_no_restart_syscall; in SYSCALL_DEFINE4()
1393 current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE; in SYSCALL_DEFINE4()
1394 current->restart_block.nanosleep.rmtp = rmtp; in SYSCALL_DEFINE4()
1396 return kc->nsleep(which_clock, flags, &t); in SYSCALL_DEFINE4()
1409 return -EINVAL; in SYSCALL_DEFINE4()
1410 if (!kc->nsleep) in SYSCALL_DEFINE4()
1411 return -EOPNOTSUPP; in SYSCALL_DEFINE4()
1414 return -EFAULT; in SYSCALL_DEFINE4()
1417 return -EINVAL; in SYSCALL_DEFINE4()
1420 current->restart_block.fn = do_no_restart_syscall; in SYSCALL_DEFINE4()
1421 current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE; in SYSCALL_DEFINE4()
1422 current->restart_block.nanosleep.compat_rmtp = rmtp; in SYSCALL_DEFINE4()
1424 return kc->nsleep(which_clock, flags, &t); in SYSCALL_DEFINE4()