]> Git Repo - linux.git/blob - kernel/time/posix-cpu-timers.c
42f673974d71229c331ce646f4525ccb51faf79c
[linux.git] / kernel / time / posix-cpu-timers.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Implement CPU time clocks for the POSIX clock interface.
4  */
5
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
19 #include "posix-timers.h"
20
21 static void posix_cpu_timer_rearm(struct k_itimer *timer);
22
23 void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit)
24 {
25         posix_cputimers_init(pct);
26         if (cpu_limit != RLIM_INFINITY) {
27                 pct->bases[CPUCLOCK_PROF].nextevt = cpu_limit * NSEC_PER_SEC;
28                 pct->timers_active = true;
29         }
30 }
31
32 /*
33  * Called after updating RLIMIT_CPU to run cpu timer and update
34  * tsk->signal->posix_cputimers.bases[clock].nextevt expiration cache if
35  * necessary. Needs siglock protection since other code may update the
36  * expiration cache as well.
37  */
38 void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new)
39 {
40         u64 nsecs = rlim_new * NSEC_PER_SEC;
41
42         spin_lock_irq(&task->sighand->siglock);
43         set_process_cpu_timer(task, CPUCLOCK_PROF, &nsecs, NULL);
44         spin_unlock_irq(&task->sighand->siglock);
45 }
46
47 /*
48  * Functions for validating access to tasks.
49  */
50 static struct task_struct *lookup_task(const pid_t pid, bool thread,
51                                        bool gettime)
52 {
53         struct task_struct *p;
54
55         /*
56          * If the encoded PID is 0, then the timer is targeted at current
57          * or the process to which current belongs.
58          */
59         if (!pid)
60                 return thread ? current : current->group_leader;
61
62         p = find_task_by_vpid(pid);
63         if (!p)
64                 return p;
65
66         if (thread)
67                 return same_thread_group(p, current) ? p : NULL;
68
69         /*
70          * For clock_gettime(PROCESS) the task does not need to be
71          * the actual group leader. task->signal gives
72          * access to the group's clock.
73          */
74         if (gettime && (p == current))
75                 return p;
76
77         /*
78          * For processes require that p is group leader.
79          */
80         return thread_group_leader(p) ? p : NULL;
81 }
82
83 static struct task_struct *__get_task_for_clock(const clockid_t clock,
84                                                 bool gettime)
85 {
86         const bool thread = !!CPUCLOCK_PERTHREAD(clock);
87         const pid_t pid = CPUCLOCK_PID(clock);
88
89         if (CPUCLOCK_WHICH(clock) >= CPUCLOCK_MAX)
90                 return NULL;
91
92         return lookup_task(pid, thread, gettime);
93 }
94
95 static inline struct task_struct *get_task_for_clock(const clockid_t clock)
96 {
97         return __get_task_for_clock(clock, false);
98 }
99
100 static inline struct task_struct *get_task_for_clock_get(const clockid_t clock)
101 {
102         return __get_task_for_clock(clock, true);
103 }
104
105 static inline int validate_clock_permissions(const clockid_t clock)
106 {
107         int ret;
108
109         rcu_read_lock();
110         ret = __get_task_for_clock(clock, false) ? 0 : -EINVAL;
111         rcu_read_unlock();
112
113         return ret;
114 }
115
116 static inline enum pid_type clock_pid_type(const clockid_t clock)
117 {
118         return CPUCLOCK_PERTHREAD(clock) ? PIDTYPE_PID : PIDTYPE_TGID;
119 }
120
121 static inline struct task_struct *cpu_timer_task_rcu(struct k_itimer *timer)
122 {
123         return pid_task(timer->it.cpu.pid, clock_pid_type(timer->it_clock));
124 }
125
126 /*
127  * Update expiry time from increment, and increase overrun count,
128  * given the current clock sample.
129  */
130 static u64 bump_cpu_timer(struct k_itimer *timer, u64 now)
131 {
132         u64 delta, incr, expires = timer->it.cpu.node.expires;
133         int i;
134
135         if (!timer->it_interval)
136                 return expires;
137
138         if (now < expires)
139                 return expires;
140
141         incr = timer->it_interval;
142         delta = now + incr - expires;
143
144         /* Don't use (incr*2 < delta), incr*2 might overflow. */
145         for (i = 0; incr < delta - incr; i++)
146                 incr = incr << 1;
147
148         for (; i >= 0; incr >>= 1, i--) {
149                 if (delta < incr)
150                         continue;
151
152                 timer->it.cpu.node.expires += incr;
153                 timer->it_overrun += 1LL << i;
154                 delta -= incr;
155         }
156         return timer->it.cpu.node.expires;
157 }
158
159 /* Check whether all cache entries contain U64_MAX, i.e. eternal expiry time */
160 static inline bool expiry_cache_is_inactive(const struct posix_cputimers *pct)
161 {
162         return !(~pct->bases[CPUCLOCK_PROF].nextevt |
163                  ~pct->bases[CPUCLOCK_VIRT].nextevt |
164                  ~pct->bases[CPUCLOCK_SCHED].nextevt);
165 }
166
167 static int
168 posix_cpu_clock_getres(const clockid_t which_clock, struct timespec64 *tp)
169 {
170         int error = validate_clock_permissions(which_clock);
171
172         if (!error) {
173                 tp->tv_sec = 0;
174                 tp->tv_nsec = ((NSEC_PER_SEC + HZ - 1) / HZ);
175                 if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
176                         /*
177                          * If sched_clock is using a cycle counter, we
178                          * don't have any idea of its true resolution
179                          * exported, but it is much more than 1s/HZ.
180                          */
181                         tp->tv_nsec = 1;
182                 }
183         }
184         return error;
185 }
186
187 static int
188 posix_cpu_clock_set(const clockid_t clock, const struct timespec64 *tp)
189 {
190         int error = validate_clock_permissions(clock);
191
192         /*
193          * You can never reset a CPU clock, but we check for other errors
194          * in the call before failing with EPERM.
195          */
196         return error ? : -EPERM;
197 }
198
199 /*
200  * Sample a per-thread clock for the given task. clkid is validated.
201  */
202 static u64 cpu_clock_sample(const clockid_t clkid, struct task_struct *p)
203 {
204         u64 utime, stime;
205
206         if (clkid == CPUCLOCK_SCHED)
207                 return task_sched_runtime(p);
208
209         task_cputime(p, &utime, &stime);
210
211         switch (clkid) {
212         case CPUCLOCK_PROF:
213                 return utime + stime;
214         case CPUCLOCK_VIRT:
215                 return utime;
216         default:
217                 WARN_ON_ONCE(1);
218         }
219         return 0;
220 }
221
222 static inline void store_samples(u64 *samples, u64 stime, u64 utime, u64 rtime)
223 {
224         samples[CPUCLOCK_PROF] = stime + utime;
225         samples[CPUCLOCK_VIRT] = utime;
226         samples[CPUCLOCK_SCHED] = rtime;
227 }
228
229 static void task_sample_cputime(struct task_struct *p, u64 *samples)
230 {
231         u64 stime, utime;
232
233         task_cputime(p, &utime, &stime);
234         store_samples(samples, stime, utime, p->se.sum_exec_runtime);
235 }
236
237 static void proc_sample_cputime_atomic(struct task_cputime_atomic *at,
238                                        u64 *samples)
239 {
240         u64 stime, utime, rtime;
241
242         utime = atomic64_read(&at->utime);
243         stime = atomic64_read(&at->stime);
244         rtime = atomic64_read(&at->sum_exec_runtime);
245         store_samples(samples, stime, utime, rtime);
246 }
247
248 /*
249  * Set cputime to sum_cputime if sum_cputime > cputime. Use cmpxchg
250  * to avoid race conditions with concurrent updates to cputime.
251  */
252 static inline void __update_gt_cputime(atomic64_t *cputime, u64 sum_cputime)
253 {
254         u64 curr_cputime;
255 retry:
256         curr_cputime = atomic64_read(cputime);
257         if (sum_cputime > curr_cputime) {
258                 if (atomic64_cmpxchg(cputime, curr_cputime, sum_cputime) != curr_cputime)
259                         goto retry;
260         }
261 }
262
263 static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic,
264                               struct task_cputime *sum)
265 {
266         __update_gt_cputime(&cputime_atomic->utime, sum->utime);
267         __update_gt_cputime(&cputime_atomic->stime, sum->stime);
268         __update_gt_cputime(&cputime_atomic->sum_exec_runtime, sum->sum_exec_runtime);
269 }
270
271 /**
272  * thread_group_sample_cputime - Sample cputime for a given task
273  * @tsk:        Task for which cputime needs to be started
274  * @samples:    Storage for time samples
275  *
276  * Called from sys_getitimer() to calculate the expiry time of an active
277  * timer. That means group cputime accounting is already active. Called
278  * with task sighand lock held.
279  *
280  * Updates @times with an uptodate sample of the thread group cputimes.
281  */
282 void thread_group_sample_cputime(struct task_struct *tsk, u64 *samples)
283 {
284         struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
285         struct posix_cputimers *pct = &tsk->signal->posix_cputimers;
286
287         WARN_ON_ONCE(!pct->timers_active);
288
289         proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
290 }
291
292 /**
293  * thread_group_start_cputime - Start cputime and return a sample
294  * @tsk:        Task for which cputime needs to be started
295  * @samples:    Storage for time samples
296  *
297  * The thread group cputime accouting is avoided when there are no posix
298  * CPU timers armed. Before starting a timer it's required to check whether
299  * the time accounting is active. If not, a full update of the atomic
300  * accounting store needs to be done and the accounting enabled.
301  *
302  * Updates @times with an uptodate sample of the thread group cputimes.
303  */
304 static void thread_group_start_cputime(struct task_struct *tsk, u64 *samples)
305 {
306         struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
307         struct posix_cputimers *pct = &tsk->signal->posix_cputimers;
308
309         /* Check if cputimer isn't running. This is accessed without locking. */
310         if (!READ_ONCE(pct->timers_active)) {
311                 struct task_cputime sum;
312
313                 /*
314                  * The POSIX timer interface allows for absolute time expiry
315                  * values through the TIMER_ABSTIME flag, therefore we have
316                  * to synchronize the timer to the clock every time we start it.
317                  */
318                 thread_group_cputime(tsk, &sum);
319                 update_gt_cputime(&cputimer->cputime_atomic, &sum);
320
321                 /*
322                  * We're setting timers_active without a lock. Ensure this
323                  * only gets written to in one operation. We set it after
324                  * update_gt_cputime() as a small optimization, but
325                  * barriers are not required because update_gt_cputime()
326                  * can handle concurrent updates.
327                  */
328                 WRITE_ONCE(pct->timers_active, true);
329         }
330         proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
331 }
332
333 static void __thread_group_cputime(struct task_struct *tsk, u64 *samples)
334 {
335         struct task_cputime ct;
336
337         thread_group_cputime(tsk, &ct);
338         store_samples(samples, ct.stime, ct.utime, ct.sum_exec_runtime);
339 }
340
341 /*
342  * Sample a process (thread group) clock for the given task clkid. If the
343  * group's cputime accounting is already enabled, read the atomic
344  * store. Otherwise a full update is required.  clkid is already validated.
345  */
346 static u64 cpu_clock_sample_group(const clockid_t clkid, struct task_struct *p,
347                                   bool start)
348 {
349         struct thread_group_cputimer *cputimer = &p->signal->cputimer;
350         struct posix_cputimers *pct = &p->signal->posix_cputimers;
351         u64 samples[CPUCLOCK_MAX];
352
353         if (!READ_ONCE(pct->timers_active)) {
354                 if (start)
355                         thread_group_start_cputime(p, samples);
356                 else
357                         __thread_group_cputime(p, samples);
358         } else {
359                 proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
360         }
361
362         return samples[clkid];
363 }
364
365 static int posix_cpu_clock_get(const clockid_t clock, struct timespec64 *tp)
366 {
367         const clockid_t clkid = CPUCLOCK_WHICH(clock);
368         struct task_struct *tsk;
369         u64 t;
370
371         rcu_read_lock();
372         tsk = get_task_for_clock_get(clock);
373         if (!tsk) {
374                 rcu_read_unlock();
375                 return -EINVAL;
376         }
377
378         if (CPUCLOCK_PERTHREAD(clock))
379                 t = cpu_clock_sample(clkid, tsk);
380         else
381                 t = cpu_clock_sample_group(clkid, tsk, false);
382         rcu_read_unlock();
383
384         *tp = ns_to_timespec64(t);
385         return 0;
386 }
387
388 /*
389  * Validate the clockid_t for a new CPU-clock timer, and initialize the timer.
390  * This is called from sys_timer_create() and do_cpu_nanosleep() with the
391  * new timer already all-zeros initialized.
392  */
393 static int posix_cpu_timer_create(struct k_itimer *new_timer)
394 {
395         struct task_struct *p;
396
397         rcu_read_lock();
398         p = get_task_for_clock(new_timer->it_clock);
399         if (!p) {
400                 rcu_read_unlock();
401                 return -EINVAL;
402         }
403
404         new_timer->kclock = &clock_posix_cpu;
405         timerqueue_init(&new_timer->it.cpu.node);
406         new_timer->it.cpu.pid = get_task_pid(p, clock_pid_type(new_timer->it_clock));
407         rcu_read_unlock();
408         return 0;
409 }
410
411 /*
412  * Clean up a CPU-clock timer that is about to be destroyed.
413  * This is called from timer deletion with the timer already locked.
414  * If we return TIMER_RETRY, it's necessary to release the timer's lock
415  * and try again.  (This happens when the timer is in the middle of firing.)
416  */
417 static int posix_cpu_timer_del(struct k_itimer *timer)
418 {
419         struct cpu_timer *ctmr = &timer->it.cpu;
420         struct sighand_struct *sighand;
421         struct task_struct *p;
422         unsigned long flags;
423         int ret = 0;
424
425         rcu_read_lock();
426         p = cpu_timer_task_rcu(timer);
427         if (!p)
428                 goto out;
429
430         /*
431          * Protect against sighand release/switch in exit/exec and process/
432          * thread timer list entry concurrent read/writes.
433          */
434         sighand = lock_task_sighand(p, &flags);
435         if (unlikely(sighand == NULL)) {
436                 /*
437                  * This raced with the reaping of the task. The exit cleanup
438                  * should have removed this timer from the timer queue.
439                  */
440                 WARN_ON_ONCE(ctmr->head || timerqueue_node_queued(&ctmr->node));
441         } else {
442                 if (timer->it.cpu.firing)
443                         ret = TIMER_RETRY;
444                 else
445                         cpu_timer_dequeue(ctmr);
446
447                 unlock_task_sighand(p, &flags);
448         }
449
450 out:
451         rcu_read_unlock();
452         if (!ret)
453                 put_pid(ctmr->pid);
454
455         return ret;
456 }
457
458 static void cleanup_timerqueue(struct timerqueue_head *head)
459 {
460         struct timerqueue_node *node;
461         struct cpu_timer *ctmr;
462
463         while ((node = timerqueue_getnext(head))) {
464                 timerqueue_del(head, node);
465                 ctmr = container_of(node, struct cpu_timer, node);
466                 ctmr->head = NULL;
467         }
468 }
469
470 /*
471  * Clean out CPU timers which are still armed when a thread exits. The
472  * timers are only removed from the list. No other updates are done. The
473  * corresponding posix timers are still accessible, but cannot be rearmed.
474  *
475  * This must be called with the siglock held.
476  */
477 static void cleanup_timers(struct posix_cputimers *pct)
478 {
479         cleanup_timerqueue(&pct->bases[CPUCLOCK_PROF].tqhead);
480         cleanup_timerqueue(&pct->bases[CPUCLOCK_VIRT].tqhead);
481         cleanup_timerqueue(&pct->bases[CPUCLOCK_SCHED].tqhead);
482 }
483
484 /*
485  * These are both called with the siglock held, when the current thread
486  * is being reaped.  When the final (leader) thread in the group is reaped,
487  * posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit.
488  */
489 void posix_cpu_timers_exit(struct task_struct *tsk)
490 {
491         cleanup_timers(&tsk->posix_cputimers);
492 }
493 void posix_cpu_timers_exit_group(struct task_struct *tsk)
494 {
495         cleanup_timers(&tsk->signal->posix_cputimers);
496 }
497
498 /*
499  * Insert the timer on the appropriate list before any timers that
500  * expire later.  This must be called with the sighand lock held.
501  */
502 static void arm_timer(struct k_itimer *timer, struct task_struct *p)
503 {
504         int clkidx = CPUCLOCK_WHICH(timer->it_clock);
505         struct cpu_timer *ctmr = &timer->it.cpu;
506         u64 newexp = cpu_timer_getexpires(ctmr);
507         struct posix_cputimer_base *base;
508
509         if (CPUCLOCK_PERTHREAD(timer->it_clock))
510                 base = p->posix_cputimers.bases + clkidx;
511         else
512                 base = p->signal->posix_cputimers.bases + clkidx;
513
514         if (!cpu_timer_enqueue(&base->tqhead, ctmr))
515                 return;
516
517         /*
518          * We are the new earliest-expiring POSIX 1.b timer, hence
519          * need to update expiration cache. Take into account that
520          * for process timers we share expiration cache with itimers
521          * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME.
522          */
523         if (newexp < base->nextevt)
524                 base->nextevt = newexp;
525
526         if (CPUCLOCK_PERTHREAD(timer->it_clock))
527                 tick_dep_set_task(p, TICK_DEP_BIT_POSIX_TIMER);
528         else
529                 tick_dep_set_signal(p->signal, TICK_DEP_BIT_POSIX_TIMER);
530 }
531
532 /*
533  * The timer is locked, fire it and arrange for its reload.
534  */
535 static void cpu_timer_fire(struct k_itimer *timer)
536 {
537         struct cpu_timer *ctmr = &timer->it.cpu;
538
539         if ((timer->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
540                 /*
541                  * User don't want any signal.
542                  */
543                 cpu_timer_setexpires(ctmr, 0);
544         } else if (unlikely(timer->sigq == NULL)) {
545                 /*
546                  * This a special case for clock_nanosleep,
547                  * not a normal timer from sys_timer_create.
548                  */
549                 wake_up_process(timer->it_process);
550                 cpu_timer_setexpires(ctmr, 0);
551         } else if (!timer->it_interval) {
552                 /*
553                  * One-shot timer.  Clear it as soon as it's fired.
554                  */
555                 posix_timer_event(timer, 0);
556                 cpu_timer_setexpires(ctmr, 0);
557         } else if (posix_timer_event(timer, ++timer->it_requeue_pending)) {
558                 /*
559                  * The signal did not get queued because the signal
560                  * was ignored, so we won't get any callback to
561                  * reload the timer.  But we need to keep it
562                  * ticking in case the signal is deliverable next time.
563                  */
564                 posix_cpu_timer_rearm(timer);
565                 ++timer->it_requeue_pending;
566         }
567 }
568
569 /*
570  * Guts of sys_timer_settime for CPU timers.
571  * This is called with the timer locked and interrupts disabled.
572  * If we return TIMER_RETRY, it's necessary to release the timer's lock
573  * and try again.  (This happens when the timer is in the middle of firing.)
574  */
575 static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags,
576                                struct itimerspec64 *new, struct itimerspec64 *old)
577 {
578         clockid_t clkid = CPUCLOCK_WHICH(timer->it_clock);
579         u64 old_expires, new_expires, old_incr, val;
580         struct cpu_timer *ctmr = &timer->it.cpu;
581         struct sighand_struct *sighand;
582         struct task_struct *p;
583         unsigned long flags;
584         int ret = 0;
585
586         rcu_read_lock();
587         p = cpu_timer_task_rcu(timer);
588         if (!p) {
589                 /*
590                  * If p has just been reaped, we can no
591                  * longer get any information about it at all.
592                  */
593                 rcu_read_unlock();
594                 return -ESRCH;
595         }
596
597         /*
598          * Use the to_ktime conversion because that clamps the maximum
599          * value to KTIME_MAX and avoid multiplication overflows.
600          */
601         new_expires = ktime_to_ns(timespec64_to_ktime(new->it_value));
602
603         /*
604          * Protect against sighand release/switch in exit/exec and p->cpu_timers
605          * and p->signal->cpu_timers read/write in arm_timer()
606          */
607         sighand = lock_task_sighand(p, &flags);
608         /*
609          * If p has just been reaped, we can no
610          * longer get any information about it at all.
611          */
612         if (unlikely(sighand == NULL)) {
613                 rcu_read_unlock();
614                 return -ESRCH;
615         }
616
617         /*
618          * Disarm any old timer after extracting its expiry time.
619          */
620         old_incr = timer->it_interval;
621         old_expires = cpu_timer_getexpires(ctmr);
622
623         if (unlikely(timer->it.cpu.firing)) {
624                 timer->it.cpu.firing = -1;
625                 ret = TIMER_RETRY;
626         } else {
627                 cpu_timer_dequeue(ctmr);
628         }
629
630         /*
631          * We need to sample the current value to convert the new
632          * value from to relative and absolute, and to convert the
633          * old value from absolute to relative.  To set a process
634          * timer, we need a sample to balance the thread expiry
635          * times (in arm_timer).  With an absolute time, we must
636          * check if it's already passed.  In short, we need a sample.
637          */
638         if (CPUCLOCK_PERTHREAD(timer->it_clock))
639                 val = cpu_clock_sample(clkid, p);
640         else
641                 val = cpu_clock_sample_group(clkid, p, true);
642
643         if (old) {
644                 if (old_expires == 0) {
645                         old->it_value.tv_sec = 0;
646                         old->it_value.tv_nsec = 0;
647                 } else {
648                         /*
649                          * Update the timer in case it has overrun already.
650                          * If it has, we'll report it as having overrun and
651                          * with the next reloaded timer already ticking,
652                          * though we are swallowing that pending
653                          * notification here to install the new setting.
654                          */
655                         u64 exp = bump_cpu_timer(timer, val);
656
657                         if (val < exp) {
658                                 old_expires = exp - val;
659                                 old->it_value = ns_to_timespec64(old_expires);
660                         } else {
661                                 old->it_value.tv_nsec = 1;
662                                 old->it_value.tv_sec = 0;
663                         }
664                 }
665         }
666
667         if (unlikely(ret)) {
668                 /*
669                  * We are colliding with the timer actually firing.
670                  * Punt after filling in the timer's old value, and
671                  * disable this firing since we are already reporting
672                  * it as an overrun (thanks to bump_cpu_timer above).
673                  */
674                 unlock_task_sighand(p, &flags);
675                 goto out;
676         }
677
678         if (new_expires != 0 && !(timer_flags & TIMER_ABSTIME)) {
679                 new_expires += val;
680         }
681
682         /*
683          * Install the new expiry time (or zero).
684          * For a timer with no notification action, we don't actually
685          * arm the timer (we'll just fake it for timer_gettime).
686          */
687         cpu_timer_setexpires(ctmr, new_expires);
688         if (new_expires != 0 && val < new_expires) {
689                 arm_timer(timer, p);
690         }
691
692         unlock_task_sighand(p, &flags);
693         /*
694          * Install the new reload setting, and
695          * set up the signal and overrun bookkeeping.
696          */
697         timer->it_interval = timespec64_to_ktime(new->it_interval);
698
699         /*
700          * This acts as a modification timestamp for the timer,
701          * so any automatic reload attempt will punt on seeing
702          * that we have reset the timer manually.
703          */
704         timer->it_requeue_pending = (timer->it_requeue_pending + 2) &
705                 ~REQUEUE_PENDING;
706         timer->it_overrun_last = 0;
707         timer->it_overrun = -1;
708
709         if (new_expires != 0 && !(val < new_expires)) {
710                 /*
711                  * The designated time already passed, so we notify
712                  * immediately, even if the thread never runs to
713                  * accumulate more time on this clock.
714                  */
715                 cpu_timer_fire(timer);
716         }
717
718         ret = 0;
719  out:
720         rcu_read_unlock();
721         if (old)
722                 old->it_interval = ns_to_timespec64(old_incr);
723
724         return ret;
725 }
726
727 static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp)
728 {
729         clockid_t clkid = CPUCLOCK_WHICH(timer->it_clock);
730         struct cpu_timer *ctmr = &timer->it.cpu;
731         u64 now, expires = cpu_timer_getexpires(ctmr);
732         struct task_struct *p;
733
734         rcu_read_lock();
735         p = cpu_timer_task_rcu(timer);
736         if (!p)
737                 goto out;
738
739         /*
740          * Easy part: convert the reload time.
741          */
742         itp->it_interval = ktime_to_timespec64(timer->it_interval);
743
744         if (!expires)
745                 goto out;
746
747         /*
748          * Sample the clock to take the difference with the expiry time.
749          */
750         if (CPUCLOCK_PERTHREAD(timer->it_clock))
751                 now = cpu_clock_sample(clkid, p);
752         else
753                 now = cpu_clock_sample_group(clkid, p, false);
754
755         if (now < expires) {
756                 itp->it_value = ns_to_timespec64(expires - now);
757         } else {
758                 /*
759                  * The timer should have expired already, but the firing
760                  * hasn't taken place yet.  Say it's just about to expire.
761                  */
762                 itp->it_value.tv_nsec = 1;
763                 itp->it_value.tv_sec = 0;
764         }
765 out:
766         rcu_read_unlock();
767 }
768
769 #define MAX_COLLECTED   20
770
771 static u64 collect_timerqueue(struct timerqueue_head *head,
772                               struct list_head *firing, u64 now)
773 {
774         struct timerqueue_node *next;
775         int i = 0;
776
777         while ((next = timerqueue_getnext(head))) {
778                 struct cpu_timer *ctmr;
779                 u64 expires;
780
781                 ctmr = container_of(next, struct cpu_timer, node);
782                 expires = cpu_timer_getexpires(ctmr);
783                 /* Limit the number of timers to expire at once */
784                 if (++i == MAX_COLLECTED || now < expires)
785                         return expires;
786
787                 ctmr->firing = 1;
788                 cpu_timer_dequeue(ctmr);
789                 list_add_tail(&ctmr->elist, firing);
790         }
791
792         return U64_MAX;
793 }
794
795 static void collect_posix_cputimers(struct posix_cputimers *pct, u64 *samples,
796                                     struct list_head *firing)
797 {
798         struct posix_cputimer_base *base = pct->bases;
799         int i;
800
801         for (i = 0; i < CPUCLOCK_MAX; i++, base++) {
802                 base->nextevt = collect_timerqueue(&base->tqhead, firing,
803                                                     samples[i]);
804         }
805 }
806
807 static inline void check_dl_overrun(struct task_struct *tsk)
808 {
809         if (tsk->dl.dl_overrun) {
810                 tsk->dl.dl_overrun = 0;
811                 __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
812         }
813 }
814
815 static bool check_rlimit(u64 time, u64 limit, int signo, bool rt, bool hard)
816 {
817         if (time < limit)
818                 return false;
819
820         if (print_fatal_signals) {
821                 pr_info("%s Watchdog Timeout (%s): %s[%d]\n",
822                         rt ? "RT" : "CPU", hard ? "hard" : "soft",
823                         current->comm, task_pid_nr(current));
824         }
825         __group_send_sig_info(signo, SEND_SIG_PRIV, current);
826         return true;
827 }
828
829 /*
830  * Check for any per-thread CPU timers that have fired and move them off
831  * the tsk->cpu_timers[N] list onto the firing list.  Here we update the
832  * tsk->it_*_expires values to reflect the remaining thread CPU timers.
833  */
834 static void check_thread_timers(struct task_struct *tsk,
835                                 struct list_head *firing)
836 {
837         struct posix_cputimers *pct = &tsk->posix_cputimers;
838         u64 samples[CPUCLOCK_MAX];
839         unsigned long soft;
840
841         if (dl_task(tsk))
842                 check_dl_overrun(tsk);
843
844         if (expiry_cache_is_inactive(pct))
845                 return;
846
847         task_sample_cputime(tsk, samples);
848         collect_posix_cputimers(pct, samples, firing);
849
850         /*
851          * Check for the special case thread timers.
852          */
853         soft = task_rlimit(tsk, RLIMIT_RTTIME);
854         if (soft != RLIM_INFINITY) {
855                 /* Task RT timeout is accounted in jiffies. RTTIME is usec */
856                 unsigned long rttime = tsk->rt.timeout * (USEC_PER_SEC / HZ);
857                 unsigned long hard = task_rlimit_max(tsk, RLIMIT_RTTIME);
858
859                 /* At the hard limit, send SIGKILL. No further action. */
860                 if (hard != RLIM_INFINITY &&
861                     check_rlimit(rttime, hard, SIGKILL, true, true))
862                         return;
863
864                 /* At the soft limit, send a SIGXCPU every second */
865                 if (check_rlimit(rttime, soft, SIGXCPU, true, false)) {
866                         soft += USEC_PER_SEC;
867                         tsk->signal->rlim[RLIMIT_RTTIME].rlim_cur = soft;
868                 }
869         }
870
871         if (expiry_cache_is_inactive(pct))
872                 tick_dep_clear_task(tsk, TICK_DEP_BIT_POSIX_TIMER);
873 }
874
875 static inline void stop_process_timers(struct signal_struct *sig)
876 {
877         struct posix_cputimers *pct = &sig->posix_cputimers;
878
879         /* Turn off the active flag. This is done without locking. */
880         WRITE_ONCE(pct->timers_active, false);
881         tick_dep_clear_signal(sig, TICK_DEP_BIT_POSIX_TIMER);
882 }
883
884 static void check_cpu_itimer(struct task_struct *tsk, struct cpu_itimer *it,
885                              u64 *expires, u64 cur_time, int signo)
886 {
887         if (!it->expires)
888                 return;
889
890         if (cur_time >= it->expires) {
891                 if (it->incr)
892                         it->expires += it->incr;
893                 else
894                         it->expires = 0;
895
896                 trace_itimer_expire(signo == SIGPROF ?
897                                     ITIMER_PROF : ITIMER_VIRTUAL,
898                                     task_tgid(tsk), cur_time);
899                 __group_send_sig_info(signo, SEND_SIG_PRIV, tsk);
900         }
901
902         if (it->expires && it->expires < *expires)
903                 *expires = it->expires;
904 }
905
906 /*
907  * Check for any per-thread CPU timers that have fired and move them
908  * off the tsk->*_timers list onto the firing list.  Per-thread timers
909  * have already been taken off.
910  */
911 static void check_process_timers(struct task_struct *tsk,
912                                  struct list_head *firing)
913 {
914         struct signal_struct *const sig = tsk->signal;
915         struct posix_cputimers *pct = &sig->posix_cputimers;
916         u64 samples[CPUCLOCK_MAX];
917         unsigned long soft;
918
919         /*
920          * If there are no active process wide timers (POSIX 1.b, itimers,
921          * RLIMIT_CPU) nothing to check. Also skip the process wide timer
922          * processing when there is already another task handling them.
923          */
924         if (!READ_ONCE(pct->timers_active) || pct->expiry_active)
925                 return;
926
927         /*
928          * Signify that a thread is checking for process timers.
929          * Write access to this field is protected by the sighand lock.
930          */
931         pct->expiry_active = true;
932
933         /*
934          * Collect the current process totals. Group accounting is active
935          * so the sample can be taken directly.
936          */
937         proc_sample_cputime_atomic(&sig->cputimer.cputime_atomic, samples);
938         collect_posix_cputimers(pct, samples, firing);
939
940         /*
941          * Check for the special case process timers.
942          */
943         check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF],
944                          &pct->bases[CPUCLOCK_PROF].nextevt,
945                          samples[CPUCLOCK_PROF], SIGPROF);
946         check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT],
947                          &pct->bases[CPUCLOCK_VIRT].nextevt,
948                          samples[CPUCLOCK_VIRT], SIGVTALRM);
949
950         soft = task_rlimit(tsk, RLIMIT_CPU);
951         if (soft != RLIM_INFINITY) {
952                 /* RLIMIT_CPU is in seconds. Samples are nanoseconds */
953                 unsigned long hard = task_rlimit_max(tsk, RLIMIT_CPU);
954                 u64 ptime = samples[CPUCLOCK_PROF];
955                 u64 softns = (u64)soft * NSEC_PER_SEC;
956                 u64 hardns = (u64)hard * NSEC_PER_SEC;
957
958                 /* At the hard limit, send SIGKILL. No further action. */
959                 if (hard != RLIM_INFINITY &&
960                     check_rlimit(ptime, hardns, SIGKILL, false, true))
961                         return;
962
963                 /* At the soft limit, send a SIGXCPU every second */
964                 if (check_rlimit(ptime, softns, SIGXCPU, false, false)) {
965                         sig->rlim[RLIMIT_CPU].rlim_cur = soft + 1;
966                         softns += NSEC_PER_SEC;
967                 }
968
969                 /* Update the expiry cache */
970                 if (softns < pct->bases[CPUCLOCK_PROF].nextevt)
971                         pct->bases[CPUCLOCK_PROF].nextevt = softns;
972         }
973
974         if (expiry_cache_is_inactive(pct))
975                 stop_process_timers(sig);
976
977         pct->expiry_active = false;
978 }
979
980 /*
981  * This is called from the signal code (via posixtimer_rearm)
982  * when the last timer signal was delivered and we have to reload the timer.
983  */
984 static void posix_cpu_timer_rearm(struct k_itimer *timer)
985 {
986         clockid_t clkid = CPUCLOCK_WHICH(timer->it_clock);
987         struct task_struct *p;
988         struct sighand_struct *sighand;
989         unsigned long flags;
990         u64 now;
991
992         rcu_read_lock();
993         p = cpu_timer_task_rcu(timer);
994         if (!p)
995                 goto out;
996
997         /*
998          * Fetch the current sample and update the timer's expiry time.
999          */
1000         if (CPUCLOCK_PERTHREAD(timer->it_clock))
1001                 now = cpu_clock_sample(clkid, p);
1002         else
1003                 now = cpu_clock_sample_group(clkid, p, true);
1004
1005         bump_cpu_timer(timer, now);
1006
1007         /* Protect timer list r/w in arm_timer() */
1008         sighand = lock_task_sighand(p, &flags);
1009         if (unlikely(sighand == NULL))
1010                 goto out;
1011
1012         /*
1013          * Now re-arm for the new expiry time.
1014          */
1015         arm_timer(timer, p);
1016         unlock_task_sighand(p, &flags);
1017 out:
1018         rcu_read_unlock();
1019 }
1020
1021 /**
1022  * task_cputimers_expired - Check whether posix CPU timers are expired
1023  *
1024  * @samples:    Array of current samples for the CPUCLOCK clocks
1025  * @pct:        Pointer to a posix_cputimers container
1026  *
1027  * Returns true if any member of @samples is greater than the corresponding
1028  * member of @pct->bases[CLK].nextevt. False otherwise
1029  */
1030 static inline bool
1031 task_cputimers_expired(const u64 *samples, struct posix_cputimers *pct)
1032 {
1033         int i;
1034
1035         for (i = 0; i < CPUCLOCK_MAX; i++) {
1036                 if (samples[i] >= pct->bases[i].nextevt)
1037                         return true;
1038         }
1039         return false;
1040 }
1041
1042 /**
1043  * fastpath_timer_check - POSIX CPU timers fast path.
1044  *
1045  * @tsk:        The task (thread) being checked.
1046  *
1047  * Check the task and thread group timers.  If both are zero (there are no
1048  * timers set) return false.  Otherwise snapshot the task and thread group
1049  * timers and compare them with the corresponding expiration times.  Return
1050  * true if a timer has expired, else return false.
1051  */
1052 static inline bool fastpath_timer_check(struct task_struct *tsk)
1053 {
1054         struct posix_cputimers *pct = &tsk->posix_cputimers;
1055         struct signal_struct *sig;
1056
1057         if (!expiry_cache_is_inactive(pct)) {
1058                 u64 samples[CPUCLOCK_MAX];
1059
1060                 task_sample_cputime(tsk, samples);
1061                 if (task_cputimers_expired(samples, pct))
1062                         return true;
1063         }
1064
1065         sig = tsk->signal;
1066         pct = &sig->posix_cputimers;
1067         /*
1068          * Check if thread group timers expired when timers are active and
1069          * no other thread in the group is already handling expiry for
1070          * thread group cputimers. These fields are read without the
1071          * sighand lock. However, this is fine because this is meant to be
1072          * a fastpath heuristic to determine whether we should try to
1073          * acquire the sighand lock to handle timer expiry.
1074          *
1075          * In the worst case scenario, if concurrently timers_active is set
1076          * or expiry_active is cleared, but the current thread doesn't see
1077          * the change yet, the timer checks are delayed until the next
1078          * thread in the group gets a scheduler interrupt to handle the
1079          * timer. This isn't an issue in practice because these types of
1080          * delays with signals actually getting sent are expected.
1081          */
1082         if (READ_ONCE(pct->timers_active) && !READ_ONCE(pct->expiry_active)) {
1083                 u64 samples[CPUCLOCK_MAX];
1084
1085                 proc_sample_cputime_atomic(&sig->cputimer.cputime_atomic,
1086                                            samples);
1087
1088                 if (task_cputimers_expired(samples, pct))
1089                         return true;
1090         }
1091
1092         if (dl_task(tsk) && tsk->dl.dl_overrun)
1093                 return true;
1094
1095         return false;
1096 }
1097
1098 /*
1099  * This is called from the timer interrupt handler.  The irq handler has
1100  * already updated our counts.  We need to check if any timers fire now.
1101  * Interrupts are disabled.
1102  */
1103 void run_posix_cpu_timers(void)
1104 {
1105         struct task_struct *tsk = current;
1106         struct k_itimer *timer, *next;
1107         unsigned long flags;
1108         LIST_HEAD(firing);
1109
1110         lockdep_assert_irqs_disabled();
1111
1112         /*
1113          * The fast path checks that there are no expired thread or thread
1114          * group timers.  If that's so, just return.
1115          */
1116         if (!fastpath_timer_check(tsk))
1117                 return;
1118
1119         lockdep_posixtimer_enter();
1120         if (!lock_task_sighand(tsk, &flags)) {
1121                 lockdep_posixtimer_exit();
1122                 return;
1123         }
1124         /*
1125          * Here we take off tsk->signal->cpu_timers[N] and
1126          * tsk->cpu_timers[N] all the timers that are firing, and
1127          * put them on the firing list.
1128          */
1129         check_thread_timers(tsk, &firing);
1130
1131         check_process_timers(tsk, &firing);
1132
1133         /*
1134          * We must release these locks before taking any timer's lock.
1135          * There is a potential race with timer deletion here, as the
1136          * siglock now protects our private firing list.  We have set
1137          * the firing flag in each timer, so that a deletion attempt
1138          * that gets the timer lock before we do will give it up and
1139          * spin until we've taken care of that timer below.
1140          */
1141         unlock_task_sighand(tsk, &flags);
1142
1143         /*
1144          * Now that all the timers on our list have the firing flag,
1145          * no one will touch their list entries but us.  We'll take
1146          * each timer's lock before clearing its firing flag, so no
1147          * timer call will interfere.
1148          */
1149         list_for_each_entry_safe(timer, next, &firing, it.cpu.elist) {
1150                 int cpu_firing;
1151
1152                 spin_lock(&timer->it_lock);
1153                 list_del_init(&timer->it.cpu.elist);
1154                 cpu_firing = timer->it.cpu.firing;
1155                 timer->it.cpu.firing = 0;
1156                 /*
1157                  * The firing flag is -1 if we collided with a reset
1158                  * of the timer, which already reported this
1159                  * almost-firing as an overrun.  So don't generate an event.
1160                  */
1161                 if (likely(cpu_firing >= 0))
1162                         cpu_timer_fire(timer);
1163                 spin_unlock(&timer->it_lock);
1164         }
1165         lockdep_posixtimer_exit();
1166 }
1167
1168 /*
1169  * Set one of the process-wide special case CPU timers or RLIMIT_CPU.
1170  * The tsk->sighand->siglock must be held by the caller.
1171  */
1172 void set_process_cpu_timer(struct task_struct *tsk, unsigned int clkid,
1173                            u64 *newval, u64 *oldval)
1174 {
1175         u64 now, *nextevt;
1176
1177         if (WARN_ON_ONCE(clkid >= CPUCLOCK_SCHED))
1178                 return;
1179
1180         nextevt = &tsk->signal->posix_cputimers.bases[clkid].nextevt;
1181         now = cpu_clock_sample_group(clkid, tsk, true);
1182
1183         if (oldval) {
1184                 /*
1185                  * We are setting itimer. The *oldval is absolute and we update
1186                  * it to be relative, *newval argument is relative and we update
1187                  * it to be absolute.
1188                  */
1189                 if (*oldval) {
1190                         if (*oldval <= now) {
1191                                 /* Just about to fire. */
1192                                 *oldval = TICK_NSEC;
1193                         } else {
1194                                 *oldval -= now;
1195                         }
1196                 }
1197
1198                 if (!*newval)
1199                         return;
1200                 *newval += now;
1201         }
1202
1203         /*
1204          * Update expiration cache if this is the earliest timer. CPUCLOCK_PROF
1205          * expiry cache is also used by RLIMIT_CPU!.
1206          */
1207         if (*newval < *nextevt)
1208                 *nextevt = *newval;
1209
1210         tick_dep_set_signal(tsk->signal, TICK_DEP_BIT_POSIX_TIMER);
1211 }
1212
1213 static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
1214                             const struct timespec64 *rqtp)
1215 {
1216         struct itimerspec64 it;
1217         struct k_itimer timer;
1218         u64 expires;
1219         int error;
1220
1221         /*
1222          * Set up a temporary timer and then wait for it to go off.
1223          */
1224         memset(&timer, 0, sizeof timer);
1225         spin_lock_init(&timer.it_lock);
1226         timer.it_clock = which_clock;
1227         timer.it_overrun = -1;
1228         error = posix_cpu_timer_create(&timer);
1229         timer.it_process = current;
1230
1231         if (!error) {
1232                 static struct itimerspec64 zero_it;
1233                 struct restart_block *restart;
1234
1235                 memset(&it, 0, sizeof(it));
1236                 it.it_value = *rqtp;
1237
1238                 spin_lock_irq(&timer.it_lock);
1239                 error = posix_cpu_timer_set(&timer, flags, &it, NULL);
1240                 if (error) {
1241                         spin_unlock_irq(&timer.it_lock);
1242                         return error;
1243                 }
1244
1245                 while (!signal_pending(current)) {
1246                         if (!cpu_timer_getexpires(&timer.it.cpu)) {
1247                                 /*
1248                                  * Our timer fired and was reset, below
1249                                  * deletion can not fail.
1250                                  */
1251                                 posix_cpu_timer_del(&timer);
1252                                 spin_unlock_irq(&timer.it_lock);
1253                                 return 0;
1254                         }
1255
1256                         /*
1257                          * Block until cpu_timer_fire (or a signal) wakes us.
1258                          */
1259                         __set_current_state(TASK_INTERRUPTIBLE);
1260                         spin_unlock_irq(&timer.it_lock);
1261                         schedule();
1262                         spin_lock_irq(&timer.it_lock);
1263                 }
1264
1265                 /*
1266                  * We were interrupted by a signal.
1267                  */
1268                 expires = cpu_timer_getexpires(&timer.it.cpu);
1269                 error = posix_cpu_timer_set(&timer, 0, &zero_it, &it);
1270                 if (!error) {
1271                         /*
1272                          * Timer is now unarmed, deletion can not fail.
1273                          */
1274                         posix_cpu_timer_del(&timer);
1275                 }
1276                 spin_unlock_irq(&timer.it_lock);
1277
1278                 while (error == TIMER_RETRY) {
1279                         /*
1280                          * We need to handle case when timer was or is in the
1281                          * middle of firing. In other cases we already freed
1282                          * resources.
1283                          */
1284                         spin_lock_irq(&timer.it_lock);
1285                         error = posix_cpu_timer_del(&timer);
1286                         spin_unlock_irq(&timer.it_lock);
1287                 }
1288
1289                 if ((it.it_value.tv_sec | it.it_value.tv_nsec) == 0) {
1290                         /*
1291                          * It actually did fire already.
1292                          */
1293                         return 0;
1294                 }
1295
1296                 error = -ERESTART_RESTARTBLOCK;
1297                 /*
1298                  * Report back to the user the time still remaining.
1299                  */
1300                 restart = &current->restart_block;
1301                 restart->nanosleep.expires = expires;
1302                 if (restart->nanosleep.type != TT_NONE)
1303                         error = nanosleep_copyout(restart, &it.it_value);
1304         }
1305
1306         return error;
1307 }
1308
1309 static long posix_cpu_nsleep_restart(struct restart_block *restart_block);
1310
1311 static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
1312                             const struct timespec64 *rqtp)
1313 {
1314         struct restart_block *restart_block = &current->restart_block;
1315         int error;
1316
1317         /*
1318          * Diagnose required errors first.
1319          */
1320         if (CPUCLOCK_PERTHREAD(which_clock) &&
1321             (CPUCLOCK_PID(which_clock) == 0 ||
1322              CPUCLOCK_PID(which_clock) == task_pid_vnr(current)))
1323                 return -EINVAL;
1324
1325         error = do_cpu_nanosleep(which_clock, flags, rqtp);
1326
1327         if (error == -ERESTART_RESTARTBLOCK) {
1328
1329                 if (flags & TIMER_ABSTIME)
1330                         return -ERESTARTNOHAND;
1331
1332                 restart_block->fn = posix_cpu_nsleep_restart;
1333                 restart_block->nanosleep.clockid = which_clock;
1334         }
1335         return error;
1336 }
1337
1338 static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
1339 {
1340         clockid_t which_clock = restart_block->nanosleep.clockid;
1341         struct timespec64 t;
1342
1343         t = ns_to_timespec64(restart_block->nanosleep.expires);
1344
1345         return do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t);
1346 }
1347
1348 #define PROCESS_CLOCK   make_process_cpuclock(0, CPUCLOCK_SCHED)
1349 #define THREAD_CLOCK    make_thread_cpuclock(0, CPUCLOCK_SCHED)
1350
1351 static int process_cpu_clock_getres(const clockid_t which_clock,
1352                                     struct timespec64 *tp)
1353 {
1354         return posix_cpu_clock_getres(PROCESS_CLOCK, tp);
1355 }
1356 static int process_cpu_clock_get(const clockid_t which_clock,
1357                                  struct timespec64 *tp)
1358 {
1359         return posix_cpu_clock_get(PROCESS_CLOCK, tp);
1360 }
1361 static int process_cpu_timer_create(struct k_itimer *timer)
1362 {
1363         timer->it_clock = PROCESS_CLOCK;
1364         return posix_cpu_timer_create(timer);
1365 }
1366 static int process_cpu_nsleep(const clockid_t which_clock, int flags,
1367                               const struct timespec64 *rqtp)
1368 {
1369         return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp);
1370 }
1371 static int thread_cpu_clock_getres(const clockid_t which_clock,
1372                                    struct timespec64 *tp)
1373 {
1374         return posix_cpu_clock_getres(THREAD_CLOCK, tp);
1375 }
1376 static int thread_cpu_clock_get(const clockid_t which_clock,
1377                                 struct timespec64 *tp)
1378 {
1379         return posix_cpu_clock_get(THREAD_CLOCK, tp);
1380 }
1381 static int thread_cpu_timer_create(struct k_itimer *timer)
1382 {
1383         timer->it_clock = THREAD_CLOCK;
1384         return posix_cpu_timer_create(timer);
1385 }
1386
1387 const struct k_clock clock_posix_cpu = {
1388         .clock_getres           = posix_cpu_clock_getres,
1389         .clock_set              = posix_cpu_clock_set,
1390         .clock_get_timespec     = posix_cpu_clock_get,
1391         .timer_create           = posix_cpu_timer_create,
1392         .nsleep                 = posix_cpu_nsleep,
1393         .timer_set              = posix_cpu_timer_set,
1394         .timer_del              = posix_cpu_timer_del,
1395         .timer_get              = posix_cpu_timer_get,
1396         .timer_rearm            = posix_cpu_timer_rearm,
1397 };
1398
1399 const struct k_clock clock_process = {
1400         .clock_getres           = process_cpu_clock_getres,
1401         .clock_get_timespec     = process_cpu_clock_get,
1402         .timer_create           = process_cpu_timer_create,
1403         .nsleep                 = process_cpu_nsleep,
1404 };
1405
1406 const struct k_clock clock_thread = {
1407         .clock_getres           = thread_cpu_clock_getres,
1408         .clock_get_timespec     = thread_cpu_clock_get,
1409         .timer_create           = thread_cpu_timer_create,
1410 };
This page took 0.101242 seconds and 2 git commands to generate.