xref: /openbmc/linux/kernel/time/posix-timers.c (revision 20e2fc42)
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(&current->sighand->siglock);
535 	new_timer->it_signal = current->signal;
536 	list_add(&new_timer->list, &current->signal->posix_timers);
537 	spin_unlock_irq(&current->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(&current->sighand->siglock);
1000 	list_del(&timer->list);
1001 	spin_unlock(&current->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