1 // SPDX-License-Identifier: GPL-2.0
3 * Implement CPU time clocks for the POSIX clock interface.
6 #include <linux/sched/signal.h>
7 #include <linux/sched/cputime.h>
8 #include <linux/posix-timers.h>
9 #include <linux/errno.h>
10 #include <linux/math64.h>
11 #include <linux/uaccess.h>
12 #include <linux/kernel_stat.h>
13 #include <trace/events/timer.h>
14 #include <linux/tick.h>
15 #include <linux/workqueue.h>
16 #include <linux/compat.h>
17 #include <linux/sched/deadline.h>
18 #include <linux/task_work.h>
20 #include "posix-timers.h"
22 static void posix_cpu_timer_rearm(struct k_itimer
*timer
);
24 void posix_cputimers_group_init(struct posix_cputimers
*pct
, u64 cpu_limit
)
26 posix_cputimers_init(pct
);
27 if (cpu_limit
!= RLIM_INFINITY
) {
28 pct
->bases
[CPUCLOCK_PROF
].nextevt
= cpu_limit
* NSEC_PER_SEC
;
29 pct
->timers_active
= true;
34 * Called after updating RLIMIT_CPU to run cpu timer and update
35 * tsk->signal->posix_cputimers.bases[clock].nextevt expiration cache if
36 * necessary. Needs siglock protection since other code may update the
37 * expiration cache as well.
39 * Returns 0 on success, -ESRCH on failure. Can fail if the task is exiting and
40 * we cannot lock_task_sighand. Cannot fail if task is current.
42 int update_rlimit_cpu(struct task_struct
*task
, unsigned long rlim_new
)
44 u64 nsecs
= rlim_new
* NSEC_PER_SEC
;
47 if (!lock_task_sighand(task
, &irq_fl
))
49 set_process_cpu_timer(task
, CPUCLOCK_PROF
, &nsecs
, NULL
);
50 unlock_task_sighand(task
, &irq_fl
);
55 * Functions for validating access to tasks.
57 static struct pid
*pid_for_clock(const clockid_t clock
, bool gettime
)
59 const bool thread
= !!CPUCLOCK_PERTHREAD(clock
);
60 const pid_t upid
= CPUCLOCK_PID(clock
);
63 if (CPUCLOCK_WHICH(clock
) >= CPUCLOCK_MAX
)
67 * If the encoded PID is 0, then the timer is targeted at current
68 * or the process to which current belongs.
71 return thread
? task_pid(current
) : task_tgid(current
);
73 pid
= find_vpid(upid
);
78 struct task_struct
*tsk
= pid_task(pid
, PIDTYPE_PID
);
79 return (tsk
&& same_thread_group(tsk
, current
)) ? pid
: NULL
;
83 * For clock_gettime(PROCESS) allow finding the process by
84 * with the pid of the current task. The code needs the tgid
85 * of the process so that pid_task(pid, PIDTYPE_TGID) can be
86 * used to find the process.
88 if (gettime
&& (pid
== task_pid(current
)))
89 return task_tgid(current
);
92 * For processes require that pid identifies a process.
94 return pid_has_task(pid
, PIDTYPE_TGID
) ? pid
: NULL
;
97 static inline int validate_clock_permissions(const clockid_t clock
)
102 ret
= pid_for_clock(clock
, false) ? 0 : -EINVAL
;
108 static inline enum pid_type
clock_pid_type(const clockid_t clock
)
110 return CPUCLOCK_PERTHREAD(clock
) ? PIDTYPE_PID
: PIDTYPE_TGID
;
113 static inline struct task_struct
*cpu_timer_task_rcu(struct k_itimer
*timer
)
115 return pid_task(timer
->it
.cpu
.pid
, clock_pid_type(timer
->it_clock
));
119 * Update expiry time from increment, and increase overrun count,
120 * given the current clock sample.
122 static u64
bump_cpu_timer(struct k_itimer
*timer
, u64 now
)
124 u64 delta
, incr
, expires
= timer
->it
.cpu
.node
.expires
;
127 if (!timer
->it_interval
)
133 incr
= timer
->it_interval
;
134 delta
= now
+ incr
- expires
;
136 /* Don't use (incr*2 < delta), incr*2 might overflow. */
137 for (i
= 0; incr
< delta
- incr
; i
++)
140 for (; i
>= 0; incr
>>= 1, i
--) {
144 timer
->it
.cpu
.node
.expires
+= incr
;
145 timer
->it_overrun
+= 1LL << i
;
148 return timer
->it
.cpu
.node
.expires
;
151 /* Check whether all cache entries contain U64_MAX, i.e. eternal expiry time */
152 static inline bool expiry_cache_is_inactive(const struct posix_cputimers
*pct
)
154 return !(~pct
->bases
[CPUCLOCK_PROF
].nextevt
|
155 ~pct
->bases
[CPUCLOCK_VIRT
].nextevt
|
156 ~pct
->bases
[CPUCLOCK_SCHED
].nextevt
);
160 posix_cpu_clock_getres(const clockid_t which_clock
, struct timespec64
*tp
)
162 int error
= validate_clock_permissions(which_clock
);
166 tp
->tv_nsec
= ((NSEC_PER_SEC
+ HZ
- 1) / HZ
);
167 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
) {
169 * If sched_clock is using a cycle counter, we
170 * don't have any idea of its true resolution
171 * exported, but it is much more than 1s/HZ.
180 posix_cpu_clock_set(const clockid_t clock
, const struct timespec64
*tp
)
182 int error
= validate_clock_permissions(clock
);
185 * You can never reset a CPU clock, but we check for other errors
186 * in the call before failing with EPERM.
188 return error
? : -EPERM
;
192 * Sample a per-thread clock for the given task. clkid is validated.
194 static u64
cpu_clock_sample(const clockid_t clkid
, struct task_struct
*p
)
198 if (clkid
== CPUCLOCK_SCHED
)
199 return task_sched_runtime(p
);
201 task_cputime(p
, &utime
, &stime
);
205 return utime
+ stime
;
214 static inline void store_samples(u64
*samples
, u64 stime
, u64 utime
, u64 rtime
)
216 samples
[CPUCLOCK_PROF
] = stime
+ utime
;
217 samples
[CPUCLOCK_VIRT
] = utime
;
218 samples
[CPUCLOCK_SCHED
] = rtime
;
221 static void task_sample_cputime(struct task_struct
*p
, u64
*samples
)
225 task_cputime(p
, &utime
, &stime
);
226 store_samples(samples
, stime
, utime
, p
->se
.sum_exec_runtime
);
229 static void proc_sample_cputime_atomic(struct task_cputime_atomic
*at
,
232 u64 stime
, utime
, rtime
;
234 utime
= atomic64_read(&at
->utime
);
235 stime
= atomic64_read(&at
->stime
);
236 rtime
= atomic64_read(&at
->sum_exec_runtime
);
237 store_samples(samples
, stime
, utime
, rtime
);
241 * Set cputime to sum_cputime if sum_cputime > cputime. Use cmpxchg
242 * to avoid race conditions with concurrent updates to cputime.
244 static inline void __update_gt_cputime(atomic64_t
*cputime
, u64 sum_cputime
)
248 curr_cputime
= atomic64_read(cputime
);
249 if (sum_cputime
> curr_cputime
) {
250 if (atomic64_cmpxchg(cputime
, curr_cputime
, sum_cputime
) != curr_cputime
)
255 static void update_gt_cputime(struct task_cputime_atomic
*cputime_atomic
,
256 struct task_cputime
*sum
)
258 __update_gt_cputime(&cputime_atomic
->utime
, sum
->utime
);
259 __update_gt_cputime(&cputime_atomic
->stime
, sum
->stime
);
260 __update_gt_cputime(&cputime_atomic
->sum_exec_runtime
, sum
->sum_exec_runtime
);
264 * thread_group_sample_cputime - Sample cputime for a given task
265 * @tsk: Task for which cputime needs to be started
266 * @samples: Storage for time samples
268 * Called from sys_getitimer() to calculate the expiry time of an active
269 * timer. That means group cputime accounting is already active. Called
270 * with task sighand lock held.
272 * Updates @times with an uptodate sample of the thread group cputimes.
274 void thread_group_sample_cputime(struct task_struct
*tsk
, u64
*samples
)
276 struct thread_group_cputimer
*cputimer
= &tsk
->signal
->cputimer
;
277 struct posix_cputimers
*pct
= &tsk
->signal
->posix_cputimers
;
279 WARN_ON_ONCE(!pct
->timers_active
);
281 proc_sample_cputime_atomic(&cputimer
->cputime_atomic
, samples
);
285 * thread_group_start_cputime - Start cputime and return a sample
286 * @tsk: Task for which cputime needs to be started
287 * @samples: Storage for time samples
289 * The thread group cputime accounting is avoided when there are no posix
290 * CPU timers armed. Before starting a timer it's required to check whether
291 * the time accounting is active. If not, a full update of the atomic
292 * accounting store needs to be done and the accounting enabled.
294 * Updates @times with an uptodate sample of the thread group cputimes.
296 static void thread_group_start_cputime(struct task_struct
*tsk
, u64
*samples
)
298 struct thread_group_cputimer
*cputimer
= &tsk
->signal
->cputimer
;
299 struct posix_cputimers
*pct
= &tsk
->signal
->posix_cputimers
;
301 lockdep_assert_task_sighand_held(tsk
);
303 /* Check if cputimer isn't running. This is accessed without locking. */
304 if (!READ_ONCE(pct
->timers_active
)) {
305 struct task_cputime sum
;
308 * The POSIX timer interface allows for absolute time expiry
309 * values through the TIMER_ABSTIME flag, therefore we have
310 * to synchronize the timer to the clock every time we start it.
312 thread_group_cputime(tsk
, &sum
);
313 update_gt_cputime(&cputimer
->cputime_atomic
, &sum
);
316 * We're setting timers_active without a lock. Ensure this
317 * only gets written to in one operation. We set it after
318 * update_gt_cputime() as a small optimization, but
319 * barriers are not required because update_gt_cputime()
320 * can handle concurrent updates.
322 WRITE_ONCE(pct
->timers_active
, true);
324 proc_sample_cputime_atomic(&cputimer
->cputime_atomic
, samples
);
327 static void __thread_group_cputime(struct task_struct
*tsk
, u64
*samples
)
329 struct task_cputime ct
;
331 thread_group_cputime(tsk
, &ct
);
332 store_samples(samples
, ct
.stime
, ct
.utime
, ct
.sum_exec_runtime
);
336 * Sample a process (thread group) clock for the given task clkid. If the
337 * group's cputime accounting is already enabled, read the atomic
338 * store. Otherwise a full update is required. clkid is already validated.
340 static u64
cpu_clock_sample_group(const clockid_t clkid
, struct task_struct
*p
,
343 struct thread_group_cputimer
*cputimer
= &p
->signal
->cputimer
;
344 struct posix_cputimers
*pct
= &p
->signal
->posix_cputimers
;
345 u64 samples
[CPUCLOCK_MAX
];
347 if (!READ_ONCE(pct
->timers_active
)) {
349 thread_group_start_cputime(p
, samples
);
351 __thread_group_cputime(p
, samples
);
353 proc_sample_cputime_atomic(&cputimer
->cputime_atomic
, samples
);
356 return samples
[clkid
];
359 static int posix_cpu_clock_get(const clockid_t clock
, struct timespec64
*tp
)
361 const clockid_t clkid
= CPUCLOCK_WHICH(clock
);
362 struct task_struct
*tsk
;
366 tsk
= pid_task(pid_for_clock(clock
, true), clock_pid_type(clock
));
372 if (CPUCLOCK_PERTHREAD(clock
))
373 t
= cpu_clock_sample(clkid
, tsk
);
375 t
= cpu_clock_sample_group(clkid
, tsk
, false);
378 *tp
= ns_to_timespec64(t
);
383 * Validate the clockid_t for a new CPU-clock timer, and initialize the timer.
384 * This is called from sys_timer_create() and do_cpu_nanosleep() with the
385 * new timer already all-zeros initialized.
387 static int posix_cpu_timer_create(struct k_itimer
*new_timer
)
389 static struct lock_class_key posix_cpu_timers_key
;
393 pid
= pid_for_clock(new_timer
->it_clock
, false);
400 * If posix timer expiry is handled in task work context then
401 * timer::it_lock can be taken without disabling interrupts as all
402 * other locking happens in task context. This requires a separate
403 * lock class key otherwise regular posix timer expiry would record
404 * the lock class being taken in interrupt context and generate a
405 * false positive warning.
407 if (IS_ENABLED(CONFIG_POSIX_CPU_TIMERS_TASK_WORK
))
408 lockdep_set_class(&new_timer
->it_lock
, &posix_cpu_timers_key
);
410 new_timer
->kclock
= &clock_posix_cpu
;
411 timerqueue_init(&new_timer
->it
.cpu
.node
);
412 new_timer
->it
.cpu
.pid
= get_pid(pid
);
417 static struct posix_cputimer_base
*timer_base(struct k_itimer
*timer
,
418 struct task_struct
*tsk
)
420 int clkidx
= CPUCLOCK_WHICH(timer
->it_clock
);
422 if (CPUCLOCK_PERTHREAD(timer
->it_clock
))
423 return tsk
->posix_cputimers
.bases
+ clkidx
;
425 return tsk
->signal
->posix_cputimers
.bases
+ clkidx
;
429 * Force recalculating the base earliest expiration on the next tick.
430 * This will also re-evaluate the need to keep around the process wide
431 * cputime counter and tick dependency and eventually shut these down
434 static void trigger_base_recalc_expires(struct k_itimer
*timer
,
435 struct task_struct
*tsk
)
437 struct posix_cputimer_base
*base
= timer_base(timer
, tsk
);
443 * Dequeue the timer and reset the base if it was its earliest expiration.
444 * It makes sure the next tick recalculates the base next expiration so we
445 * don't keep the costly process wide cputime counter around for a random
446 * amount of time, along with the tick dependency.
448 * If another timer gets queued between this and the next tick, its
449 * expiration will update the base next event if necessary on the next
452 static void disarm_timer(struct k_itimer
*timer
, struct task_struct
*p
)
454 struct cpu_timer
*ctmr
= &timer
->it
.cpu
;
455 struct posix_cputimer_base
*base
;
457 if (!cpu_timer_dequeue(ctmr
))
460 base
= timer_base(timer
, p
);
461 if (cpu_timer_getexpires(ctmr
) == base
->nextevt
)
462 trigger_base_recalc_expires(timer
, p
);
467 * Clean up a CPU-clock timer that is about to be destroyed.
468 * This is called from timer deletion with the timer already locked.
469 * If we return TIMER_RETRY, it's necessary to release the timer's lock
470 * and try again. (This happens when the timer is in the middle of firing.)
472 static int posix_cpu_timer_del(struct k_itimer
*timer
)
474 struct cpu_timer
*ctmr
= &timer
->it
.cpu
;
475 struct sighand_struct
*sighand
;
476 struct task_struct
*p
;
481 p
= cpu_timer_task_rcu(timer
);
486 * Protect against sighand release/switch in exit/exec and process/
487 * thread timer list entry concurrent read/writes.
489 sighand
= lock_task_sighand(p
, &flags
);
490 if (unlikely(sighand
== NULL
)) {
492 * This raced with the reaping of the task. The exit cleanup
493 * should have removed this timer from the timer queue.
495 WARN_ON_ONCE(ctmr
->head
|| timerqueue_node_queued(&ctmr
->node
));
497 if (timer
->it
.cpu
.firing
)
500 disarm_timer(timer
, p
);
502 unlock_task_sighand(p
, &flags
);
513 static void cleanup_timerqueue(struct timerqueue_head
*head
)
515 struct timerqueue_node
*node
;
516 struct cpu_timer
*ctmr
;
518 while ((node
= timerqueue_getnext(head
))) {
519 timerqueue_del(head
, node
);
520 ctmr
= container_of(node
, struct cpu_timer
, node
);
526 * Clean out CPU timers which are still armed when a thread exits. The
527 * timers are only removed from the list. No other updates are done. The
528 * corresponding posix timers are still accessible, but cannot be rearmed.
530 * This must be called with the siglock held.
532 static void cleanup_timers(struct posix_cputimers
*pct
)
534 cleanup_timerqueue(&pct
->bases
[CPUCLOCK_PROF
].tqhead
);
535 cleanup_timerqueue(&pct
->bases
[CPUCLOCK_VIRT
].tqhead
);
536 cleanup_timerqueue(&pct
->bases
[CPUCLOCK_SCHED
].tqhead
);
540 * These are both called with the siglock held, when the current thread
541 * is being reaped. When the final (leader) thread in the group is reaped,
542 * posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit.
544 void posix_cpu_timers_exit(struct task_struct
*tsk
)
546 cleanup_timers(&tsk
->posix_cputimers
);
548 void posix_cpu_timers_exit_group(struct task_struct
*tsk
)
550 cleanup_timers(&tsk
->signal
->posix_cputimers
);
554 * Insert the timer on the appropriate list before any timers that
555 * expire later. This must be called with the sighand lock held.
557 static void arm_timer(struct k_itimer
*timer
, struct task_struct
*p
)
559 struct posix_cputimer_base
*base
= timer_base(timer
, p
);
560 struct cpu_timer
*ctmr
= &timer
->it
.cpu
;
561 u64 newexp
= cpu_timer_getexpires(ctmr
);
563 if (!cpu_timer_enqueue(&base
->tqhead
, ctmr
))
567 * We are the new earliest-expiring POSIX 1.b timer, hence
568 * need to update expiration cache. Take into account that
569 * for process timers we share expiration cache with itimers
570 * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME.
572 if (newexp
< base
->nextevt
)
573 base
->nextevt
= newexp
;
575 if (CPUCLOCK_PERTHREAD(timer
->it_clock
))
576 tick_dep_set_task(p
, TICK_DEP_BIT_POSIX_TIMER
);
578 tick_dep_set_signal(p
, TICK_DEP_BIT_POSIX_TIMER
);
582 * The timer is locked, fire it and arrange for its reload.
584 static void cpu_timer_fire(struct k_itimer
*timer
)
586 struct cpu_timer
*ctmr
= &timer
->it
.cpu
;
588 if ((timer
->it_sigev_notify
& ~SIGEV_THREAD_ID
) == SIGEV_NONE
) {
590 * User don't want any signal.
592 cpu_timer_setexpires(ctmr
, 0);
593 } else if (unlikely(timer
->sigq
== NULL
)) {
595 * This a special case for clock_nanosleep,
596 * not a normal timer from sys_timer_create.
598 wake_up_process(timer
->it_process
);
599 cpu_timer_setexpires(ctmr
, 0);
600 } else if (!timer
->it_interval
) {
602 * One-shot timer. Clear it as soon as it's fired.
604 posix_timer_event(timer
, 0);
605 cpu_timer_setexpires(ctmr
, 0);
606 } else if (posix_timer_event(timer
, ++timer
->it_requeue_pending
)) {
608 * The signal did not get queued because the signal
609 * was ignored, so we won't get any callback to
610 * reload the timer. But we need to keep it
611 * ticking in case the signal is deliverable next time.
613 posix_cpu_timer_rearm(timer
);
614 ++timer
->it_requeue_pending
;
619 * Guts of sys_timer_settime for CPU timers.
620 * This is called with the timer locked and interrupts disabled.
621 * If we return TIMER_RETRY, it's necessary to release the timer's lock
622 * and try again. (This happens when the timer is in the middle of firing.)
624 static int posix_cpu_timer_set(struct k_itimer
*timer
, int timer_flags
,
625 struct itimerspec64
*new, struct itimerspec64
*old
)
627 clockid_t clkid
= CPUCLOCK_WHICH(timer
->it_clock
);
628 u64 old_expires
, new_expires
, old_incr
, val
;
629 struct cpu_timer
*ctmr
= &timer
->it
.cpu
;
630 struct sighand_struct
*sighand
;
631 struct task_struct
*p
;
636 p
= cpu_timer_task_rcu(timer
);
639 * If p has just been reaped, we can no
640 * longer get any information about it at all.
647 * Use the to_ktime conversion because that clamps the maximum
648 * value to KTIME_MAX and avoid multiplication overflows.
650 new_expires
= ktime_to_ns(timespec64_to_ktime(new->it_value
));
653 * Protect against sighand release/switch in exit/exec and p->cpu_timers
654 * and p->signal->cpu_timers read/write in arm_timer()
656 sighand
= lock_task_sighand(p
, &flags
);
658 * If p has just been reaped, we can no
659 * longer get any information about it at all.
661 if (unlikely(sighand
== NULL
)) {
667 * Disarm any old timer after extracting its expiry time.
669 old_incr
= timer
->it_interval
;
670 old_expires
= cpu_timer_getexpires(ctmr
);
672 if (unlikely(timer
->it
.cpu
.firing
)) {
673 timer
->it
.cpu
.firing
= -1;
676 cpu_timer_dequeue(ctmr
);
680 * We need to sample the current value to convert the new
681 * value from to relative and absolute, and to convert the
682 * old value from absolute to relative. To set a process
683 * timer, we need a sample to balance the thread expiry
684 * times (in arm_timer). With an absolute time, we must
685 * check if it's already passed. In short, we need a sample.
687 if (CPUCLOCK_PERTHREAD(timer
->it_clock
))
688 val
= cpu_clock_sample(clkid
, p
);
690 val
= cpu_clock_sample_group(clkid
, p
, true);
693 if (old_expires
== 0) {
694 old
->it_value
.tv_sec
= 0;
695 old
->it_value
.tv_nsec
= 0;
698 * Update the timer in case it has overrun already.
699 * If it has, we'll report it as having overrun and
700 * with the next reloaded timer already ticking,
701 * though we are swallowing that pending
702 * notification here to install the new setting.
704 u64 exp
= bump_cpu_timer(timer
, val
);
707 old_expires
= exp
- val
;
708 old
->it_value
= ns_to_timespec64(old_expires
);
710 old
->it_value
.tv_nsec
= 1;
711 old
->it_value
.tv_sec
= 0;
718 * We are colliding with the timer actually firing.
719 * Punt after filling in the timer's old value, and
720 * disable this firing since we are already reporting
721 * it as an overrun (thanks to bump_cpu_timer above).
723 unlock_task_sighand(p
, &flags
);
727 if (new_expires
!= 0 && !(timer_flags
& TIMER_ABSTIME
)) {
732 * Install the new expiry time (or zero).
733 * For a timer with no notification action, we don't actually
734 * arm the timer (we'll just fake it for timer_gettime).
736 cpu_timer_setexpires(ctmr
, new_expires
);
737 if (new_expires
!= 0 && val
< new_expires
) {
741 unlock_task_sighand(p
, &flags
);
743 * Install the new reload setting, and
744 * set up the signal and overrun bookkeeping.
746 timer
->it_interval
= timespec64_to_ktime(new->it_interval
);
749 * This acts as a modification timestamp for the timer,
750 * so any automatic reload attempt will punt on seeing
751 * that we have reset the timer manually.
753 timer
->it_requeue_pending
= (timer
->it_requeue_pending
+ 2) &
755 timer
->it_overrun_last
= 0;
756 timer
->it_overrun
= -1;
758 if (val
>= new_expires
) {
759 if (new_expires
!= 0) {
761 * The designated time already passed, so we notify
762 * immediately, even if the thread never runs to
763 * accumulate more time on this clock.
765 cpu_timer_fire(timer
);
769 * Make sure we don't keep around the process wide cputime
770 * counter or the tick dependency if they are not necessary.
772 sighand
= lock_task_sighand(p
, &flags
);
776 if (!cpu_timer_queued(ctmr
))
777 trigger_base_recalc_expires(timer
, p
);
779 unlock_task_sighand(p
, &flags
);
784 old
->it_interval
= ns_to_timespec64(old_incr
);
789 static void posix_cpu_timer_get(struct k_itimer
*timer
, struct itimerspec64
*itp
)
791 clockid_t clkid
= CPUCLOCK_WHICH(timer
->it_clock
);
792 struct cpu_timer
*ctmr
= &timer
->it
.cpu
;
793 u64 now
, expires
= cpu_timer_getexpires(ctmr
);
794 struct task_struct
*p
;
797 p
= cpu_timer_task_rcu(timer
);
802 * Easy part: convert the reload time.
804 itp
->it_interval
= ktime_to_timespec64(timer
->it_interval
);
810 * Sample the clock to take the difference with the expiry time.
812 if (CPUCLOCK_PERTHREAD(timer
->it_clock
))
813 now
= cpu_clock_sample(clkid
, p
);
815 now
= cpu_clock_sample_group(clkid
, p
, false);
818 itp
->it_value
= ns_to_timespec64(expires
- now
);
821 * The timer should have expired already, but the firing
822 * hasn't taken place yet. Say it's just about to expire.
824 itp
->it_value
.tv_nsec
= 1;
825 itp
->it_value
.tv_sec
= 0;
831 #define MAX_COLLECTED 20
833 static u64
collect_timerqueue(struct timerqueue_head
*head
,
834 struct list_head
*firing
, u64 now
)
836 struct timerqueue_node
*next
;
839 while ((next
= timerqueue_getnext(head
))) {
840 struct cpu_timer
*ctmr
;
843 ctmr
= container_of(next
, struct cpu_timer
, node
);
844 expires
= cpu_timer_getexpires(ctmr
);
845 /* Limit the number of timers to expire at once */
846 if (++i
== MAX_COLLECTED
|| now
< expires
)
850 cpu_timer_dequeue(ctmr
);
851 list_add_tail(&ctmr
->elist
, firing
);
857 static void collect_posix_cputimers(struct posix_cputimers
*pct
, u64
*samples
,
858 struct list_head
*firing
)
860 struct posix_cputimer_base
*base
= pct
->bases
;
863 for (i
= 0; i
< CPUCLOCK_MAX
; i
++, base
++) {
864 base
->nextevt
= collect_timerqueue(&base
->tqhead
, firing
,
869 static inline void check_dl_overrun(struct task_struct
*tsk
)
871 if (tsk
->dl
.dl_overrun
) {
872 tsk
->dl
.dl_overrun
= 0;
873 __group_send_sig_info(SIGXCPU
, SEND_SIG_PRIV
, tsk
);
877 static bool check_rlimit(u64 time
, u64 limit
, int signo
, bool rt
, bool hard
)
882 if (print_fatal_signals
) {
883 pr_info("%s Watchdog Timeout (%s): %s[%d]\n",
884 rt
? "RT" : "CPU", hard
? "hard" : "soft",
885 current
->comm
, task_pid_nr(current
));
887 __group_send_sig_info(signo
, SEND_SIG_PRIV
, current
);
892 * Check for any per-thread CPU timers that have fired and move them off
893 * the tsk->cpu_timers[N] list onto the firing list. Here we update the
894 * tsk->it_*_expires values to reflect the remaining thread CPU timers.
896 static void check_thread_timers(struct task_struct
*tsk
,
897 struct list_head
*firing
)
899 struct posix_cputimers
*pct
= &tsk
->posix_cputimers
;
900 u64 samples
[CPUCLOCK_MAX
];
904 check_dl_overrun(tsk
);
906 if (expiry_cache_is_inactive(pct
))
909 task_sample_cputime(tsk
, samples
);
910 collect_posix_cputimers(pct
, samples
, firing
);
913 * Check for the special case thread timers.
915 soft
= task_rlimit(tsk
, RLIMIT_RTTIME
);
916 if (soft
!= RLIM_INFINITY
) {
917 /* Task RT timeout is accounted in jiffies. RTTIME is usec */
918 unsigned long rttime
= tsk
->rt
.timeout
* (USEC_PER_SEC
/ HZ
);
919 unsigned long hard
= task_rlimit_max(tsk
, RLIMIT_RTTIME
);
921 /* At the hard limit, send SIGKILL. No further action. */
922 if (hard
!= RLIM_INFINITY
&&
923 check_rlimit(rttime
, hard
, SIGKILL
, true, true))
926 /* At the soft limit, send a SIGXCPU every second */
927 if (check_rlimit(rttime
, soft
, SIGXCPU
, true, false)) {
928 soft
+= USEC_PER_SEC
;
929 tsk
->signal
->rlim
[RLIMIT_RTTIME
].rlim_cur
= soft
;
933 if (expiry_cache_is_inactive(pct
))
934 tick_dep_clear_task(tsk
, TICK_DEP_BIT_POSIX_TIMER
);
937 static inline void stop_process_timers(struct signal_struct
*sig
)
939 struct posix_cputimers
*pct
= &sig
->posix_cputimers
;
941 /* Turn off the active flag. This is done without locking. */
942 WRITE_ONCE(pct
->timers_active
, false);
943 tick_dep_clear_signal(sig
, TICK_DEP_BIT_POSIX_TIMER
);
946 static void check_cpu_itimer(struct task_struct
*tsk
, struct cpu_itimer
*it
,
947 u64
*expires
, u64 cur_time
, int signo
)
952 if (cur_time
>= it
->expires
) {
954 it
->expires
+= it
->incr
;
958 trace_itimer_expire(signo
== SIGPROF
?
959 ITIMER_PROF
: ITIMER_VIRTUAL
,
960 task_tgid(tsk
), cur_time
);
961 __group_send_sig_info(signo
, SEND_SIG_PRIV
, tsk
);
964 if (it
->expires
&& it
->expires
< *expires
)
965 *expires
= it
->expires
;
969 * Check for any per-thread CPU timers that have fired and move them
970 * off the tsk->*_timers list onto the firing list. Per-thread timers
971 * have already been taken off.
973 static void check_process_timers(struct task_struct
*tsk
,
974 struct list_head
*firing
)
976 struct signal_struct
*const sig
= tsk
->signal
;
977 struct posix_cputimers
*pct
= &sig
->posix_cputimers
;
978 u64 samples
[CPUCLOCK_MAX
];
982 * If there are no active process wide timers (POSIX 1.b, itimers,
983 * RLIMIT_CPU) nothing to check. Also skip the process wide timer
984 * processing when there is already another task handling them.
986 if (!READ_ONCE(pct
->timers_active
) || pct
->expiry_active
)
990 * Signify that a thread is checking for process timers.
991 * Write access to this field is protected by the sighand lock.
993 pct
->expiry_active
= true;
996 * Collect the current process totals. Group accounting is active
997 * so the sample can be taken directly.
999 proc_sample_cputime_atomic(&sig
->cputimer
.cputime_atomic
, samples
);
1000 collect_posix_cputimers(pct
, samples
, firing
);
1003 * Check for the special case process timers.
1005 check_cpu_itimer(tsk
, &sig
->it
[CPUCLOCK_PROF
],
1006 &pct
->bases
[CPUCLOCK_PROF
].nextevt
,
1007 samples
[CPUCLOCK_PROF
], SIGPROF
);
1008 check_cpu_itimer(tsk
, &sig
->it
[CPUCLOCK_VIRT
],
1009 &pct
->bases
[CPUCLOCK_VIRT
].nextevt
,
1010 samples
[CPUCLOCK_VIRT
], SIGVTALRM
);
1012 soft
= task_rlimit(tsk
, RLIMIT_CPU
);
1013 if (soft
!= RLIM_INFINITY
) {
1014 /* RLIMIT_CPU is in seconds. Samples are nanoseconds */
1015 unsigned long hard
= task_rlimit_max(tsk
, RLIMIT_CPU
);
1016 u64 ptime
= samples
[CPUCLOCK_PROF
];
1017 u64 softns
= (u64
)soft
* NSEC_PER_SEC
;
1018 u64 hardns
= (u64
)hard
* NSEC_PER_SEC
;
1020 /* At the hard limit, send SIGKILL. No further action. */
1021 if (hard
!= RLIM_INFINITY
&&
1022 check_rlimit(ptime
, hardns
, SIGKILL
, false, true))
1025 /* At the soft limit, send a SIGXCPU every second */
1026 if (check_rlimit(ptime
, softns
, SIGXCPU
, false, false)) {
1027 sig
->rlim
[RLIMIT_CPU
].rlim_cur
= soft
+ 1;
1028 softns
+= NSEC_PER_SEC
;
1031 /* Update the expiry cache */
1032 if (softns
< pct
->bases
[CPUCLOCK_PROF
].nextevt
)
1033 pct
->bases
[CPUCLOCK_PROF
].nextevt
= softns
;
1036 if (expiry_cache_is_inactive(pct
))
1037 stop_process_timers(sig
);
1039 pct
->expiry_active
= false;
1043 * This is called from the signal code (via posixtimer_rearm)
1044 * when the last timer signal was delivered and we have to reload the timer.
1046 static void posix_cpu_timer_rearm(struct k_itimer
*timer
)
1048 clockid_t clkid
= CPUCLOCK_WHICH(timer
->it_clock
);
1049 struct task_struct
*p
;
1050 struct sighand_struct
*sighand
;
1051 unsigned long flags
;
1055 p
= cpu_timer_task_rcu(timer
);
1059 /* Protect timer list r/w in arm_timer() */
1060 sighand
= lock_task_sighand(p
, &flags
);
1061 if (unlikely(sighand
== NULL
))
1065 * Fetch the current sample and update the timer's expiry time.
1067 if (CPUCLOCK_PERTHREAD(timer
->it_clock
))
1068 now
= cpu_clock_sample(clkid
, p
);
1070 now
= cpu_clock_sample_group(clkid
, p
, true);
1072 bump_cpu_timer(timer
, now
);
1075 * Now re-arm for the new expiry time.
1077 arm_timer(timer
, p
);
1078 unlock_task_sighand(p
, &flags
);
1084 * task_cputimers_expired - Check whether posix CPU timers are expired
1086 * @samples: Array of current samples for the CPUCLOCK clocks
1087 * @pct: Pointer to a posix_cputimers container
1089 * Returns true if any member of @samples is greater than the corresponding
1090 * member of @pct->bases[CLK].nextevt. False otherwise
1093 task_cputimers_expired(const u64
*samples
, struct posix_cputimers
*pct
)
1097 for (i
= 0; i
< CPUCLOCK_MAX
; i
++) {
1098 if (samples
[i
] >= pct
->bases
[i
].nextevt
)
1105 * fastpath_timer_check - POSIX CPU timers fast path.
1107 * @tsk: The task (thread) being checked.
1109 * Check the task and thread group timers. If both are zero (there are no
1110 * timers set) return false. Otherwise snapshot the task and thread group
1111 * timers and compare them with the corresponding expiration times. Return
1112 * true if a timer has expired, else return false.
1114 static inline bool fastpath_timer_check(struct task_struct
*tsk
)
1116 struct posix_cputimers
*pct
= &tsk
->posix_cputimers
;
1117 struct signal_struct
*sig
;
1119 if (!expiry_cache_is_inactive(pct
)) {
1120 u64 samples
[CPUCLOCK_MAX
];
1122 task_sample_cputime(tsk
, samples
);
1123 if (task_cputimers_expired(samples
, pct
))
1128 pct
= &sig
->posix_cputimers
;
1130 * Check if thread group timers expired when timers are active and
1131 * no other thread in the group is already handling expiry for
1132 * thread group cputimers. These fields are read without the
1133 * sighand lock. However, this is fine because this is meant to be
1134 * a fastpath heuristic to determine whether we should try to
1135 * acquire the sighand lock to handle timer expiry.
1137 * In the worst case scenario, if concurrently timers_active is set
1138 * or expiry_active is cleared, but the current thread doesn't see
1139 * the change yet, the timer checks are delayed until the next
1140 * thread in the group gets a scheduler interrupt to handle the
1141 * timer. This isn't an issue in practice because these types of
1142 * delays with signals actually getting sent are expected.
1144 if (READ_ONCE(pct
->timers_active
) && !READ_ONCE(pct
->expiry_active
)) {
1145 u64 samples
[CPUCLOCK_MAX
];
1147 proc_sample_cputime_atomic(&sig
->cputimer
.cputime_atomic
,
1150 if (task_cputimers_expired(samples
, pct
))
1154 if (dl_task(tsk
) && tsk
->dl
.dl_overrun
)
1160 static void handle_posix_cpu_timers(struct task_struct
*tsk
);
1162 #ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK
1163 static void posix_cpu_timers_work(struct callback_head
*work
)
1165 handle_posix_cpu_timers(current
);
1169 * Clear existing posix CPU timers task work.
1171 void clear_posix_cputimers_work(struct task_struct
*p
)
1174 * A copied work entry from the old task is not meaningful, clear it.
1175 * N.B. init_task_work will not do this.
1177 memset(&p
->posix_cputimers_work
.work
, 0,
1178 sizeof(p
->posix_cputimers_work
.work
));
1179 init_task_work(&p
->posix_cputimers_work
.work
,
1180 posix_cpu_timers_work
);
1181 p
->posix_cputimers_work
.scheduled
= false;
1185 * Initialize posix CPU timers task work in init task. Out of line to
1186 * keep the callback static and to avoid header recursion hell.
1188 void __init
posix_cputimers_init_work(void)
1190 clear_posix_cputimers_work(current
);
1194 * Note: All operations on tsk->posix_cputimer_work.scheduled happen either
1195 * in hard interrupt context or in task context with interrupts
1196 * disabled. Aside of that the writer/reader interaction is always in the
1197 * context of the current task, which means they are strict per CPU.
1199 static inline bool posix_cpu_timers_work_scheduled(struct task_struct
*tsk
)
1201 return tsk
->posix_cputimers_work
.scheduled
;
1204 static inline void __run_posix_cpu_timers(struct task_struct
*tsk
)
1206 if (WARN_ON_ONCE(tsk
->posix_cputimers_work
.scheduled
))
1209 /* Schedule task work to actually expire the timers */
1210 tsk
->posix_cputimers_work
.scheduled
= true;
1211 task_work_add(tsk
, &tsk
->posix_cputimers_work
.work
, TWA_RESUME
);
1214 static inline bool posix_cpu_timers_enable_work(struct task_struct
*tsk
,
1215 unsigned long start
)
1220 * On !RT kernels interrupts are disabled while collecting expired
1221 * timers, so no tick can happen and the fast path check can be
1222 * reenabled without further checks.
1224 if (!IS_ENABLED(CONFIG_PREEMPT_RT
)) {
1225 tsk
->posix_cputimers_work
.scheduled
= false;
1230 * On RT enabled kernels ticks can happen while the expired timers
1231 * are collected under sighand lock. But any tick which observes
1232 * the CPUTIMERS_WORK_SCHEDULED bit set, does not run the fastpath
1233 * checks. So reenabling the tick work has do be done carefully:
1235 * Disable interrupts and run the fast path check if jiffies have
1236 * advanced since the collecting of expired timers started. If
1237 * jiffies have not advanced or the fast path check did not find
1238 * newly expired timers, reenable the fast path check in the timer
1239 * interrupt. If there are newly expired timers, return false and
1240 * let the collection loop repeat.
1242 local_irq_disable();
1243 if (start
!= jiffies
&& fastpath_timer_check(tsk
))
1246 tsk
->posix_cputimers_work
.scheduled
= false;
1251 #else /* CONFIG_POSIX_CPU_TIMERS_TASK_WORK */
1252 static inline void __run_posix_cpu_timers(struct task_struct
*tsk
)
1254 lockdep_posixtimer_enter();
1255 handle_posix_cpu_timers(tsk
);
1256 lockdep_posixtimer_exit();
1259 static inline bool posix_cpu_timers_work_scheduled(struct task_struct
*tsk
)
1264 static inline bool posix_cpu_timers_enable_work(struct task_struct
*tsk
,
1265 unsigned long start
)
1269 #endif /* CONFIG_POSIX_CPU_TIMERS_TASK_WORK */
1271 static void handle_posix_cpu_timers(struct task_struct
*tsk
)
1273 struct k_itimer
*timer
, *next
;
1274 unsigned long flags
, start
;
1277 if (!lock_task_sighand(tsk
, &flags
))
1282 * On RT locking sighand lock does not disable interrupts,
1283 * so this needs to be careful vs. ticks. Store the current
1286 start
= READ_ONCE(jiffies
);
1290 * Here we take off tsk->signal->cpu_timers[N] and
1291 * tsk->cpu_timers[N] all the timers that are firing, and
1292 * put them on the firing list.
1294 check_thread_timers(tsk
, &firing
);
1296 check_process_timers(tsk
, &firing
);
1299 * The above timer checks have updated the expiry cache and
1300 * because nothing can have queued or modified timers after
1301 * sighand lock was taken above it is guaranteed to be
1302 * consistent. So the next timer interrupt fastpath check
1303 * will find valid data.
1305 * If timer expiry runs in the timer interrupt context then
1306 * the loop is not relevant as timers will be directly
1307 * expired in interrupt context. The stub function below
1308 * returns always true which allows the compiler to
1309 * optimize the loop out.
1311 * If timer expiry is deferred to task work context then
1312 * the following rules apply:
1314 * - On !RT kernels no tick can have happened on this CPU
1315 * after sighand lock was acquired because interrupts are
1316 * disabled. So reenabling task work before dropping
1317 * sighand lock and reenabling interrupts is race free.
1319 * - On RT kernels ticks might have happened but the tick
1320 * work ignored posix CPU timer handling because the
1321 * CPUTIMERS_WORK_SCHEDULED bit is set. Reenabling work
1322 * must be done very carefully including a check whether
1323 * ticks have happened since the start of the timer
1324 * expiry checks. posix_cpu_timers_enable_work() takes
1325 * care of that and eventually lets the expiry checks
1328 } while (!posix_cpu_timers_enable_work(tsk
, start
));
1331 * We must release sighand lock before taking any timer's lock.
1332 * There is a potential race with timer deletion here, as the
1333 * siglock now protects our private firing list. We have set
1334 * the firing flag in each timer, so that a deletion attempt
1335 * that gets the timer lock before we do will give it up and
1336 * spin until we've taken care of that timer below.
1338 unlock_task_sighand(tsk
, &flags
);
1341 * Now that all the timers on our list have the firing flag,
1342 * no one will touch their list entries but us. We'll take
1343 * each timer's lock before clearing its firing flag, so no
1344 * timer call will interfere.
1346 list_for_each_entry_safe(timer
, next
, &firing
, it
.cpu
.elist
) {
1350 * spin_lock() is sufficient here even independent of the
1351 * expiry context. If expiry happens in hard interrupt
1352 * context it's obvious. For task work context it's safe
1353 * because all other operations on timer::it_lock happen in
1354 * task context (syscall or exit).
1356 spin_lock(&timer
->it_lock
);
1357 list_del_init(&timer
->it
.cpu
.elist
);
1358 cpu_firing
= timer
->it
.cpu
.firing
;
1359 timer
->it
.cpu
.firing
= 0;
1361 * The firing flag is -1 if we collided with a reset
1362 * of the timer, which already reported this
1363 * almost-firing as an overrun. So don't generate an event.
1365 if (likely(cpu_firing
>= 0))
1366 cpu_timer_fire(timer
);
1367 spin_unlock(&timer
->it_lock
);
1372 * This is called from the timer interrupt handler. The irq handler has
1373 * already updated our counts. We need to check if any timers fire now.
1374 * Interrupts are disabled.
1376 void run_posix_cpu_timers(void)
1378 struct task_struct
*tsk
= current
;
1380 lockdep_assert_irqs_disabled();
1383 * If the actual expiry is deferred to task work context and the
1384 * work is already scheduled there is no point to do anything here.
1386 if (posix_cpu_timers_work_scheduled(tsk
))
1390 * The fast path checks that there are no expired thread or thread
1391 * group timers. If that's so, just return.
1393 if (!fastpath_timer_check(tsk
))
1396 __run_posix_cpu_timers(tsk
);
1400 * Set one of the process-wide special case CPU timers or RLIMIT_CPU.
1401 * The tsk->sighand->siglock must be held by the caller.
1403 void set_process_cpu_timer(struct task_struct
*tsk
, unsigned int clkid
,
1404 u64
*newval
, u64
*oldval
)
1408 if (WARN_ON_ONCE(clkid
>= CPUCLOCK_SCHED
))
1411 nextevt
= &tsk
->signal
->posix_cputimers
.bases
[clkid
].nextevt
;
1412 now
= cpu_clock_sample_group(clkid
, tsk
, true);
1416 * We are setting itimer. The *oldval is absolute and we update
1417 * it to be relative, *newval argument is relative and we update
1418 * it to be absolute.
1421 if (*oldval
<= now
) {
1422 /* Just about to fire. */
1423 *oldval
= TICK_NSEC
;
1434 * Update expiration cache if this is the earliest timer. CPUCLOCK_PROF
1435 * expiry cache is also used by RLIMIT_CPU!.
1437 if (*newval
< *nextevt
)
1440 tick_dep_set_signal(tsk
, TICK_DEP_BIT_POSIX_TIMER
);
1443 static int do_cpu_nanosleep(const clockid_t which_clock
, int flags
,
1444 const struct timespec64
*rqtp
)
1446 struct itimerspec64 it
;
1447 struct k_itimer timer
;
1452 * Set up a temporary timer and then wait for it to go off.
1454 memset(&timer
, 0, sizeof timer
);
1455 spin_lock_init(&timer
.it_lock
);
1456 timer
.it_clock
= which_clock
;
1457 timer
.it_overrun
= -1;
1458 error
= posix_cpu_timer_create(&timer
);
1459 timer
.it_process
= current
;
1462 static struct itimerspec64 zero_it
;
1463 struct restart_block
*restart
;
1465 memset(&it
, 0, sizeof(it
));
1466 it
.it_value
= *rqtp
;
1468 spin_lock_irq(&timer
.it_lock
);
1469 error
= posix_cpu_timer_set(&timer
, flags
, &it
, NULL
);
1471 spin_unlock_irq(&timer
.it_lock
);
1475 while (!signal_pending(current
)) {
1476 if (!cpu_timer_getexpires(&timer
.it
.cpu
)) {
1478 * Our timer fired and was reset, below
1479 * deletion can not fail.
1481 posix_cpu_timer_del(&timer
);
1482 spin_unlock_irq(&timer
.it_lock
);
1487 * Block until cpu_timer_fire (or a signal) wakes us.
1489 __set_current_state(TASK_INTERRUPTIBLE
);
1490 spin_unlock_irq(&timer
.it_lock
);
1492 spin_lock_irq(&timer
.it_lock
);
1496 * We were interrupted by a signal.
1498 expires
= cpu_timer_getexpires(&timer
.it
.cpu
);
1499 error
= posix_cpu_timer_set(&timer
, 0, &zero_it
, &it
);
1502 * Timer is now unarmed, deletion can not fail.
1504 posix_cpu_timer_del(&timer
);
1506 spin_unlock_irq(&timer
.it_lock
);
1508 while (error
== TIMER_RETRY
) {
1510 * We need to handle case when timer was or is in the
1511 * middle of firing. In other cases we already freed
1514 spin_lock_irq(&timer
.it_lock
);
1515 error
= posix_cpu_timer_del(&timer
);
1516 spin_unlock_irq(&timer
.it_lock
);
1519 if ((it
.it_value
.tv_sec
| it
.it_value
.tv_nsec
) == 0) {
1521 * It actually did fire already.
1526 error
= -ERESTART_RESTARTBLOCK
;
1528 * Report back to the user the time still remaining.
1530 restart
= ¤t
->restart_block
;
1531 restart
->nanosleep
.expires
= expires
;
1532 if (restart
->nanosleep
.type
!= TT_NONE
)
1533 error
= nanosleep_copyout(restart
, &it
.it_value
);
1539 static long posix_cpu_nsleep_restart(struct restart_block
*restart_block
);
1541 static int posix_cpu_nsleep(const clockid_t which_clock
, int flags
,
1542 const struct timespec64
*rqtp
)
1544 struct restart_block
*restart_block
= ¤t
->restart_block
;
1548 * Diagnose required errors first.
1550 if (CPUCLOCK_PERTHREAD(which_clock
) &&
1551 (CPUCLOCK_PID(which_clock
) == 0 ||
1552 CPUCLOCK_PID(which_clock
) == task_pid_vnr(current
)))
1555 error
= do_cpu_nanosleep(which_clock
, flags
, rqtp
);
1557 if (error
== -ERESTART_RESTARTBLOCK
) {
1559 if (flags
& TIMER_ABSTIME
)
1560 return -ERESTARTNOHAND
;
1562 restart_block
->nanosleep
.clockid
= which_clock
;
1563 set_restart_fn(restart_block
, posix_cpu_nsleep_restart
);
1568 static long posix_cpu_nsleep_restart(struct restart_block
*restart_block
)
1570 clockid_t which_clock
= restart_block
->nanosleep
.clockid
;
1571 struct timespec64 t
;
1573 t
= ns_to_timespec64(restart_block
->nanosleep
.expires
);
1575 return do_cpu_nanosleep(which_clock
, TIMER_ABSTIME
, &t
);
1578 #define PROCESS_CLOCK make_process_cpuclock(0, CPUCLOCK_SCHED)
1579 #define THREAD_CLOCK make_thread_cpuclock(0, CPUCLOCK_SCHED)
1581 static int process_cpu_clock_getres(const clockid_t which_clock
,
1582 struct timespec64
*tp
)
1584 return posix_cpu_clock_getres(PROCESS_CLOCK
, tp
);
1586 static int process_cpu_clock_get(const clockid_t which_clock
,
1587 struct timespec64
*tp
)
1589 return posix_cpu_clock_get(PROCESS_CLOCK
, tp
);
1591 static int process_cpu_timer_create(struct k_itimer
*timer
)
1593 timer
->it_clock
= PROCESS_CLOCK
;
1594 return posix_cpu_timer_create(timer
);
1596 static int process_cpu_nsleep(const clockid_t which_clock
, int flags
,
1597 const struct timespec64
*rqtp
)
1599 return posix_cpu_nsleep(PROCESS_CLOCK
, flags
, rqtp
);
1601 static int thread_cpu_clock_getres(const clockid_t which_clock
,
1602 struct timespec64
*tp
)
1604 return posix_cpu_clock_getres(THREAD_CLOCK
, tp
);
1606 static int thread_cpu_clock_get(const clockid_t which_clock
,
1607 struct timespec64
*tp
)
1609 return posix_cpu_clock_get(THREAD_CLOCK
, tp
);
1611 static int thread_cpu_timer_create(struct k_itimer
*timer
)
1613 timer
->it_clock
= THREAD_CLOCK
;
1614 return posix_cpu_timer_create(timer
);
1617 const struct k_clock clock_posix_cpu
= {
1618 .clock_getres
= posix_cpu_clock_getres
,
1619 .clock_set
= posix_cpu_clock_set
,
1620 .clock_get_timespec
= posix_cpu_clock_get
,
1621 .timer_create
= posix_cpu_timer_create
,
1622 .nsleep
= posix_cpu_nsleep
,
1623 .timer_set
= posix_cpu_timer_set
,
1624 .timer_del
= posix_cpu_timer_del
,
1625 .timer_get
= posix_cpu_timer_get
,
1626 .timer_rearm
= posix_cpu_timer_rearm
,
1629 const struct k_clock clock_process
= {
1630 .clock_getres
= process_cpu_clock_getres
,
1631 .clock_get_timespec
= process_cpu_clock_get
,
1632 .timer_create
= process_cpu_timer_create
,
1633 .nsleep
= process_cpu_nsleep
,
1636 const struct k_clock clock_thread
= {
1637 .clock_getres
= thread_cpu_clock_getres
,
1638 .clock_get_timespec
= thread_cpu_clock_get
,
1639 .timer_create
= thread_cpu_timer_create
,