Lines Matching +full:signal +full:- +full:id
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"
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
53 static const struct k_clock *clockid_to_kclock(const clockid_t id);
66 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \
77 timer_t id) in __posix_timers_find() argument
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()
89 static struct k_itimer *posix_timer_by_id(timer_t id) in posix_timer_by_id() argument
91 struct signal_struct *sig = current->signal; in posix_timer_by_id()
92 struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)]; in posix_timer_by_id()
94 return __posix_timers_find(head, sig, id); in posix_timer_by_id()
99 struct signal_struct *sig = current->signal; in posix_timer_add()
101 unsigned int cnt, id; in posix_timer_add() local
104 * FIXME: Replace this by a per signal struct xarray once there is in posix_timer_add()
109 id = sig->next_posix_timer_id; in posix_timer_add()
111 /* Write the next ID back. Clamp it to the positive space */ in posix_timer_add()
112 sig->next_posix_timer_id = (id + 1) & INT_MAX; in posix_timer_add()
114 head = &posix_timers_hashtable[hash(sig, id)]; in posix_timer_add()
115 if (!__posix_timers_find(head, sig, id)) { in posix_timer_add()
116 hlist_add_head_rcu(&timer->t_hash, head); in posix_timer_add()
118 return id; 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 if (timr->it_overrun_last > (s64)INT_MAX) in timer_overrun_to_int()
241 return (int)timr->it_overrun_last; in timer_overrun_to_int()
246 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_rearm()
248 timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(), in common_hrtimer_rearm()
249 timr->it_interval); in common_hrtimer_rearm()
255 guard(spinlock)(&timr->it_lock); in __posixtimer_deliver_signal()
259 * since the signal was queued. In either case, don't rearm and in __posixtimer_deliver_signal()
260 * drop the signal. in __posixtimer_deliver_signal()
262 if (timr->it_signal_seq != timr->it_sigqueue_seq || WARN_ON_ONCE(!timr->it_signal)) in __posixtimer_deliver_signal()
265 if (!timr->it_interval || WARN_ON_ONCE(timr->it_status != POSIX_TIMER_REQUEUE_PENDING)) in __posixtimer_deliver_signal()
268 timr->kclock->timer_rearm(timr); in __posixtimer_deliver_signal()
269 timr->it_status = POSIX_TIMER_ARMED; in __posixtimer_deliver_signal()
270 timr->it_overrun_last = timr->it_overrun; in __posixtimer_deliver_signal()
271 timr->it_overrun = -1LL; in __posixtimer_deliver_signal()
272 ++timr->it_signal_seq; in __posixtimer_deliver_signal()
273 info->si_overrun = timer_overrun_to_int(timr); in __posixtimer_deliver_signal()
278 * This function is called from the signal delivery code. It decides
279 * whether the signal should be dropped and rearms interval timers. The
292 spin_unlock(¤t->sighand->siglock); in posixtimer_deliver_signal()
296 /* Drop the reference which was acquired when the signal was queued */ in posixtimer_deliver_signal()
299 spin_lock(¤t->sighand->siglock); in posixtimer_deliver_signal()
305 lockdep_assert_held(&timr->it_lock); in posix_timer_queue_signal()
307 timr->it_status = timr->it_interval ? POSIX_TIMER_REQUEUE_PENDING : POSIX_TIMER_DISARMED; in posix_timer_queue_signal()
322 guard(spinlock_irqsave)(&timr->it_lock); in posix_timer_fn()
332 switch (event->sigev_notify) { in good_sigevent()
334 pid = find_vpid(event->sigev_notify_thread_id); in good_sigevent()
341 if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX) in good_sigevent()
358 if (unlikely(!posixtimer_init_sigqueue(&tmr->sigq))) { in alloc_posix_timer()
362 rcuref_init(&tmr->rcuref, 1); in alloc_posix_timer()
368 put_pid(tmr->it_pid); in posixtimer_free_timer()
369 if (tmr->sigq.ucounts) in posixtimer_free_timer()
370 dec_rlimit_put_ucounts(tmr->sigq.ucounts, UCOUNT_RLIMIT_SIGPENDING); in posixtimer_free_timer()
377 hlist_del_rcu(&tmr->t_hash); in posix_timer_unhash_and_free()
384 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0); in common_timer_create()
397 return -EINVAL; in do_timer_create()
398 if (!kc->timer_create) in do_timer_create()
399 return -EOPNOTSUPP; in do_timer_create()
403 return -EAGAIN; in do_timer_create()
405 spin_lock_init(&new_timer->it_lock); in do_timer_create()
409 * because new_timer::it_signal is still NULL. The timer id is also in do_timer_create()
418 new_timer->it_id = (timer_t) new_timer_id; in do_timer_create()
419 new_timer->it_clock = which_clock; in do_timer_create()
420 new_timer->kclock = kc; in do_timer_create()
421 new_timer->it_overrun = -1LL; in do_timer_create()
425 new_timer->it_pid = get_pid(good_sigevent(event)); in do_timer_create()
427 if (!new_timer->it_pid) { in do_timer_create()
428 error = -EINVAL; in do_timer_create()
431 new_timer->it_sigev_notify = event->sigev_notify; in do_timer_create()
432 new_timer->sigq.info.si_signo = event->sigev_signo; in do_timer_create()
433 new_timer->sigq.info.si_value = event->sigev_value; in do_timer_create()
435 new_timer->it_sigev_notify = SIGEV_SIGNAL; in do_timer_create()
436 new_timer->sigq.info.si_signo = SIGALRM; in do_timer_create()
437 memset(&new_timer->sigq.info.si_value, 0, sizeof(sigval_t)); in do_timer_create()
438 new_timer->sigq.info.si_value.sival_int = new_timer->it_id; in do_timer_create()
439 new_timer->it_pid = get_pid(task_tgid(current)); in do_timer_create()
442 if (new_timer->it_sigev_notify & SIGEV_THREAD_ID) in do_timer_create()
443 new_timer->it_pid_type = PIDTYPE_PID; in do_timer_create()
445 new_timer->it_pid_type = PIDTYPE_TGID; in do_timer_create()
447 new_timer->sigq.info.si_tid = new_timer->it_id; in do_timer_create()
448 new_timer->sigq.info.si_code = SI_TIMER; in do_timer_create()
451 error = -EFAULT; in do_timer_create()
455 * After succesful copy out, the timer ID is visible to user space in do_timer_create()
456 * now but not yet valid because new_timer::signal is still NULL. in do_timer_create()
461 error = kc->timer_create(new_timer); in do_timer_create()
465 spin_lock_irq(¤t->sighand->siglock); in do_timer_create()
467 WRITE_ONCE(new_timer->it_signal, current->signal); in do_timer_create()
468 hlist_add_head(&new_timer->list, ¤t->signal->posix_timers); in do_timer_create()
469 spin_unlock_irq(¤t->sighand->siglock); in do_timer_create()
488 return -EFAULT; in SYSCALL_DEFINE3()
503 return -EFAULT; in COMPAT_SYSCALL_DEFINE3()
535 * queued. In that case the signal delivery or flush will put the in __lock_timer()
552 spin_lock_irqsave(&timr->it_lock, *flags); in __lock_timer()
557 if (timr->it_signal == current->signal) { in __lock_timer()
561 spin_unlock_irqrestore(&timr->it_lock, *flags); in __lock_timer()
570 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_remaining()
577 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_forward()
579 return hrtimer_forward(timer, now, timr->it_interval); in common_hrtimer_forward()
596 const struct k_clock *kc = timr->kclock; in common_timer_get()
600 sig_none = timr->it_sigev_notify == SIGEV_NONE; in common_timer_get()
601 iv = timr->it_interval; in common_timer_get()
605 cur_setting->it_interval = ktime_to_timespec64(iv); in common_timer_get()
606 } else if (timr->it_status == POSIX_TIMER_DISARMED) { in common_timer_get()
609 * timr->it_status is always DISARMED. The check below in common_timer_get()
619 now = kc->clock_get_ktime(timr->it_clock); in common_timer_get()
626 if (iv && timr->it_status != POSIX_TIMER_ARMED) in common_timer_get()
627 timr->it_overrun += kc->timer_forward(timr, now); in common_timer_get()
629 remaining = kc->timer_remaining(timr, now); in common_timer_get()
642 * expired! Timers which have a real signal delivery mode in common_timer_get()
644 * signal has not yet been delivered. in common_timer_get()
647 cur_setting->it_value.tv_nsec = 1; in common_timer_get()
649 cur_setting->it_value = ktime_to_timespec64(remaining); in common_timer_get()
662 return -EINVAL; in do_timer_gettime()
665 kc = timr->kclock; in do_timer_gettime()
666 if (WARN_ON_ONCE(!kc || !kc->timer_get)) in do_timer_gettime()
667 ret = -EINVAL; in do_timer_gettime()
669 kc->timer_get(timr, setting); in do_timer_gettime()
684 ret = -EFAULT; in SYSCALL_DEFINE2()
699 ret = -EFAULT; in SYSCALL_DEFINE2()
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
712 * signal and the actual signal delivery. On signal delivery the "overrun
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
721 * -EINVAL @timer_id is invalid
722 * 1..INT_MAX The number of overruns related to the last delivered signal
732 return -EINVAL; in SYSCALL_DEFINE1()
743 struct hrtimer *timer = &timr->it.real.timer; in common_hrtimer_arm()
750 * hood. See hrtimer_init(). Update timr->kclock, so the generic in common_hrtimer_arm()
751 * functions which use timr->kclock->clock_get_*() work. in common_hrtimer_arm()
756 if (timr->it_clock == CLOCK_REALTIME) in common_hrtimer_arm()
757 timr->kclock = absolute ? &clock_realtime : &clock_monotonic; in common_hrtimer_arm()
759 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode); in common_hrtimer_arm()
760 timr->it.real.timer.function = posix_timer_fn; in common_hrtimer_arm()
763 expires = ktime_add_safe(expires, timer->base->get_time()); in common_hrtimer_arm()
772 return hrtimer_try_to_cancel(&timr->it.real.timer); in common_hrtimer_try_to_cancel()
777 hrtimer_cancel_wait_running(&timer->it.real.timer); in common_timer_wait_running()
797 const struct k_clock *kc = READ_ONCE(timer->kclock); in timer_wait_running()
798 timer_t timer_id = READ_ONCE(timer->it_id); in timer_wait_running()
805 * kc->timer_wait_running() might drop RCU lock. So @timer in timer_wait_running()
808 if (!WARN_ON_ONCE(!kc->timer_wait_running)) in timer_wait_running()
809 kc->timer_wait_running(timer); in timer_wait_running()
817 * Set up the new interval and reset the signal delivery data
821 if (new_setting->it_value.tv_sec || new_setting->it_value.tv_nsec) in posix_timer_set_common()
822 timer->it_interval = timespec64_to_ktime(new_setting->it_interval); in posix_timer_set_common()
824 timer->it_interval = 0; in posix_timer_set_common()
827 timer->it_overrun_last = 0; in posix_timer_set_common()
828 timer->it_overrun = -1LL; in posix_timer_set_common()
836 const struct k_clock *kc = timr->kclock; in common_timer_set()
845 * active and spinning on timr->it_lock. in common_timer_set()
847 if (kc->timer_try_to_cancel(timr) < 0) in common_timer_set()
850 timr->it_status = POSIX_TIMER_DISARMED; in common_timer_set()
854 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec) in common_timer_set()
857 expires = timespec64_to_ktime(new_setting->it_value); in common_timer_set()
859 expires = timens_ktime_to_host(timr->it_clock, expires); in common_timer_set()
860 sigev_none = timr->it_sigev_notify == SIGEV_NONE; in common_timer_set()
862 kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none); in common_timer_set()
864 timr->it_status = POSIX_TIMER_ARMED; in common_timer_set()
877 if (!timespec64_valid(&new_spec64->it_interval) || in do_timer_settime()
878 !timespec64_valid(&new_spec64->it_value)) in do_timer_settime()
879 return -EINVAL; in do_timer_settime()
887 return -EINVAL; in do_timer_settime()
890 old_spec64->it_interval = ktime_to_timespec64(timr->it_interval); in do_timer_settime()
892 /* Prevent signal delivery and rearming. */ in do_timer_settime()
893 timr->it_signal_seq++; in do_timer_settime()
895 kc = timr->kclock; in do_timer_settime()
896 if (WARN_ON_ONCE(!kc || !kc->timer_set)) in do_timer_settime()
897 error = -EINVAL; in do_timer_settime()
899 error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64); in do_timer_settime()
922 return -EINVAL; in SYSCALL_DEFINE4()
925 return -EFAULT; in SYSCALL_DEFINE4()
931 error = -EFAULT; in SYSCALL_DEFINE4()
946 return -EINVAL; in SYSCALL_DEFINE4()
948 return -EFAULT; in SYSCALL_DEFINE4()
953 error = -EFAULT; in SYSCALL_DEFINE4()
961 const struct k_clock *kc = timer->kclock; in common_timer_del()
963 if (kc->timer_try_to_cancel(timer) < 0) in common_timer_del()
965 timer->it_status = POSIX_TIMER_DISARMED; in common_timer_del()
975 if (!hlist_unhashed(&tmr->ignored_list)) { in posix_timer_cleanup_ignored()
976 hlist_del_init(&tmr->ignored_list); in posix_timer_cleanup_ignored()
983 const struct k_clock *kc = timer->kclock; in timer_delete_hook()
985 /* Prevent signal delivery and rearming. */ in timer_delete_hook()
986 timer->it_signal_seq++; in timer_delete_hook()
988 if (WARN_ON_ONCE(!kc || !kc->timer_del)) in timer_delete_hook()
989 return -EINVAL; in timer_delete_hook()
990 return kc->timer_del(timer); in timer_delete_hook()
1003 return -EINVAL; in SYSCALL_DEFINE1()
1011 spin_lock(¤t->sighand->siglock); in SYSCALL_DEFINE1()
1012 hlist_del(&timer->list); in SYSCALL_DEFINE1()
1018 * It must be written with siglock held so that the signal code in SYSCALL_DEFINE1()
1019 * observes timer->it_signal == NULL in do_sigaction(SIG_IGN), in SYSCALL_DEFINE1()
1020 * which prevents it from moving a pending signal of a deleted in SYSCALL_DEFINE1()
1023 WRITE_ONCE(timer->it_signal, NULL); in SYSCALL_DEFINE1()
1024 spin_unlock(¤t->sighand->siglock); in SYSCALL_DEFINE1()
1042 spin_lock_irqsave(&timer->it_lock, flags); in itimer_delete()
1068 hlist_del(&timer->list); in itimer_delete()
1078 WRITE_ONCE(timer->it_signal, NULL); in itimer_delete()
1080 spin_unlock_irqrestore(&timer->it_lock, flags); in itimer_delete()
1093 if (hlist_empty(&tsk->signal->posix_timers)) in exit_itimers()
1097 spin_lock_irq(&tsk->sighand->siglock); in exit_itimers()
1098 hlist_move_list(&tsk->signal->posix_timers, &timers); in exit_itimers()
1099 spin_unlock_irq(&tsk->sighand->siglock); in exit_itimers()
1101 /* The timers are not longer accessible via tsk::signal */ in exit_itimers()
1109 if (!WARN_ON_ONCE(!hlist_empty(&tsk->signal->ignored_posix_timers))) in exit_itimers()
1112 hlist_move_list(&tsk->signal->ignored_posix_timers, &timers); in exit_itimers()
1125 if (!kc || !kc->clock_set) in SYSCALL_DEFINE2()
1126 return -EINVAL; in SYSCALL_DEFINE2()
1129 return -EFAULT; in SYSCALL_DEFINE2()
1135 return kc->clock_set(which_clock, &new_tp); in SYSCALL_DEFINE2()
1146 return -EINVAL; in SYSCALL_DEFINE2()
1148 error = kc->clock_get_timespec(which_clock, &kernel_tp); in SYSCALL_DEFINE2()
1151 error = -EFAULT; in SYSCALL_DEFINE2()
1161 return -EINVAL; in do_clock_adjtime()
1162 if (!kc->clock_adj) in do_clock_adjtime()
1163 return -EOPNOTSUPP; in do_clock_adjtime()
1165 return kc->clock_adj(which_clock, ktx); in do_clock_adjtime()
1175 return -EFAULT; in SYSCALL_DEFINE2()
1180 return -EFAULT; in SYSCALL_DEFINE2()
1186 * sys_clock_getres - Get the resolution of a clock
1193 * clock. Clock resolutions are implementation-defined and cannot be set by
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()
1266 return -EINVAL; in SYSCALL_DEFINE2()
1268 error = kc->clock_getres(which_clock, &rtn_tp); in SYSCALL_DEFINE2()
1271 error = -EFAULT; in SYSCALL_DEFINE2()
1284 if (!kc || !kc->clock_set) in SYSCALL_DEFINE2()
1285 return -EINVAL; in SYSCALL_DEFINE2()
1288 return -EFAULT; in SYSCALL_DEFINE2()
1290 return kc->clock_set(which_clock, &ts); in SYSCALL_DEFINE2()
1301 return -EINVAL; in SYSCALL_DEFINE2()
1303 err = kc->clock_get_timespec(which_clock, &ts); in SYSCALL_DEFINE2()
1306 err = -EFAULT; in SYSCALL_DEFINE2()
1324 return -EFAULT; in SYSCALL_DEFINE2()
1337 return -EINVAL; in SYSCALL_DEFINE2()
1339 err = kc->clock_getres(which_clock, &ts); in SYSCALL_DEFINE2()
1341 return -EFAULT; in SYSCALL_DEFINE2()
1364 * Absolute nanosleeps for these clocks are time-namespace adjusted.
1387 return -EINVAL; in SYSCALL_DEFINE4()
1388 if (!kc->nsleep) in SYSCALL_DEFINE4()
1389 return -EOPNOTSUPP; in SYSCALL_DEFINE4()
1392 return -EFAULT; in SYSCALL_DEFINE4()
1395 return -EINVAL; in SYSCALL_DEFINE4()
1398 current->restart_block.fn = do_no_restart_syscall; in SYSCALL_DEFINE4()
1399 current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE; in SYSCALL_DEFINE4()
1400 current->restart_block.nanosleep.rmtp = rmtp; in SYSCALL_DEFINE4()
1402 return kc->nsleep(which_clock, flags, &t); in SYSCALL_DEFINE4()
1415 return -EINVAL; in SYSCALL_DEFINE4()
1416 if (!kc->nsleep) in SYSCALL_DEFINE4()
1417 return -EOPNOTSUPP; in SYSCALL_DEFINE4()
1420 return -EFAULT; in SYSCALL_DEFINE4()
1423 return -EINVAL; in SYSCALL_DEFINE4()
1426 current->restart_block.fn = do_no_restart_syscall; in SYSCALL_DEFINE4()
1427 current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE; in SYSCALL_DEFINE4()
1428 current->restart_block.nanosleep.compat_rmtp = rmtp; in SYSCALL_DEFINE4()
1430 return kc->nsleep(which_clock, flags, &t); in SYSCALL_DEFINE4()
1534 static const struct k_clock *clockid_to_kclock(const clockid_t id) in clockid_to_kclock() argument
1536 clockid_t idx = id; in clockid_to_kclock()
1538 if (id < 0) { in clockid_to_kclock()
1539 return (id & CLOCKFD_MASK) == CLOCKFD ? in clockid_to_kclock()
1543 if (id >= ARRAY_SIZE(posix_clocks)) in clockid_to_kclock()