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.
20 #include <linux/posix-clock.h>
21 #include <linux/posix-timers.h>
31 #include "posix-timers.h"
37  * constructed from current::signal and the timer ID and the timer is
38  * matched against current::signal and the timer ID when walking the hash
58 static const struct k_clock *clockid_to_kclock(const clockid_t id);
73 	__cond_lock(&__timr->it_lock, __timr = __lock_timer(tid));	\
80 		spin_unlock_irq(&timr->it_lock);  in unlock_timer()
84 	scoped_cond_guard(lock_timer, return -EINVAL, _id)
88 DEFINE_CLASS(lock_timer, struct k_itimer *, unlock_timer(_T), __lock_timer(id), timer_t id);
96 static struct k_itimer *posix_timer_by_id(timer_t id)  in posix_timer_by_id()  argument
98 	struct signal_struct *sig = current->signal;  in posix_timer_by_id()
99 	struct timer_hash_bucket *bucket = hash_bucket(sig, id);  in posix_timer_by_id()
102 	hlist_for_each_entry_rcu(timer, &bucket->head, t_hash) {  in posix_timer_by_id()
103 		/* timer->it_signal can be set concurrently */  in posix_timer_by_id()
104 		if ((READ_ONCE(timer->it_signal) == sig) && (timer->it_id == id))  in posix_timer_by_id()
112 	unsigned long val = (unsigned long)timer->it_signal;  in posix_sig_owner()
122 			       timer_t id)  in posix_timer_hashed()  argument
124 	struct hlist_head *head = &bucket->head;  in posix_timer_hashed()
127 	hlist_for_each_entry_rcu(timer, head, t_hash, lockdep_is_held(&bucket->lock)) {  in posix_timer_hashed()
128 		if ((posix_sig_owner(timer) == sig) && (timer->it_id == id))  in posix_timer_hashed()
134 static bool posix_timer_add_at(struct k_itimer *timer, struct signal_struct *sig, unsigned int id)  in posix_timer_add_at()  argument
136 	struct timer_hash_bucket *bucket = hash_bucket(sig, id);  in posix_timer_add_at()
138 	scoped_guard (spinlock, &bucket->lock) {  in posix_timer_add_at()
141 		 * another thread ending up with the same ID, which is  in posix_timer_add_at()
144 		if (!posix_timer_hashed(bucket, sig, id)) {  in posix_timer_add_at()
146 			 * Set the timer ID and the signal pointer to make  in posix_timer_add_at()
147 			 * it identifiable in the hash table. The signal  in posix_timer_add_at()
155 			timer->it_id = (timer_t)id;  in posix_timer_add_at()
156 			timer->it_signal = (struct signal_struct *)((unsigned long)sig | 1UL);  in posix_timer_add_at()
157 			hlist_add_head_rcu(&timer->t_hash, &bucket->head);  in posix_timer_add_at()
166 	struct signal_struct *sig = current->signal;  in posix_timer_add()
170 			return -EBUSY;  in posix_timer_add()
173 		 * Move the ID counter past the requested ID, so that after  in posix_timer_add()
175 		 * exact allocated region. That avoids ID collisions on the  in posix_timer_add()
178 		atomic_set(&sig->next_posix_timer_id, req_id + 1);  in posix_timer_add()
183 		/* Get the next timer ID and clamp it to positive space */  in posix_timer_add()
184 		unsigned int id = atomic_fetch_inc(&sig->next_posix_timer_id) & INT_MAX;  in posix_timer_add()  local
186 		if (posix_timer_add_at(timer, sig, id))  in posix_timer_add()
187 			return id;  in posix_timer_add()
190 	/* POSIX return code when no timer ID could be allocated */  in posix_timer_add()
191 	return -EAGAIN;  in posix_timer_add()
281 	tp->tv_sec = 0;  in posix_get_hrtimer_res()
282 	tp->tv_nsec = hrtimer_resolution;  in posix_get_hrtimer_res()
300 	if (timr->it_overrun_last > (s64)INT_MAX)  in timer_overrun_to_int()
303 	return (int)timr->it_overrun_last;  in timer_overrun_to_int()
308 	struct hrtimer *timer = &timr->it.real.timer;  in common_hrtimer_rearm()
310 	timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(),  in common_hrtimer_rearm()
311 					    timr->it_interval);  in common_hrtimer_rearm()
317 	guard(spinlock)(&timr->it_lock);  in __posixtimer_deliver_signal()
321 	 * since the signal was queued. In either case, don't rearm and  in __posixtimer_deliver_signal()
322 	 * drop the signal.  in __posixtimer_deliver_signal()
324 	if (timr->it_signal_seq != timr->it_sigqueue_seq || WARN_ON_ONCE(!posixtimer_valid(timr)))  in __posixtimer_deliver_signal()
327 	if (!timr->it_interval || WARN_ON_ONCE(timr->it_status != POSIX_TIMER_REQUEUE_PENDING))  in __posixtimer_deliver_signal()
330 	timr->kclock->timer_rearm(timr);  in __posixtimer_deliver_signal()
331 	timr->it_status = POSIX_TIMER_ARMED;  in __posixtimer_deliver_signal()
332 	timr->it_overrun_last = timr->it_overrun;  in __posixtimer_deliver_signal()
333 	timr->it_overrun = -1LL;  in __posixtimer_deliver_signal()
334 	++timr->it_signal_seq;  in __posixtimer_deliver_signal()
335 	info->si_overrun = timer_overrun_to_int(timr);  in __posixtimer_deliver_signal()
340  * This function is called from the signal delivery code. It decides
341  * whether the signal should be dropped and rearms interval timers.  The
354 	spin_unlock(&current->sighand->siglock);  in posixtimer_deliver_signal()
358 	/* Drop the reference which was acquired when the signal was queued */  in posixtimer_deliver_signal()
361 	spin_lock(&current->sighand->siglock);  in posixtimer_deliver_signal()
367 	lockdep_assert_held(&timr->it_lock);  in posix_timer_queue_signal()
372 	timr->it_status = timr->it_interval ? POSIX_TIMER_REQUEUE_PENDING : POSIX_TIMER_DISARMED;  in posix_timer_queue_signal()
387 	guard(spinlock_irqsave)(&timr->it_lock);  in posix_timer_fn()
396 		current->signal->timer_create_restore_ids = 0;  in posixtimer_create_prctl()
399 		current->signal->timer_create_restore_ids = 1;  in posixtimer_create_prctl()
402 		return current->signal->timer_create_restore_ids;  in posixtimer_create_prctl()
404 	return -EINVAL;  in posixtimer_create_prctl()
412 	switch (event->sigev_notify) {  in good_sigevent()
414 		pid = find_vpid(event->sigev_notify_thread_id);  in good_sigevent()
421 		if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX)  in good_sigevent()
442 	if (unlikely(!posixtimer_init_sigqueue(&tmr->sigq))) {  in alloc_posix_timer()
446 	rcuref_init(&tmr->rcuref, 1);  in alloc_posix_timer()
452 	put_pid(tmr->it_pid);  in posixtimer_free_timer()
453 	if (tmr->sigq.ucounts)  in posixtimer_free_timer()
454 		dec_rlimit_put_ucounts(tmr->sigq.ucounts, UCOUNT_RLIMIT_SIGPENDING);  in posixtimer_free_timer()
460 	struct timer_hash_bucket *bucket = hash_bucket(posix_sig_owner(tmr), tmr->it_id);  in posix_timer_unhash_and_free()
462 	scoped_guard (spinlock, &bucket->lock)  in posix_timer_unhash_and_free()
463 		hlist_del_rcu(&tmr->t_hash);  in posix_timer_unhash_and_free()
469 	hrtimer_setup(&new_timer->it.real.timer, posix_timer_fn, new_timer->it_clock, 0);  in common_timer_create()
483 		return -EINVAL;  in do_timer_create()
484 	if (!kc->timer_create)  in do_timer_create()
485 		return -EOPNOTSUPP;  in do_timer_create()
489 		return -EAGAIN;  in do_timer_create()
491 	spin_lock_init(&new_timer->it_lock);  in do_timer_create()
493 	/* Special case for CRIU to restore timers with a given timer ID. */  in do_timer_create()
494 	if (unlikely(current->signal->timer_create_restore_ids)) {  in do_timer_create()
496 			return -EFAULT;  in do_timer_create()
499 			return -EINVAL;  in do_timer_create()
504 	 * after insertion, but has a unique ID allocated.  in do_timer_create()
512 	new_timer->it_clock = which_clock;  in do_timer_create()
513 	new_timer->kclock = kc;  in do_timer_create()
514 	new_timer->it_overrun = -1LL;  in do_timer_create()
518 			new_timer->it_pid = get_pid(good_sigevent(event));  in do_timer_create()
519 		if (!new_timer->it_pid) {  in do_timer_create()
520 			error = -EINVAL;  in do_timer_create()
523 		new_timer->it_sigev_notify     = event->sigev_notify;  in do_timer_create()
524 		new_timer->sigq.info.si_signo = event->sigev_signo;  in do_timer_create()
525 		new_timer->sigq.info.si_value = event->sigev_value;  in do_timer_create()
527 		new_timer->it_sigev_notify     = SIGEV_SIGNAL;  in do_timer_create()
528 		new_timer->sigq.info.si_signo = SIGALRM;  in do_timer_create()
529 		new_timer->sigq.info.si_value.sival_int = new_timer->it_id;  in do_timer_create()
530 		new_timer->it_pid = get_pid(task_tgid(current));  in do_timer_create()
533 	if (new_timer->it_sigev_notify & SIGEV_THREAD_ID)  in do_timer_create()
534 		new_timer->it_pid_type = PIDTYPE_PID;  in do_timer_create()
536 		new_timer->it_pid_type = PIDTYPE_TGID;  in do_timer_create()
538 	new_timer->sigq.info.si_tid = new_timer->it_id;  in do_timer_create()
539 	new_timer->sigq.info.si_code = SI_TIMER;  in do_timer_create()
542 		error = -EFAULT;  in do_timer_create()
546 	 * After succesful copy out, the timer ID is visible to user space  in do_timer_create()
547 	 * now but not yet valid because new_timer::signal low order bit is 1.  in do_timer_create()
552 	error = kc->timer_create(new_timer);  in do_timer_create()
560 	 * sighand::siglock is required to protect signal::posix_timers.  in do_timer_create()
562 	scoped_guard (spinlock_irq, &new_timer->it_lock) {  in do_timer_create()
563 		guard(spinlock)(&current->sighand->siglock);  in do_timer_create()
565 		 * new_timer::it_signal contains the signal pointer with  in do_timer_create()
567 		 * Store the unmodified signal pointer to make it valid.  in do_timer_create()
569 		WRITE_ONCE(new_timer->it_signal, current->signal);  in do_timer_create()
570 		hlist_add_head_rcu(&new_timer->list, &current->signal->posix_timers);  in do_timer_create()
590 			return -EFAULT;  in SYSCALL_DEFINE3()
605 			return -EFAULT;  in COMPAT_SYSCALL_DEFINE3()
637 	 * queued. In that case the signal delivery or flush will put the  in __lock_timer()
654 		spin_lock_irq(&timr->it_lock);  in __lock_timer()
659 		if (timr->it_signal == current->signal)  in __lock_timer()
661 		spin_unlock_irq(&timr->it_lock);  in __lock_timer()
668 	struct hrtimer *timer = &timr->it.real.timer;  in common_hrtimer_remaining()
675 	struct hrtimer *timer = &timr->it.real.timer;  in common_hrtimer_forward()
677 	return hrtimer_forward(timer, now, timr->it_interval);  in common_hrtimer_forward()
694 	const struct k_clock *kc = timr->kclock;  in common_timer_get()
698 	sig_none = timr->it_sigev_notify == SIGEV_NONE;  in common_timer_get()
699 	iv = timr->it_interval;  in common_timer_get()
703 		cur_setting->it_interval = ktime_to_timespec64(iv);  in common_timer_get()
704 	} else if (timr->it_status == POSIX_TIMER_DISARMED) {  in common_timer_get()
707 		 * timr->it_status is always DISARMED. The check below  in common_timer_get()
717 	now = kc->clock_get_ktime(timr->it_clock);  in common_timer_get()
724 	if (iv && timr->it_status != POSIX_TIMER_ARMED)  in common_timer_get()
725 		timr->it_overrun += kc->timer_forward(timr, now);  in common_timer_get()
727 	remaining = kc->timer_remaining(timr, now);  in common_timer_get()
740 		 * expired! Timers which have a real signal delivery mode  in common_timer_get()
742 		 * signal has not yet been delivered.  in common_timer_get()
745 			cur_setting->it_value.tv_nsec = 1;  in common_timer_get()
747 		cur_setting->it_value = ktime_to_timespec64(remaining);  in common_timer_get()
755 		scoped_timer->kclock->timer_get(scoped_timer, setting);  in do_timer_gettime()
768 			ret = -EFAULT;  in SYSCALL_DEFINE2()
783 			ret = -EFAULT;  in SYSCALL_DEFINE2()
791  * sys_timer_getoverrun - Get the number of overruns of a POSIX.1b interval timer
792  * @timer_id:	The timer ID which identifies the timer
796  * signal and the actual signal delivery. On signal delivery the "overrun
799  * As this is relative to the last queued signal the returned overrun count
800  * is meaningless outside of the signal delivery path and even there it
805  *	-EINVAL		@timer_id is invalid
806  *	1..INT_MAX	The number of overruns related to the last delivered signal
817 	struct hrtimer *timer = &timr->it.real.timer;  in common_hrtimer_arm()
824 	 * hood. See hrtimer_setup(). Update timr->kclock, so the generic  in common_hrtimer_arm()
825 	 * functions which use timr->kclock->clock_get_*() work.  in common_hrtimer_arm()
830 	if (timr->it_clock == CLOCK_REALTIME)  in common_hrtimer_arm()
831 		timr->kclock = absolute ? &clock_realtime : &clock_monotonic;  in common_hrtimer_arm()
833 	hrtimer_setup(&timr->it.real.timer, posix_timer_fn, timr->it_clock, mode);  in common_hrtimer_arm()
836 		expires = ktime_add_safe(expires, timer->base->get_time());  in common_hrtimer_arm()
845 	return hrtimer_try_to_cancel(&timr->it.real.timer);  in common_hrtimer_try_to_cancel()
850 	hrtimer_cancel_wait_running(&timer->it.real.timer);  in common_timer_wait_running()
870 	 * kc->timer_wait_running() might drop RCU lock. So @timer  in timer_wait_running()
873 	timer->kclock->timer_wait_running(timer);  in timer_wait_running()
877  * Set up the new interval and reset the signal delivery data
881 	if (new_setting->it_value.tv_sec || new_setting->it_value.tv_nsec)  in posix_timer_set_common()
882 		timer->it_interval = timespec64_to_ktime(new_setting->it_interval);  in posix_timer_set_common()
884 		timer->it_interval = 0;  in posix_timer_set_common()
887 	timer->it_overrun_last = 0;  in posix_timer_set_common()
888 	timer->it_overrun = -1LL;  in posix_timer_set_common()
896 	const struct k_clock *kc = timr->kclock;  in common_timer_set()
905 	 * active and spinning on timr->it_lock.  in common_timer_set()
907 	if (kc->timer_try_to_cancel(timr) < 0)  in common_timer_set()
910 	timr->it_status = POSIX_TIMER_DISARMED;  in common_timer_set()
914 	if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)  in common_timer_set()
917 	expires = timespec64_to_ktime(new_setting->it_value);  in common_timer_set()
919 		expires = timens_ktime_to_host(timr->it_clock, expires);  in common_timer_set()
920 	sigev_none = timr->it_sigev_notify == SIGEV_NONE;  in common_timer_set()
922 	kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);  in common_timer_set()
924 		timr->it_status = POSIX_TIMER_ARMED;  in common_timer_set()
931 	if (!timespec64_valid(&new_spec64->it_interval) ||  in do_timer_settime()
932 	    !timespec64_valid(&new_spec64->it_value))  in do_timer_settime()
933 		return -EINVAL;  in do_timer_settime()
945 				old_spec64->it_interval = ktime_to_timespec64(timr->it_interval);  in do_timer_settime()
947 			/* Prevent signal delivery and rearming. */  in do_timer_settime()
948 			timr->it_signal_seq++;  in do_timer_settime()
950 			int ret = timr->kclock->timer_set(timr, tmr_flags, new_spec64, old_spec64);  in do_timer_settime()
971 		return -EINVAL;  in SYSCALL_DEFINE4()
974 		return -EFAULT;  in SYSCALL_DEFINE4()
980 			error = -EFAULT;  in SYSCALL_DEFINE4()
995 		return -EINVAL;  in SYSCALL_DEFINE4()
997 		return -EFAULT;  in SYSCALL_DEFINE4()
1002 			error = -EFAULT;  in SYSCALL_DEFINE4()
1010 	const struct k_clock *kc = timer->kclock;  in common_timer_del()
1012 	if (kc->timer_try_to_cancel(timer) < 0)  in common_timer_del()
1014 	timer->it_status = POSIX_TIMER_DISARMED;  in common_timer_del()
1024 	if (!hlist_unhashed(&tmr->ignored_list)) {  in posix_timer_cleanup_ignored()
1025 		hlist_del_init(&tmr->ignored_list);  in posix_timer_cleanup_ignored()
1037 	 * signal code observes the invalidated timer::it_signal in  in posix_timer_delete()
1038 	 * do_sigaction(), which prevents it from moving a pending signal  in posix_timer_delete()
1041 	 * The invalidation also prevents signal queueing, signal delivery  in posix_timer_delete()
1042 	 * and therefore rearming from the signal delivery path.  in posix_timer_delete()
1046 	 * bit 0 set, which invalidates it. That also prevents the timer ID  in posix_timer_delete()
1049 	timer->it_signal_seq++;  in posix_timer_delete()
1051 	scoped_guard (spinlock, &current->sighand->siglock) {  in posix_timer_delete()
1052 		unsigned long sig = (unsigned long)timer->it_signal | 1UL;  in posix_timer_delete()
1054 		WRITE_ONCE(timer->it_signal, (struct signal_struct *)sig);  in posix_timer_delete()
1055 		hlist_del_rcu(&timer->list);  in posix_timer_delete()
1059 	while (timer->kclock->timer_del(timer) == TIMER_RETRY) {  in posix_timer_delete()
1061 		spin_unlock_irq(&timer->it_lock);  in posix_timer_delete()
1063 		spin_lock_irq(&timer->it_lock);  in posix_timer_delete()
1076 	/* Remove it from the hash, which frees up the timer ID */  in SYSCALL_DEFINE1()
1093 	tsk->signal->timer_create_restore_ids = 0;  in exit_itimers()
1095 	if (hlist_empty(&tsk->signal->posix_timers))  in exit_itimers()
1099 	scoped_guard (spinlock_irq, &tsk->sighand->siglock)  in exit_itimers()
1100 		hlist_move_list(&tsk->signal->posix_timers, &timers);  in exit_itimers()
1102 	/* The timers are not longer accessible via tsk::signal */  in exit_itimers()
1104 		scoped_guard (spinlock_irq, &timer->it_lock)  in exit_itimers()
1114 	if (!WARN_ON_ONCE(!hlist_empty(&tsk->signal->ignored_posix_timers)))  in exit_itimers()
1117 	hlist_move_list(&tsk->signal->ignored_posix_timers, &timers);  in exit_itimers()
1130 	if (!kc || !kc->clock_set)  in SYSCALL_DEFINE2()
1131 		return -EINVAL;  in SYSCALL_DEFINE2()
1134 		return -EFAULT;  in SYSCALL_DEFINE2()
1140 	return kc->clock_set(which_clock, &new_tp);  in SYSCALL_DEFINE2()
1151 		return -EINVAL;  in SYSCALL_DEFINE2()
1153 	error = kc->clock_get_timespec(which_clock, &kernel_tp);  in SYSCALL_DEFINE2()
1156 		error = -EFAULT;  in SYSCALL_DEFINE2()
1166 		return -EINVAL;  in do_clock_adjtime()
1167 	if (!kc->clock_adj)  in do_clock_adjtime()
1168 		return -EOPNOTSUPP;  in do_clock_adjtime()
1170 	return kc->clock_adj(which_clock, ktx);  in do_clock_adjtime()
1180 		return -EFAULT;  in SYSCALL_DEFINE2()
1185 		return -EFAULT;  in SYSCALL_DEFINE2()
1191  * sys_clock_getres - Get the resolution of a clock
1198  * clock. Clock resolutions are implementation-defined and cannot be set by
1258  *	-EINVAL		@which_clock is not a valid clock ID
1259  *	-EFAULT		Copying the resolution to @tp faulted
1260  *	-ENODEV		Dynamic POSIX clock is not backed by a device
1261  *	-EOPNOTSUPP	Dynamic POSIX clock does not support getres()
1271 		return -EINVAL;  in SYSCALL_DEFINE2()
1273 	error = kc->clock_getres(which_clock, &rtn_tp);  in SYSCALL_DEFINE2()
1276 		error = -EFAULT;  in SYSCALL_DEFINE2()
1289 	if (!kc || !kc->clock_set)  in SYSCALL_DEFINE2()
1290 		return -EINVAL;  in SYSCALL_DEFINE2()
1293 		return -EFAULT;  in SYSCALL_DEFINE2()
1295 	return kc->clock_set(which_clock, &ts);  in SYSCALL_DEFINE2()
1306 		return -EINVAL;  in SYSCALL_DEFINE2()
1308 	err = kc->clock_get_timespec(which_clock, &ts);  in SYSCALL_DEFINE2()
1311 		err = -EFAULT;  in SYSCALL_DEFINE2()
1329 		return -EFAULT;  in SYSCALL_DEFINE2()
1342 		return -EINVAL;  in SYSCALL_DEFINE2()
1344 	err = kc->clock_getres(which_clock, &ts);  in SYSCALL_DEFINE2()
1346 		return -EFAULT;  in SYSCALL_DEFINE2()
1369  * Absolute nanosleeps for these clocks are time-namespace adjusted.
1392 		return -EINVAL;  in SYSCALL_DEFINE4()
1393 	if (!kc->nsleep)  in SYSCALL_DEFINE4()
1394 		return -EOPNOTSUPP;  in SYSCALL_DEFINE4()
1397 		return -EFAULT;  in SYSCALL_DEFINE4()
1400 		return -EINVAL;  in SYSCALL_DEFINE4()
1403 	current->restart_block.fn = do_no_restart_syscall;  in SYSCALL_DEFINE4()
1404 	current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;  in SYSCALL_DEFINE4()
1405 	current->restart_block.nanosleep.rmtp = rmtp;  in SYSCALL_DEFINE4()
1407 	return kc->nsleep(which_clock, flags, &t);  in SYSCALL_DEFINE4()
1420 		return -EINVAL;  in SYSCALL_DEFINE4()
1421 	if (!kc->nsleep)  in SYSCALL_DEFINE4()
1422 		return -EOPNOTSUPP;  in SYSCALL_DEFINE4()
1425 		return -EFAULT;  in SYSCALL_DEFINE4()
1428 		return -EINVAL;  in SYSCALL_DEFINE4()
1431 	current->restart_block.fn = do_no_restart_syscall;  in SYSCALL_DEFINE4()
1432 	current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;  in SYSCALL_DEFINE4()
1433 	current->restart_block.nanosleep.compat_rmtp = rmtp;  in SYSCALL_DEFINE4()
1435 	return kc->nsleep(which_clock, flags, &t);  in SYSCALL_DEFINE4()
1539 static const struct k_clock *clockid_to_kclock(const clockid_t id)  in clockid_to_kclock()  argument
1541 	clockid_t idx = id;  in clockid_to_kclock()
1543 	if (id < 0) {  in clockid_to_kclock()
1544 		return (id & CLOCKFD_MASK) == CLOCKFD ?  in clockid_to_kclock()
1548 	if (id >= ARRAY_SIZE(posix_clocks))  in clockid_to_kclock()
1567 	timer_hashmask = size - 1;  in posixtimer_init()