2 * Implement CPU time clocks for the POSIX clock interface.
5 #include <linux/sched.h>
6 #include <linux/posix-timers.h>
7 #include <linux/errno.h>
8 #include <linux/math64.h>
9 #include <asm/uaccess.h>
10 #include <linux/kernel_stat.h>
11 #include <trace/events/timer.h>
14 * Called after updating RLIMIT_CPU to run cpu timer and update
15 * tsk->signal->cputime_expires expiration cache if necessary. Needs
16 * siglock protection since other code may update expiration cache as
19 void update_rlimit_cpu(struct task_struct
*task
, unsigned long rlim_new
)
21 cputime_t cputime
= secs_to_cputime(rlim_new
);
23 spin_lock_irq(&task
->sighand
->siglock
);
24 set_process_cpu_timer(task
, CPUCLOCK_PROF
, &cputime
, NULL
);
25 spin_unlock_irq(&task
->sighand
->siglock
);
28 static int check_clock(const clockid_t which_clock
)
31 struct task_struct
*p
;
32 const pid_t pid
= CPUCLOCK_PID(which_clock
);
34 if (CPUCLOCK_WHICH(which_clock
) >= CPUCLOCK_MAX
)
41 p
= find_task_by_vpid(pid
);
42 if (!p
|| !(CPUCLOCK_PERTHREAD(which_clock
) ?
43 same_thread_group(p
, current
) : has_group_leader_pid(p
))) {
51 static inline union cpu_time_count
52 timespec_to_sample(const clockid_t which_clock
, const struct timespec
*tp
)
54 union cpu_time_count ret
;
55 ret
.sched
= 0; /* high half always zero when .cpu used */
56 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
) {
57 ret
.sched
= (unsigned long long)tp
->tv_sec
* NSEC_PER_SEC
+ tp
->tv_nsec
;
59 ret
.cpu
= timespec_to_cputime(tp
);
64 static void sample_to_timespec(const clockid_t which_clock
,
65 union cpu_time_count cpu
,
68 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
)
69 *tp
= ns_to_timespec(cpu
.sched
);
71 cputime_to_timespec(cpu
.cpu
, tp
);
74 static inline int cpu_time_before(const clockid_t which_clock
,
75 union cpu_time_count now
,
76 union cpu_time_count then
)
78 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
) {
79 return now
.sched
< then
.sched
;
81 return cputime_lt(now
.cpu
, then
.cpu
);
84 static inline void cpu_time_add(const clockid_t which_clock
,
85 union cpu_time_count
*acc
,
86 union cpu_time_count val
)
88 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
) {
89 acc
->sched
+= val
.sched
;
91 acc
->cpu
= cputime_add(acc
->cpu
, val
.cpu
);
94 static inline union cpu_time_count
cpu_time_sub(const clockid_t which_clock
,
95 union cpu_time_count a
,
96 union cpu_time_count b
)
98 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
) {
101 a
.cpu
= cputime_sub(a
.cpu
, b
.cpu
);
107 * Divide and limit the result to res >= 1
109 * This is necessary to prevent signal delivery starvation, when the result of
110 * the division would be rounded down to 0.
112 static inline cputime_t
cputime_div_non_zero(cputime_t time
, unsigned long div
)
114 cputime_t res
= cputime_div(time
, div
);
116 return max_t(cputime_t
, res
, 1);
120 * Update expiry time from increment, and increase overrun count,
121 * given the current clock sample.
123 static void bump_cpu_timer(struct k_itimer
*timer
,
124 union cpu_time_count now
)
128 if (timer
->it
.cpu
.incr
.sched
== 0)
131 if (CPUCLOCK_WHICH(timer
->it_clock
) == CPUCLOCK_SCHED
) {
132 unsigned long long delta
, incr
;
134 if (now
.sched
< timer
->it
.cpu
.expires
.sched
)
136 incr
= timer
->it
.cpu
.incr
.sched
;
137 delta
= now
.sched
+ incr
- timer
->it
.cpu
.expires
.sched
;
138 /* Don't use (incr*2 < delta), incr*2 might overflow. */
139 for (i
= 0; incr
< delta
- incr
; i
++)
141 for (; i
>= 0; incr
>>= 1, i
--) {
144 timer
->it
.cpu
.expires
.sched
+= incr
;
145 timer
->it_overrun
+= 1 << i
;
149 cputime_t delta
, incr
;
151 if (cputime_lt(now
.cpu
, timer
->it
.cpu
.expires
.cpu
))
153 incr
= timer
->it
.cpu
.incr
.cpu
;
154 delta
= cputime_sub(cputime_add(now
.cpu
, incr
),
155 timer
->it
.cpu
.expires
.cpu
);
156 /* Don't use (incr*2 < delta), incr*2 might overflow. */
157 for (i
= 0; cputime_lt(incr
, cputime_sub(delta
, incr
)); i
++)
158 incr
= cputime_add(incr
, incr
);
159 for (; i
>= 0; incr
= cputime_halve(incr
), i
--) {
160 if (cputime_lt(delta
, incr
))
162 timer
->it
.cpu
.expires
.cpu
=
163 cputime_add(timer
->it
.cpu
.expires
.cpu
, incr
);
164 timer
->it_overrun
+= 1 << i
;
165 delta
= cputime_sub(delta
, incr
);
170 static inline cputime_t
prof_ticks(struct task_struct
*p
)
172 return cputime_add(p
->utime
, p
->stime
);
174 static inline cputime_t
virt_ticks(struct task_struct
*p
)
180 posix_cpu_clock_getres(const clockid_t which_clock
, struct timespec
*tp
)
182 int error
= check_clock(which_clock
);
185 tp
->tv_nsec
= ((NSEC_PER_SEC
+ HZ
- 1) / HZ
);
186 if (CPUCLOCK_WHICH(which_clock
) == CPUCLOCK_SCHED
) {
188 * If sched_clock is using a cycle counter, we
189 * don't have any idea of its true resolution
190 * exported, but it is much more than 1s/HZ.
199 posix_cpu_clock_set(const clockid_t which_clock
, const struct timespec
*tp
)
202 * You can never reset a CPU clock, but we check for other errors
203 * in the call before failing with EPERM.
205 int error
= check_clock(which_clock
);
214 * Sample a per-thread clock for the given task.
216 static int cpu_clock_sample(const clockid_t which_clock
, struct task_struct
*p
,
217 union cpu_time_count
*cpu
)
219 switch (CPUCLOCK_WHICH(which_clock
)) {
223 cpu
->cpu
= prof_ticks(p
);
226 cpu
->cpu
= virt_ticks(p
);
229 cpu
->sched
= task_sched_runtime(p
);
235 void thread_group_cputime(struct task_struct
*tsk
, struct task_cputime
*times
)
237 struct signal_struct
*sig
= tsk
->signal
;
238 struct task_struct
*t
;
240 times
->utime
= sig
->utime
;
241 times
->stime
= sig
->stime
;
242 times
->sum_exec_runtime
= sig
->sum_sched_runtime
;
245 /* make sure we can trust tsk->thread_group list */
246 if (!likely(pid_alive(tsk
)))
251 times
->utime
= cputime_add(times
->utime
, t
->utime
);
252 times
->stime
= cputime_add(times
->stime
, t
->stime
);
253 times
->sum_exec_runtime
+= task_sched_runtime(t
);
254 } while_each_thread(tsk
, t
);
259 static void update_gt_cputime(struct task_cputime
*a
, struct task_cputime
*b
)
261 if (cputime_gt(b
->utime
, a
->utime
))
264 if (cputime_gt(b
->stime
, a
->stime
))
267 if (b
->sum_exec_runtime
> a
->sum_exec_runtime
)
268 a
->sum_exec_runtime
= b
->sum_exec_runtime
;
271 void thread_group_cputimer(struct task_struct
*tsk
, struct task_cputime
*times
)
273 struct thread_group_cputimer
*cputimer
= &tsk
->signal
->cputimer
;
274 struct task_cputime sum
;
277 if (!cputimer
->running
) {
279 * The POSIX timer interface allows for absolute time expiry
280 * values through the TIMER_ABSTIME flag, therefore we have
281 * to synchronize the timer to the clock every time we start
284 thread_group_cputime(tsk
, &sum
);
285 spin_lock_irqsave(&cputimer
->lock
, flags
);
286 cputimer
->running
= 1;
287 update_gt_cputime(&cputimer
->cputime
, &sum
);
289 spin_lock_irqsave(&cputimer
->lock
, flags
);
290 *times
= cputimer
->cputime
;
291 spin_unlock_irqrestore(&cputimer
->lock
, flags
);
295 * Sample a process (thread group) clock for the given group_leader task.
296 * Must be called with tasklist_lock held for reading.
298 static int cpu_clock_sample_group(const clockid_t which_clock
,
299 struct task_struct
*p
,
300 union cpu_time_count
*cpu
)
302 struct task_cputime cputime
;
304 switch (CPUCLOCK_WHICH(which_clock
)) {
308 thread_group_cputime(p
, &cputime
);
309 cpu
->cpu
= cputime_add(cputime
.utime
, cputime
.stime
);
312 thread_group_cputime(p
, &cputime
);
313 cpu
->cpu
= cputime
.utime
;
316 thread_group_cputime(p
, &cputime
);
317 cpu
->sched
= cputime
.sum_exec_runtime
;
324 static int posix_cpu_clock_get(const clockid_t which_clock
, struct timespec
*tp
)
326 const pid_t pid
= CPUCLOCK_PID(which_clock
);
328 union cpu_time_count rtn
;
332 * Special case constant value for our own clocks.
333 * We don't have to do any lookup to find ourselves.
335 if (CPUCLOCK_PERTHREAD(which_clock
)) {
337 * Sampling just ourselves we can do with no locking.
339 error
= cpu_clock_sample(which_clock
,
342 read_lock(&tasklist_lock
);
343 error
= cpu_clock_sample_group(which_clock
,
345 read_unlock(&tasklist_lock
);
349 * Find the given PID, and validate that the caller
350 * should be able to see it.
352 struct task_struct
*p
;
354 p
= find_task_by_vpid(pid
);
356 if (CPUCLOCK_PERTHREAD(which_clock
)) {
357 if (same_thread_group(p
, current
)) {
358 error
= cpu_clock_sample(which_clock
,
362 read_lock(&tasklist_lock
);
363 if (thread_group_leader(p
) && p
->sighand
) {
365 cpu_clock_sample_group(which_clock
,
368 read_unlock(&tasklist_lock
);
376 sample_to_timespec(which_clock
, rtn
, tp
);
382 * Validate the clockid_t for a new CPU-clock timer, and initialize the timer.
383 * This is called from sys_timer_create() and do_cpu_nanosleep() with the
384 * new timer already all-zeros initialized.
386 static int posix_cpu_timer_create(struct k_itimer
*new_timer
)
389 const pid_t pid
= CPUCLOCK_PID(new_timer
->it_clock
);
390 struct task_struct
*p
;
392 if (CPUCLOCK_WHICH(new_timer
->it_clock
) >= CPUCLOCK_MAX
)
395 INIT_LIST_HEAD(&new_timer
->it
.cpu
.entry
);
398 if (CPUCLOCK_PERTHREAD(new_timer
->it_clock
)) {
402 p
= find_task_by_vpid(pid
);
403 if (p
&& !same_thread_group(p
, current
))
408 p
= current
->group_leader
;
410 p
= find_task_by_vpid(pid
);
411 if (p
&& !has_group_leader_pid(p
))
415 new_timer
->it
.cpu
.task
= p
;
427 * Clean up a CPU-clock timer that is about to be destroyed.
428 * This is called from timer deletion with the timer already locked.
429 * If we return TIMER_RETRY, it's necessary to release the timer's lock
430 * and try again. (This happens when the timer is in the middle of firing.)
432 static int posix_cpu_timer_del(struct k_itimer
*timer
)
434 struct task_struct
*p
= timer
->it
.cpu
.task
;
437 if (likely(p
!= NULL
)) {
438 read_lock(&tasklist_lock
);
439 if (unlikely(p
->sighand
== NULL
)) {
441 * We raced with the reaping of the task.
442 * The deletion should have cleared us off the list.
444 BUG_ON(!list_empty(&timer
->it
.cpu
.entry
));
446 spin_lock(&p
->sighand
->siglock
);
447 if (timer
->it
.cpu
.firing
)
450 list_del(&timer
->it
.cpu
.entry
);
451 spin_unlock(&p
->sighand
->siglock
);
453 read_unlock(&tasklist_lock
);
463 * Clean out CPU timers still ticking when a thread exited. The task
464 * pointer is cleared, and the expiry time is replaced with the residual
465 * time for later timer_gettime calls to return.
466 * This must be called with the siglock held.
468 static void cleanup_timers(struct list_head
*head
,
469 cputime_t utime
, cputime_t stime
,
470 unsigned long long sum_exec_runtime
)
472 struct cpu_timer_list
*timer
, *next
;
473 cputime_t ptime
= cputime_add(utime
, stime
);
475 list_for_each_entry_safe(timer
, next
, head
, entry
) {
476 list_del_init(&timer
->entry
);
477 if (cputime_lt(timer
->expires
.cpu
, ptime
)) {
478 timer
->expires
.cpu
= cputime_zero
;
480 timer
->expires
.cpu
= cputime_sub(timer
->expires
.cpu
,
486 list_for_each_entry_safe(timer
, next
, head
, entry
) {
487 list_del_init(&timer
->entry
);
488 if (cputime_lt(timer
->expires
.cpu
, utime
)) {
489 timer
->expires
.cpu
= cputime_zero
;
491 timer
->expires
.cpu
= cputime_sub(timer
->expires
.cpu
,
497 list_for_each_entry_safe(timer
, next
, head
, entry
) {
498 list_del_init(&timer
->entry
);
499 if (timer
->expires
.sched
< sum_exec_runtime
) {
500 timer
->expires
.sched
= 0;
502 timer
->expires
.sched
-= sum_exec_runtime
;
508 * These are both called with the siglock held, when the current thread
509 * is being reaped. When the final (leader) thread in the group is reaped,
510 * posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit.
512 void posix_cpu_timers_exit(struct task_struct
*tsk
)
514 cleanup_timers(tsk
->cpu_timers
,
515 tsk
->utime
, tsk
->stime
, tsk
->se
.sum_exec_runtime
);
518 void posix_cpu_timers_exit_group(struct task_struct
*tsk
)
520 struct signal_struct
*const sig
= tsk
->signal
;
522 cleanup_timers(tsk
->signal
->cpu_timers
,
523 cputime_add(tsk
->utime
, sig
->utime
),
524 cputime_add(tsk
->stime
, sig
->stime
),
525 tsk
->se
.sum_exec_runtime
+ sig
->sum_sched_runtime
);
528 static void clear_dead_task(struct k_itimer
*timer
, union cpu_time_count now
)
531 * That's all for this thread or process.
532 * We leave our residual in expires to be reported.
534 put_task_struct(timer
->it
.cpu
.task
);
535 timer
->it
.cpu
.task
= NULL
;
536 timer
->it
.cpu
.expires
= cpu_time_sub(timer
->it_clock
,
537 timer
->it
.cpu
.expires
,
541 static inline int expires_gt(cputime_t expires
, cputime_t new_exp
)
543 return cputime_eq(expires
, cputime_zero
) ||
544 cputime_gt(expires
, new_exp
);
548 * Insert the timer on the appropriate list before any timers that
549 * expire later. This must be called with the tasklist_lock held
550 * for reading, interrupts disabled and p->sighand->siglock taken.
552 static void arm_timer(struct k_itimer
*timer
)
554 struct task_struct
*p
= timer
->it
.cpu
.task
;
555 struct list_head
*head
, *listpos
;
556 struct task_cputime
*cputime_expires
;
557 struct cpu_timer_list
*const nt
= &timer
->it
.cpu
;
558 struct cpu_timer_list
*next
;
560 if (CPUCLOCK_PERTHREAD(timer
->it_clock
)) {
561 head
= p
->cpu_timers
;
562 cputime_expires
= &p
->cputime_expires
;
564 head
= p
->signal
->cpu_timers
;
565 cputime_expires
= &p
->signal
->cputime_expires
;
567 head
+= CPUCLOCK_WHICH(timer
->it_clock
);
570 list_for_each_entry(next
, head
, entry
) {
571 if (cpu_time_before(timer
->it_clock
, nt
->expires
, next
->expires
))
573 listpos
= &next
->entry
;
575 list_add(&nt
->entry
, listpos
);
577 if (listpos
== head
) {
578 union cpu_time_count
*exp
= &nt
->expires
;
581 * We are the new earliest-expiring POSIX 1.b timer, hence
582 * need to update expiration cache. Take into account that
583 * for process timers we share expiration cache with itimers
584 * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME.
587 switch (CPUCLOCK_WHICH(timer
->it_clock
)) {
589 if (expires_gt(cputime_expires
->prof_exp
, exp
->cpu
))
590 cputime_expires
->prof_exp
= exp
->cpu
;
593 if (expires_gt(cputime_expires
->virt_exp
, exp
->cpu
))
594 cputime_expires
->virt_exp
= exp
->cpu
;
597 if (cputime_expires
->sched_exp
== 0 ||
598 cputime_expires
->sched_exp
> exp
->sched
)
599 cputime_expires
->sched_exp
= exp
->sched
;
606 * The timer is locked, fire it and arrange for its reload.
608 static void cpu_timer_fire(struct k_itimer
*timer
)
610 if ((timer
->it_sigev_notify
& ~SIGEV_THREAD_ID
) == SIGEV_NONE
) {
612 * User don't want any signal.
614 timer
->it
.cpu
.expires
.sched
= 0;
615 } else if (unlikely(timer
->sigq
== NULL
)) {
617 * This a special case for clock_nanosleep,
618 * not a normal timer from sys_timer_create.
620 wake_up_process(timer
->it_process
);
621 timer
->it
.cpu
.expires
.sched
= 0;
622 } else if (timer
->it
.cpu
.incr
.sched
== 0) {
624 * One-shot timer. Clear it as soon as it's fired.
626 posix_timer_event(timer
, 0);
627 timer
->it
.cpu
.expires
.sched
= 0;
628 } else if (posix_timer_event(timer
, ++timer
->it_requeue_pending
)) {
630 * The signal did not get queued because the signal
631 * was ignored, so we won't get any callback to
632 * reload the timer. But we need to keep it
633 * ticking in case the signal is deliverable next time.
635 posix_cpu_timer_schedule(timer
);
640 * Sample a process (thread group) timer for the given group_leader task.
641 * Must be called with tasklist_lock held for reading.
643 static int cpu_timer_sample_group(const clockid_t which_clock
,
644 struct task_struct
*p
,
645 union cpu_time_count
*cpu
)
647 struct task_cputime cputime
;
649 thread_group_cputimer(p
, &cputime
);
650 switch (CPUCLOCK_WHICH(which_clock
)) {
654 cpu
->cpu
= cputime_add(cputime
.utime
, cputime
.stime
);
657 cpu
->cpu
= cputime
.utime
;
660 cpu
->sched
= cputime
.sum_exec_runtime
+ task_delta_exec(p
);
667 * Guts of sys_timer_settime for CPU timers.
668 * This is called with the timer locked and interrupts disabled.
669 * If we return TIMER_RETRY, it's necessary to release the timer's lock
670 * and try again. (This happens when the timer is in the middle of firing.)
672 static int posix_cpu_timer_set(struct k_itimer
*timer
, int flags
,
673 struct itimerspec
*new, struct itimerspec
*old
)
675 struct task_struct
*p
= timer
->it
.cpu
.task
;
676 union cpu_time_count old_expires
, new_expires
, old_incr
, val
;
679 if (unlikely(p
== NULL
)) {
681 * Timer refers to a dead task's clock.
686 new_expires
= timespec_to_sample(timer
->it_clock
, &new->it_value
);
688 read_lock(&tasklist_lock
);
690 * We need the tasklist_lock to protect against reaping that
691 * clears p->sighand. If p has just been reaped, we can no
692 * longer get any information about it at all.
694 if (unlikely(p
->sighand
== NULL
)) {
695 read_unlock(&tasklist_lock
);
697 timer
->it
.cpu
.task
= NULL
;
702 * Disarm any old timer after extracting its expiry time.
704 BUG_ON(!irqs_disabled());
707 old_incr
= timer
->it
.cpu
.incr
;
708 spin_lock(&p
->sighand
->siglock
);
709 old_expires
= timer
->it
.cpu
.expires
;
710 if (unlikely(timer
->it
.cpu
.firing
)) {
711 timer
->it
.cpu
.firing
= -1;
714 list_del_init(&timer
->it
.cpu
.entry
);
717 * We need to sample the current value to convert the new
718 * value from to relative and absolute, and to convert the
719 * old value from absolute to relative. To set a process
720 * timer, we need a sample to balance the thread expiry
721 * times (in arm_timer). With an absolute time, we must
722 * check if it's already passed. In short, we need a sample.
724 if (CPUCLOCK_PERTHREAD(timer
->it_clock
)) {
725 cpu_clock_sample(timer
->it_clock
, p
, &val
);
727 cpu_timer_sample_group(timer
->it_clock
, p
, &val
);
731 if (old_expires
.sched
== 0) {
732 old
->it_value
.tv_sec
= 0;
733 old
->it_value
.tv_nsec
= 0;
736 * Update the timer in case it has
737 * overrun already. If it has,
738 * we'll report it as having overrun
739 * and with the next reloaded timer
740 * already ticking, though we are
741 * swallowing that pending
742 * notification here to install the
745 bump_cpu_timer(timer
, val
);
746 if (cpu_time_before(timer
->it_clock
, val
,
747 timer
->it
.cpu
.expires
)) {
748 old_expires
= cpu_time_sub(
750 timer
->it
.cpu
.expires
, val
);
751 sample_to_timespec(timer
->it_clock
,
755 old
->it_value
.tv_nsec
= 1;
756 old
->it_value
.tv_sec
= 0;
763 * We are colliding with the timer actually firing.
764 * Punt after filling in the timer's old value, and
765 * disable this firing since we are already reporting
766 * it as an overrun (thanks to bump_cpu_timer above).
768 spin_unlock(&p
->sighand
->siglock
);
769 read_unlock(&tasklist_lock
);
773 if (new_expires
.sched
!= 0 && !(flags
& TIMER_ABSTIME
)) {
774 cpu_time_add(timer
->it_clock
, &new_expires
, val
);
778 * Install the new expiry time (or zero).
779 * For a timer with no notification action, we don't actually
780 * arm the timer (we'll just fake it for timer_gettime).
782 timer
->it
.cpu
.expires
= new_expires
;
783 if (new_expires
.sched
!= 0 &&
784 cpu_time_before(timer
->it_clock
, val
, new_expires
)) {
788 spin_unlock(&p
->sighand
->siglock
);
789 read_unlock(&tasklist_lock
);
792 * Install the new reload setting, and
793 * set up the signal and overrun bookkeeping.
795 timer
->it
.cpu
.incr
= timespec_to_sample(timer
->it_clock
,
799 * This acts as a modification timestamp for the timer,
800 * so any automatic reload attempt will punt on seeing
801 * that we have reset the timer manually.
803 timer
->it_requeue_pending
= (timer
->it_requeue_pending
+ 2) &
805 timer
->it_overrun_last
= 0;
806 timer
->it_overrun
= -1;
808 if (new_expires
.sched
!= 0 &&
809 !cpu_time_before(timer
->it_clock
, val
, new_expires
)) {
811 * The designated time already passed, so we notify
812 * immediately, even if the thread never runs to
813 * accumulate more time on this clock.
815 cpu_timer_fire(timer
);
821 sample_to_timespec(timer
->it_clock
,
822 old_incr
, &old
->it_interval
);
827 static void posix_cpu_timer_get(struct k_itimer
*timer
, struct itimerspec
*itp
)
829 union cpu_time_count now
;
830 struct task_struct
*p
= timer
->it
.cpu
.task
;
834 * Easy part: convert the reload time.
836 sample_to_timespec(timer
->it_clock
,
837 timer
->it
.cpu
.incr
, &itp
->it_interval
);
839 if (timer
->it
.cpu
.expires
.sched
== 0) { /* Timer not armed at all. */
840 itp
->it_value
.tv_sec
= itp
->it_value
.tv_nsec
= 0;
844 if (unlikely(p
== NULL
)) {
846 * This task already died and the timer will never fire.
847 * In this case, expires is actually the dead value.
850 sample_to_timespec(timer
->it_clock
, timer
->it
.cpu
.expires
,
856 * Sample the clock to take the difference with the expiry time.
858 if (CPUCLOCK_PERTHREAD(timer
->it_clock
)) {
859 cpu_clock_sample(timer
->it_clock
, p
, &now
);
860 clear_dead
= p
->exit_state
;
862 read_lock(&tasklist_lock
);
863 if (unlikely(p
->sighand
== NULL
)) {
865 * The process has been reaped.
866 * We can't even collect a sample any more.
867 * Call the timer disarmed, nothing else to do.
870 timer
->it
.cpu
.task
= NULL
;
871 timer
->it
.cpu
.expires
.sched
= 0;
872 read_unlock(&tasklist_lock
);
875 cpu_timer_sample_group(timer
->it_clock
, p
, &now
);
876 clear_dead
= (unlikely(p
->exit_state
) &&
877 thread_group_empty(p
));
879 read_unlock(&tasklist_lock
);
882 if (unlikely(clear_dead
)) {
884 * We've noticed that the thread is dead, but
885 * not yet reaped. Take this opportunity to
888 clear_dead_task(timer
, now
);
892 if (cpu_time_before(timer
->it_clock
, now
, timer
->it
.cpu
.expires
)) {
893 sample_to_timespec(timer
->it_clock
,
894 cpu_time_sub(timer
->it_clock
,
895 timer
->it
.cpu
.expires
, now
),
899 * The timer should have expired already, but the firing
900 * hasn't taken place yet. Say it's just about to expire.
902 itp
->it_value
.tv_nsec
= 1;
903 itp
->it_value
.tv_sec
= 0;
908 * Check for any per-thread CPU timers that have fired and move them off
909 * the tsk->cpu_timers[N] list onto the firing list. Here we update the
910 * tsk->it_*_expires values to reflect the remaining thread CPU timers.
912 static void check_thread_timers(struct task_struct
*tsk
,
913 struct list_head
*firing
)
916 struct list_head
*timers
= tsk
->cpu_timers
;
917 struct signal_struct
*const sig
= tsk
->signal
;
921 tsk
->cputime_expires
.prof_exp
= cputime_zero
;
922 while (!list_empty(timers
)) {
923 struct cpu_timer_list
*t
= list_first_entry(timers
,
924 struct cpu_timer_list
,
926 if (!--maxfire
|| cputime_lt(prof_ticks(tsk
), t
->expires
.cpu
)) {
927 tsk
->cputime_expires
.prof_exp
= t
->expires
.cpu
;
931 list_move_tail(&t
->entry
, firing
);
936 tsk
->cputime_expires
.virt_exp
= cputime_zero
;
937 while (!list_empty(timers
)) {
938 struct cpu_timer_list
*t
= list_first_entry(timers
,
939 struct cpu_timer_list
,
941 if (!--maxfire
|| cputime_lt(virt_ticks(tsk
), t
->expires
.cpu
)) {
942 tsk
->cputime_expires
.virt_exp
= t
->expires
.cpu
;
946 list_move_tail(&t
->entry
, firing
);
951 tsk
->cputime_expires
.sched_exp
= 0;
952 while (!list_empty(timers
)) {
953 struct cpu_timer_list
*t
= list_first_entry(timers
,
954 struct cpu_timer_list
,
956 if (!--maxfire
|| tsk
->se
.sum_exec_runtime
< t
->expires
.sched
) {
957 tsk
->cputime_expires
.sched_exp
= t
->expires
.sched
;
961 list_move_tail(&t
->entry
, firing
);
965 * Check for the special case thread timers.
967 soft
= ACCESS_ONCE(sig
->rlim
[RLIMIT_RTTIME
].rlim_cur
);
968 if (soft
!= RLIM_INFINITY
) {
970 ACCESS_ONCE(sig
->rlim
[RLIMIT_RTTIME
].rlim_max
);
972 if (hard
!= RLIM_INFINITY
&&
973 tsk
->rt
.timeout
> DIV_ROUND_UP(hard
, USEC_PER_SEC
/HZ
)) {
975 * At the hard limit, we just die.
976 * No need to calculate anything else now.
978 __group_send_sig_info(SIGKILL
, SEND_SIG_PRIV
, tsk
);
981 if (tsk
->rt
.timeout
> DIV_ROUND_UP(soft
, USEC_PER_SEC
/HZ
)) {
983 * At the soft limit, send a SIGXCPU every second.
986 soft
+= USEC_PER_SEC
;
987 sig
->rlim
[RLIMIT_RTTIME
].rlim_cur
= soft
;
990 "RT Watchdog Timeout: %s[%d]\n",
991 tsk
->comm
, task_pid_nr(tsk
));
992 __group_send_sig_info(SIGXCPU
, SEND_SIG_PRIV
, tsk
);
997 static void stop_process_timers(struct signal_struct
*sig
)
999 struct thread_group_cputimer
*cputimer
= &sig
->cputimer
;
1000 unsigned long flags
;
1002 spin_lock_irqsave(&cputimer
->lock
, flags
);
1003 cputimer
->running
= 0;
1004 spin_unlock_irqrestore(&cputimer
->lock
, flags
);
1007 static u32 onecputick
;
1009 static void check_cpu_itimer(struct task_struct
*tsk
, struct cpu_itimer
*it
,
1010 cputime_t
*expires
, cputime_t cur_time
, int signo
)
1012 if (cputime_eq(it
->expires
, cputime_zero
))
1015 if (cputime_ge(cur_time
, it
->expires
)) {
1016 if (!cputime_eq(it
->incr
, cputime_zero
)) {
1017 it
->expires
= cputime_add(it
->expires
, it
->incr
);
1018 it
->error
+= it
->incr_error
;
1019 if (it
->error
>= onecputick
) {
1020 it
->expires
= cputime_sub(it
->expires
,
1022 it
->error
-= onecputick
;
1025 it
->expires
= cputime_zero
;
1028 trace_itimer_expire(signo
== SIGPROF
?
1029 ITIMER_PROF
: ITIMER_VIRTUAL
,
1030 tsk
->signal
->leader_pid
, cur_time
);
1031 __group_send_sig_info(signo
, SEND_SIG_PRIV
, tsk
);
1034 if (!cputime_eq(it
->expires
, cputime_zero
) &&
1035 (cputime_eq(*expires
, cputime_zero
) ||
1036 cputime_lt(it
->expires
, *expires
))) {
1037 *expires
= it
->expires
;
1042 * task_cputime_zero - Check a task_cputime struct for all zero fields.
1044 * @cputime: The struct to compare.
1046 * Checks @cputime to see if all fields are zero. Returns true if all fields
1047 * are zero, false if any field is nonzero.
1049 static inline int task_cputime_zero(const struct task_cputime
*cputime
)
1051 if (cputime_eq(cputime
->utime
, cputime_zero
) &&
1052 cputime_eq(cputime
->stime
, cputime_zero
) &&
1053 cputime
->sum_exec_runtime
== 0)
1059 * Check for any per-thread CPU timers that have fired and move them
1060 * off the tsk->*_timers list onto the firing list. Per-thread timers
1061 * have already been taken off.
1063 static void check_process_timers(struct task_struct
*tsk
,
1064 struct list_head
*firing
)
1067 struct signal_struct
*const sig
= tsk
->signal
;
1068 cputime_t utime
, ptime
, virt_expires
, prof_expires
;
1069 unsigned long long sum_sched_runtime
, sched_expires
;
1070 struct list_head
*timers
= sig
->cpu_timers
;
1071 struct task_cputime cputime
;
1075 * Collect the current process totals.
1077 thread_group_cputimer(tsk
, &cputime
);
1078 utime
= cputime
.utime
;
1079 ptime
= cputime_add(utime
, cputime
.stime
);
1080 sum_sched_runtime
= cputime
.sum_exec_runtime
;
1082 prof_expires
= cputime_zero
;
1083 while (!list_empty(timers
)) {
1084 struct cpu_timer_list
*tl
= list_first_entry(timers
,
1085 struct cpu_timer_list
,
1087 if (!--maxfire
|| cputime_lt(ptime
, tl
->expires
.cpu
)) {
1088 prof_expires
= tl
->expires
.cpu
;
1092 list_move_tail(&tl
->entry
, firing
);
1097 virt_expires
= cputime_zero
;
1098 while (!list_empty(timers
)) {
1099 struct cpu_timer_list
*tl
= list_first_entry(timers
,
1100 struct cpu_timer_list
,
1102 if (!--maxfire
|| cputime_lt(utime
, tl
->expires
.cpu
)) {
1103 virt_expires
= tl
->expires
.cpu
;
1107 list_move_tail(&tl
->entry
, firing
);
1113 while (!list_empty(timers
)) {
1114 struct cpu_timer_list
*tl
= list_first_entry(timers
,
1115 struct cpu_timer_list
,
1117 if (!--maxfire
|| sum_sched_runtime
< tl
->expires
.sched
) {
1118 sched_expires
= tl
->expires
.sched
;
1122 list_move_tail(&tl
->entry
, firing
);
1126 * Check for the special case process timers.
1128 check_cpu_itimer(tsk
, &sig
->it
[CPUCLOCK_PROF
], &prof_expires
, ptime
,
1130 check_cpu_itimer(tsk
, &sig
->it
[CPUCLOCK_VIRT
], &virt_expires
, utime
,
1132 soft
= ACCESS_ONCE(sig
->rlim
[RLIMIT_CPU
].rlim_cur
);
1133 if (soft
!= RLIM_INFINITY
) {
1134 unsigned long psecs
= cputime_to_secs(ptime
);
1135 unsigned long hard
=
1136 ACCESS_ONCE(sig
->rlim
[RLIMIT_CPU
].rlim_max
);
1138 if (psecs
>= hard
) {
1140 * At the hard limit, we just die.
1141 * No need to calculate anything else now.
1143 __group_send_sig_info(SIGKILL
, SEND_SIG_PRIV
, tsk
);
1146 if (psecs
>= soft
) {
1148 * At the soft limit, send a SIGXCPU every second.
1150 __group_send_sig_info(SIGXCPU
, SEND_SIG_PRIV
, tsk
);
1153 sig
->rlim
[RLIMIT_CPU
].rlim_cur
= soft
;
1156 x
= secs_to_cputime(soft
);
1157 if (cputime_eq(prof_expires
, cputime_zero
) ||
1158 cputime_lt(x
, prof_expires
)) {
1163 sig
->cputime_expires
.prof_exp
= prof_expires
;
1164 sig
->cputime_expires
.virt_exp
= virt_expires
;
1165 sig
->cputime_expires
.sched_exp
= sched_expires
;
1166 if (task_cputime_zero(&sig
->cputime_expires
))
1167 stop_process_timers(sig
);
1171 * This is called from the signal code (via do_schedule_next_timer)
1172 * when the last timer signal was delivered and we have to reload the timer.
1174 void posix_cpu_timer_schedule(struct k_itimer
*timer
)
1176 struct task_struct
*p
= timer
->it
.cpu
.task
;
1177 union cpu_time_count now
;
1179 if (unlikely(p
== NULL
))
1181 * The task was cleaned up already, no future firings.
1186 * Fetch the current sample and update the timer's expiry time.
1188 if (CPUCLOCK_PERTHREAD(timer
->it_clock
)) {
1189 cpu_clock_sample(timer
->it_clock
, p
, &now
);
1190 bump_cpu_timer(timer
, now
);
1191 if (unlikely(p
->exit_state
)) {
1192 clear_dead_task(timer
, now
);
1195 read_lock(&tasklist_lock
); /* arm_timer needs it. */
1196 spin_lock(&p
->sighand
->siglock
);
1198 read_lock(&tasklist_lock
);
1199 if (unlikely(p
->sighand
== NULL
)) {
1201 * The process has been reaped.
1202 * We can't even collect a sample any more.
1205 timer
->it
.cpu
.task
= p
= NULL
;
1206 timer
->it
.cpu
.expires
.sched
= 0;
1208 } else if (unlikely(p
->exit_state
) && thread_group_empty(p
)) {
1210 * We've noticed that the thread is dead, but
1211 * not yet reaped. Take this opportunity to
1212 * drop our task ref.
1214 clear_dead_task(timer
, now
);
1217 spin_lock(&p
->sighand
->siglock
);
1218 cpu_timer_sample_group(timer
->it_clock
, p
, &now
);
1219 bump_cpu_timer(timer
, now
);
1220 /* Leave the tasklist_lock locked for the call below. */
1224 * Now re-arm for the new expiry time.
1226 BUG_ON(!irqs_disabled());
1228 spin_unlock(&p
->sighand
->siglock
);
1231 read_unlock(&tasklist_lock
);
1234 timer
->it_overrun_last
= timer
->it_overrun
;
1235 timer
->it_overrun
= -1;
1236 ++timer
->it_requeue_pending
;
1240 * task_cputime_expired - Compare two task_cputime entities.
1242 * @sample: The task_cputime structure to be checked for expiration.
1243 * @expires: Expiration times, against which @sample will be checked.
1245 * Checks @sample against @expires to see if any field of @sample has expired.
1246 * Returns true if any field of the former is greater than the corresponding
1247 * field of the latter if the latter field is set. Otherwise returns false.
1249 static inline int task_cputime_expired(const struct task_cputime
*sample
,
1250 const struct task_cputime
*expires
)
1252 if (!cputime_eq(expires
->utime
, cputime_zero
) &&
1253 cputime_ge(sample
->utime
, expires
->utime
))
1255 if (!cputime_eq(expires
->stime
, cputime_zero
) &&
1256 cputime_ge(cputime_add(sample
->utime
, sample
->stime
),
1259 if (expires
->sum_exec_runtime
!= 0 &&
1260 sample
->sum_exec_runtime
>= expires
->sum_exec_runtime
)
1266 * fastpath_timer_check - POSIX CPU timers fast path.
1268 * @tsk: The task (thread) being checked.
1270 * Check the task and thread group timers. If both are zero (there are no
1271 * timers set) return false. Otherwise snapshot the task and thread group
1272 * timers and compare them with the corresponding expiration times. Return
1273 * true if a timer has expired, else return false.
1275 static inline int fastpath_timer_check(struct task_struct
*tsk
)
1277 struct signal_struct
*sig
;
1279 if (!task_cputime_zero(&tsk
->cputime_expires
)) {
1280 struct task_cputime task_sample
= {
1281 .utime
= tsk
->utime
,
1282 .stime
= tsk
->stime
,
1283 .sum_exec_runtime
= tsk
->se
.sum_exec_runtime
1286 if (task_cputime_expired(&task_sample
, &tsk
->cputime_expires
))
1291 if (sig
->cputimer
.running
) {
1292 struct task_cputime group_sample
;
1294 spin_lock(&sig
->cputimer
.lock
);
1295 group_sample
= sig
->cputimer
.cputime
;
1296 spin_unlock(&sig
->cputimer
.lock
);
1298 if (task_cputime_expired(&group_sample
, &sig
->cputime_expires
))
1306 * This is called from the timer interrupt handler. The irq handler has
1307 * already updated our counts. We need to check if any timers fire now.
1308 * Interrupts are disabled.
1310 void run_posix_cpu_timers(struct task_struct
*tsk
)
1313 struct k_itimer
*timer
, *next
;
1314 unsigned long flags
;
1316 BUG_ON(!irqs_disabled());
1319 * The fast path checks that there are no expired thread or thread
1320 * group timers. If that's so, just return.
1322 if (!fastpath_timer_check(tsk
))
1325 if (!lock_task_sighand(tsk
, &flags
))
1328 * Here we take off tsk->signal->cpu_timers[N] and
1329 * tsk->cpu_timers[N] all the timers that are firing, and
1330 * put them on the firing list.
1332 check_thread_timers(tsk
, &firing
);
1334 * If there are any active process wide timers (POSIX 1.b, itimers,
1335 * RLIMIT_CPU) cputimer must be running.
1337 if (tsk
->signal
->cputimer
.running
)
1338 check_process_timers(tsk
, &firing
);
1341 * We must release these locks before taking any timer's lock.
1342 * There is a potential race with timer deletion here, as the
1343 * siglock now protects our private firing list. We have set
1344 * the firing flag in each timer, so that a deletion attempt
1345 * that gets the timer lock before we do will give it up and
1346 * spin until we've taken care of that timer below.
1348 unlock_task_sighand(tsk
, &flags
);
1351 * Now that all the timers on our list have the firing flag,
1352 * no one will touch their list entries but us. We'll take
1353 * each timer's lock before clearing its firing flag, so no
1354 * timer call will interfere.
1356 list_for_each_entry_safe(timer
, next
, &firing
, it
.cpu
.entry
) {
1359 spin_lock(&timer
->it_lock
);
1360 list_del_init(&timer
->it
.cpu
.entry
);
1361 cpu_firing
= timer
->it
.cpu
.firing
;
1362 timer
->it
.cpu
.firing
= 0;
1364 * The firing flag is -1 if we collided with a reset
1365 * of the timer, which already reported this
1366 * almost-firing as an overrun. So don't generate an event.
1368 if (likely(cpu_firing
>= 0))
1369 cpu_timer_fire(timer
);
1370 spin_unlock(&timer
->it_lock
);
1375 * Set one of the process-wide special case CPU timers or RLIMIT_CPU.
1376 * The tsk->sighand->siglock must be held by the caller.
1378 void set_process_cpu_timer(struct task_struct
*tsk
, unsigned int clock_idx
,
1379 cputime_t
*newval
, cputime_t
*oldval
)
1381 union cpu_time_count now
;
1383 BUG_ON(clock_idx
== CPUCLOCK_SCHED
);
1384 cpu_timer_sample_group(clock_idx
, tsk
, &now
);
1388 * We are setting itimer. The *oldval is absolute and we update
1389 * it to be relative, *newval argument is relative and we update
1390 * it to be absolute.
1392 if (!cputime_eq(*oldval
, cputime_zero
)) {
1393 if (cputime_le(*oldval
, now
.cpu
)) {
1394 /* Just about to fire. */
1395 *oldval
= cputime_one_jiffy
;
1397 *oldval
= cputime_sub(*oldval
, now
.cpu
);
1401 if (cputime_eq(*newval
, cputime_zero
))
1403 *newval
= cputime_add(*newval
, now
.cpu
);
1407 * Update expiration cache if we are the earliest timer, or eventually
1408 * RLIMIT_CPU limit is earlier than prof_exp cpu timer expire.
1410 switch (clock_idx
) {
1412 if (expires_gt(tsk
->signal
->cputime_expires
.prof_exp
, *newval
))
1413 tsk
->signal
->cputime_expires
.prof_exp
= *newval
;
1416 if (expires_gt(tsk
->signal
->cputime_expires
.virt_exp
, *newval
))
1417 tsk
->signal
->cputime_expires
.virt_exp
= *newval
;
1422 static int do_cpu_nanosleep(const clockid_t which_clock
, int flags
,
1423 struct timespec
*rqtp
, struct itimerspec
*it
)
1425 struct k_itimer timer
;
1429 * Set up a temporary timer and then wait for it to go off.
1431 memset(&timer
, 0, sizeof timer
);
1432 spin_lock_init(&timer
.it_lock
);
1433 timer
.it_clock
= which_clock
;
1434 timer
.it_overrun
= -1;
1435 error
= posix_cpu_timer_create(&timer
);
1436 timer
.it_process
= current
;
1438 static struct itimerspec zero_it
;
1440 memset(it
, 0, sizeof *it
);
1441 it
->it_value
= *rqtp
;
1443 spin_lock_irq(&timer
.it_lock
);
1444 error
= posix_cpu_timer_set(&timer
, flags
, it
, NULL
);
1446 spin_unlock_irq(&timer
.it_lock
);
1450 while (!signal_pending(current
)) {
1451 if (timer
.it
.cpu
.expires
.sched
== 0) {
1453 * Our timer fired and was reset.
1455 spin_unlock_irq(&timer
.it_lock
);
1460 * Block until cpu_timer_fire (or a signal) wakes us.
1462 __set_current_state(TASK_INTERRUPTIBLE
);
1463 spin_unlock_irq(&timer
.it_lock
);
1465 spin_lock_irq(&timer
.it_lock
);
1469 * We were interrupted by a signal.
1471 sample_to_timespec(which_clock
, timer
.it
.cpu
.expires
, rqtp
);
1472 posix_cpu_timer_set(&timer
, 0, &zero_it
, it
);
1473 spin_unlock_irq(&timer
.it_lock
);
1475 if ((it
->it_value
.tv_sec
| it
->it_value
.tv_nsec
) == 0) {
1477 * It actually did fire already.
1482 error
= -ERESTART_RESTARTBLOCK
;
1488 static long posix_cpu_nsleep_restart(struct restart_block
*restart_block
);
1490 static int posix_cpu_nsleep(const clockid_t which_clock
, int flags
,
1491 struct timespec
*rqtp
, struct timespec __user
*rmtp
)
1493 struct restart_block
*restart_block
=
1494 ¤t_thread_info()->restart_block
;
1495 struct itimerspec it
;
1499 * Diagnose required errors first.
1501 if (CPUCLOCK_PERTHREAD(which_clock
) &&
1502 (CPUCLOCK_PID(which_clock
) == 0 ||
1503 CPUCLOCK_PID(which_clock
) == current
->pid
))
1506 error
= do_cpu_nanosleep(which_clock
, flags
, rqtp
, &it
);
1508 if (error
== -ERESTART_RESTARTBLOCK
) {
1510 if (flags
& TIMER_ABSTIME
)
1511 return -ERESTARTNOHAND
;
1513 * Report back to the user the time still remaining.
1515 if (rmtp
&& copy_to_user(rmtp
, &it
.it_value
, sizeof *rmtp
))
1518 restart_block
->fn
= posix_cpu_nsleep_restart
;
1519 restart_block
->nanosleep
.clockid
= which_clock
;
1520 restart_block
->nanosleep
.rmtp
= rmtp
;
1521 restart_block
->nanosleep
.expires
= timespec_to_ns(rqtp
);
1526 static long posix_cpu_nsleep_restart(struct restart_block
*restart_block
)
1528 clockid_t which_clock
= restart_block
->nanosleep
.clockid
;
1530 struct itimerspec it
;
1533 t
= ns_to_timespec(restart_block
->nanosleep
.expires
);
1535 error
= do_cpu_nanosleep(which_clock
, TIMER_ABSTIME
, &t
, &it
);
1537 if (error
== -ERESTART_RESTARTBLOCK
) {
1538 struct timespec __user
*rmtp
= restart_block
->nanosleep
.rmtp
;
1540 * Report back to the user the time still remaining.
1542 if (rmtp
&& copy_to_user(rmtp
, &it
.it_value
, sizeof *rmtp
))
1545 restart_block
->nanosleep
.expires
= timespec_to_ns(&t
);
1551 #define PROCESS_CLOCK MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED)
1552 #define THREAD_CLOCK MAKE_THREAD_CPUCLOCK(0, CPUCLOCK_SCHED)
1554 static int process_cpu_clock_getres(const clockid_t which_clock
,
1555 struct timespec
*tp
)
1557 return posix_cpu_clock_getres(PROCESS_CLOCK
, tp
);
1559 static int process_cpu_clock_get(const clockid_t which_clock
,
1560 struct timespec
*tp
)
1562 return posix_cpu_clock_get(PROCESS_CLOCK
, tp
);
1564 static int process_cpu_timer_create(struct k_itimer
*timer
)
1566 timer
->it_clock
= PROCESS_CLOCK
;
1567 return posix_cpu_timer_create(timer
);
1569 static int process_cpu_nsleep(const clockid_t which_clock
, int flags
,
1570 struct timespec
*rqtp
,
1571 struct timespec __user
*rmtp
)
1573 return posix_cpu_nsleep(PROCESS_CLOCK
, flags
, rqtp
, rmtp
);
1575 static long process_cpu_nsleep_restart(struct restart_block
*restart_block
)
1579 static int thread_cpu_clock_getres(const clockid_t which_clock
,
1580 struct timespec
*tp
)
1582 return posix_cpu_clock_getres(THREAD_CLOCK
, tp
);
1584 static int thread_cpu_clock_get(const clockid_t which_clock
,
1585 struct timespec
*tp
)
1587 return posix_cpu_clock_get(THREAD_CLOCK
, tp
);
1589 static int thread_cpu_timer_create(struct k_itimer
*timer
)
1591 timer
->it_clock
= THREAD_CLOCK
;
1592 return posix_cpu_timer_create(timer
);
1595 struct k_clock clock_posix_cpu
= {
1596 .clock_getres
= posix_cpu_clock_getres
,
1597 .clock_set
= posix_cpu_clock_set
,
1598 .clock_get
= posix_cpu_clock_get
,
1599 .timer_create
= posix_cpu_timer_create
,
1600 .nsleep
= posix_cpu_nsleep
,
1601 .nsleep_restart
= posix_cpu_nsleep_restart
,
1602 .timer_set
= posix_cpu_timer_set
,
1603 .timer_del
= posix_cpu_timer_del
,
1604 .timer_get
= posix_cpu_timer_get
,
1607 static __init
int init_posix_cpu_timers(void)
1609 struct k_clock process
= {
1610 .clock_getres
= process_cpu_clock_getres
,
1611 .clock_get
= process_cpu_clock_get
,
1612 .timer_create
= process_cpu_timer_create
,
1613 .nsleep
= process_cpu_nsleep
,
1614 .nsleep_restart
= process_cpu_nsleep_restart
,
1616 struct k_clock thread
= {
1617 .clock_getres
= thread_cpu_clock_getres
,
1618 .clock_get
= thread_cpu_clock_get
,
1619 .timer_create
= thread_cpu_timer_create
,
1623 posix_timers_register_clock(CLOCK_PROCESS_CPUTIME_ID
, &process
);
1624 posix_timers_register_clock(CLOCK_THREAD_CPUTIME_ID
, &thread
);
1626 cputime_to_timespec(cputime_one_jiffy
, &ts
);
1627 onecputick
= ts
.tv_nsec
;
1628 WARN_ON(ts
.tv_sec
!= 0);
1632 __initcall(init_posix_cpu_timers
);