1
2
3
4
5
6
7
8
9
10
11
12#include <linux/mm.h>
13#include <linux/interrupt.h>
14#include <linux/slab.h>
15#include <linux/time.h>
16#include <linux/mutex.h>
17#include <linux/sched/task.h>
18
19#include <linux/uaccess.h>
20#include <linux/list.h>
21#include <linux/init.h>
22#include <linux/compiler.h>
23#include <linux/hash.h>
24#include <linux/posix-clock.h>
25#include <linux/posix-timers.h>
26#include <linux/syscalls.h>
27#include <linux/wait.h>
28#include <linux/workqueue.h>
29#include <linux/export.h>
30#include <linux/hashtable.h>
31#include <linux/compat.h>
32#include <linux/nospec.h>
33#include <linux/time_namespace.h>
34
35#include "timekeeping.h"
36#include "posix-timers.h"
37
38
39
40
41
42
43
44
45
46
47
48
49
50static struct kmem_cache *posix_timers_cache;
51
52static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
53static DEFINE_SPINLOCK(hash_lock);
54
55static const struct k_clock * const posix_clocks[];
56static const struct k_clock *clockid_to_kclock(const clockid_t id);
57static const struct k_clock clock_realtime, clock_monotonic;
58
59
60
61
62
63#if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
64 ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
65#error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
66#endif
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
106
107#define lock_timer(tid, flags) \
108({ struct k_itimer *__timr; \
109 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \
110 __timr; \
111})
112
113static int hash(struct signal_struct *sig, unsigned int nr)
114{
115 return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable));
116}
117
118static struct k_itimer *__posix_timers_find(struct hlist_head *head,
119 struct signal_struct *sig,
120 timer_t id)
121{
122 struct k_itimer *timer;
123
124 hlist_for_each_entry_rcu(timer, head, t_hash,
125 lockdep_is_held(&hash_lock)) {
126 if ((timer->it_signal == sig) && (timer->it_id == id))
127 return timer;
128 }
129 return NULL;
130}
131
132static struct k_itimer *posix_timer_by_id(timer_t id)
133{
134 struct signal_struct *sig = current->signal;
135 struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)];
136
137 return __posix_timers_find(head, sig, id);
138}
139
140static int posix_timer_add(struct k_itimer *timer)
141{
142 struct signal_struct *sig = current->signal;
143 int first_free_id = sig->posix_timer_id;
144 struct hlist_head *head;
145 int ret = -ENOENT;
146
147 do {
148 spin_lock(&hash_lock);
149 head = &posix_timers_hashtable[hash(sig, sig->posix_timer_id)];
150 if (!__posix_timers_find(head, sig, sig->posix_timer_id)) {
151 hlist_add_head_rcu(&timer->t_hash, head);
152 ret = sig->posix_timer_id;
153 }
154 if (++sig->posix_timer_id < 0)
155 sig->posix_timer_id = 0;
156 if ((sig->posix_timer_id == first_free_id) && (ret == -ENOENT))
157
158 ret = -EAGAIN;
159 spin_unlock(&hash_lock);
160 } while (ret == -ENOENT);
161 return ret;
162}
163
164static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
165{
166 spin_unlock_irqrestore(&timr->it_lock, flags);
167}
168
169
170static int posix_get_realtime_timespec(clockid_t which_clock, struct timespec64 *tp)
171{
172 ktime_get_real_ts64(tp);
173 return 0;
174}
175
176static ktime_t posix_get_realtime_ktime(clockid_t which_clock)
177{
178 return ktime_get_real();
179}
180
181
182static int posix_clock_realtime_set(const clockid_t which_clock,
183 const struct timespec64 *tp)
184{
185 return do_sys_settimeofday64(tp, NULL);
186}
187
188static int posix_clock_realtime_adj(const clockid_t which_clock,
189 struct __kernel_timex *t)
190{
191 return do_adjtimex(t);
192}
193
194
195
196
197static int posix_get_monotonic_timespec(clockid_t which_clock, struct timespec64 *tp)
198{
199 ktime_get_ts64(tp);
200 timens_add_monotonic(tp);
201 return 0;
202}
203
204static ktime_t posix_get_monotonic_ktime(clockid_t which_clock)
205{
206 return ktime_get();
207}
208
209
210
211
212static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec64 *tp)
213{
214 ktime_get_raw_ts64(tp);
215 timens_add_monotonic(tp);
216 return 0;
217}
218
219
220static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec64 *tp)
221{
222 ktime_get_coarse_real_ts64(tp);
223 return 0;
224}
225
226static int posix_get_monotonic_coarse(clockid_t which_clock,
227 struct timespec64 *tp)
228{
229 ktime_get_coarse_ts64(tp);
230 timens_add_monotonic(tp);
231 return 0;
232}
233
234static int posix_get_coarse_res(const clockid_t which_clock, struct timespec64 *tp)
235{
236 *tp = ktime_to_timespec64(KTIME_LOW_RES);
237 return 0;
238}
239
240static int posix_get_boottime_timespec(const clockid_t which_clock, struct timespec64 *tp)
241{
242 ktime_get_boottime_ts64(tp);
243 timens_add_boottime(tp);
244 return 0;
245}
246
247static ktime_t posix_get_boottime_ktime(const clockid_t which_clock)
248{
249 return ktime_get_boottime();
250}
251
252static int posix_get_tai_timespec(clockid_t which_clock, struct timespec64 *tp)
253{
254 ktime_get_clocktai_ts64(tp);
255 return 0;
256}
257
258static ktime_t posix_get_tai_ktime(clockid_t which_clock)
259{
260 return ktime_get_clocktai();
261}
262
263static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp)
264{
265 tp->tv_sec = 0;
266 tp->tv_nsec = hrtimer_resolution;
267 return 0;
268}
269
270
271
272
273static __init int init_posix_timers(void)
274{
275 posix_timers_cache = kmem_cache_create("posix_timers_cache",
276 sizeof(struct k_itimer), 0,
277 SLAB_PANIC | SLAB_ACCOUNT, NULL);
278 return 0;
279}
280__initcall(init_posix_timers);
281
282
283
284
285
286static inline int timer_overrun_to_int(struct k_itimer *timr, int baseval)
287{
288 s64 sum = timr->it_overrun_last + (s64)baseval;
289
290 return sum > (s64)INT_MAX ? INT_MAX : (int)sum;
291}
292
293static void common_hrtimer_rearm(struct k_itimer *timr)
294{
295 struct hrtimer *timer = &timr->it.real.timer;
296
297 timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(),
298 timr->it_interval);
299 hrtimer_restart(timer);
300}
301
302
303
304
305
306
307
308
309
310
311
312
313void posixtimer_rearm(struct kernel_siginfo *info)
314{
315 struct k_itimer *timr;
316 unsigned long flags;
317
318 timr = lock_timer(info->si_tid, &flags);
319 if (!timr)
320 return;
321
322 if (timr->it_interval && timr->it_requeue_pending == info->si_sys_private) {
323 timr->kclock->timer_rearm(timr);
324
325 timr->it_active = 1;
326 timr->it_overrun_last = timr->it_overrun;
327 timr->it_overrun = -1LL;
328 ++timr->it_requeue_pending;
329
330 info->si_overrun = timer_overrun_to_int(timr, info->si_overrun);
331 }
332
333 unlock_timer(timr, flags);
334}
335
336int posix_timer_event(struct k_itimer *timr, int si_private)
337{
338 enum pid_type type;
339 int ret;
340
341
342
343
344
345
346
347
348
349
350
351 timr->sigq->info.si_sys_private = si_private;
352
353 type = !(timr->it_sigev_notify & SIGEV_THREAD_ID) ? PIDTYPE_TGID : PIDTYPE_PID;
354 ret = send_sigqueue(timr->sigq, timr->it_pid, type);
355
356 return ret > 0;
357}
358
359
360
361
362
363
364
365
366static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
367{
368 struct k_itimer *timr;
369 unsigned long flags;
370 int si_private = 0;
371 enum hrtimer_restart ret = HRTIMER_NORESTART;
372
373 timr = container_of(timer, struct k_itimer, it.real.timer);
374 spin_lock_irqsave(&timr->it_lock, flags);
375
376 timr->it_active = 0;
377 if (timr->it_interval != 0)
378 si_private = ++timr->it_requeue_pending;
379
380 if (posix_timer_event(timr, si_private)) {
381
382
383
384
385
386 if (timr->it_interval != 0) {
387 ktime_t now = hrtimer_cb_get_time(timer);
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411#ifdef CONFIG_HIGH_RES_TIMERS
412 {
413 ktime_t kj = NSEC_PER_SEC / HZ;
414
415 if (timr->it_interval < kj)
416 now = ktime_add(now, kj);
417 }
418#endif
419 timr->it_overrun += hrtimer_forward(timer, now,
420 timr->it_interval);
421 ret = HRTIMER_RESTART;
422 ++timr->it_requeue_pending;
423 timr->it_active = 1;
424 }
425 }
426
427 unlock_timer(timr, flags);
428 return ret;
429}
430
431static struct pid *good_sigevent(sigevent_t * event)
432{
433 struct pid *pid = task_tgid(current);
434 struct task_struct *rtn;
435
436 switch (event->sigev_notify) {
437 case SIGEV_SIGNAL | SIGEV_THREAD_ID:
438 pid = find_vpid(event->sigev_notify_thread_id);
439 rtn = pid_task(pid, PIDTYPE_PID);
440 if (!rtn || !same_thread_group(rtn, current))
441 return NULL;
442 fallthrough;
443 case SIGEV_SIGNAL:
444 case SIGEV_THREAD:
445 if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX)
446 return NULL;
447 fallthrough;
448 case SIGEV_NONE:
449 return pid;
450 default:
451 return NULL;
452 }
453}
454
455static struct k_itimer * alloc_posix_timer(void)
456{
457 struct k_itimer *tmr;
458 tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
459 if (!tmr)
460 return tmr;
461 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
462 kmem_cache_free(posix_timers_cache, tmr);
463 return NULL;
464 }
465 clear_siginfo(&tmr->sigq->info);
466 return tmr;
467}
468
469static void k_itimer_rcu_free(struct rcu_head *head)
470{
471 struct k_itimer *tmr = container_of(head, struct k_itimer, rcu);
472
473 kmem_cache_free(posix_timers_cache, tmr);
474}
475
476#define IT_ID_SET 1
477#define IT_ID_NOT_SET 0
478static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
479{
480 if (it_id_set) {
481 unsigned long flags;
482 spin_lock_irqsave(&hash_lock, flags);
483 hlist_del_rcu(&tmr->t_hash);
484 spin_unlock_irqrestore(&hash_lock, flags);
485 }
486 put_pid(tmr->it_pid);
487 sigqueue_free(tmr->sigq);
488 call_rcu(&tmr->rcu, k_itimer_rcu_free);
489}
490
491static int common_timer_create(struct k_itimer *new_timer)
492{
493 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
494 return 0;
495}
496
497
498static int do_timer_create(clockid_t which_clock, struct sigevent *event,
499 timer_t __user *created_timer_id)
500{
501 const struct k_clock *kc = clockid_to_kclock(which_clock);
502 struct k_itimer *new_timer;
503 int error, new_timer_id;
504 int it_id_set = IT_ID_NOT_SET;
505
506 if (!kc)
507 return -EINVAL;
508 if (!kc->timer_create)
509 return -EOPNOTSUPP;
510
511 new_timer = alloc_posix_timer();
512 if (unlikely(!new_timer))
513 return -EAGAIN;
514
515 spin_lock_init(&new_timer->it_lock);
516 new_timer_id = posix_timer_add(new_timer);
517 if (new_timer_id < 0) {
518 error = new_timer_id;
519 goto out;
520 }
521
522 it_id_set = IT_ID_SET;
523 new_timer->it_id = (timer_t) new_timer_id;
524 new_timer->it_clock = which_clock;
525 new_timer->kclock = kc;
526 new_timer->it_overrun = -1LL;
527
528 if (event) {
529 rcu_read_lock();
530 new_timer->it_pid = get_pid(good_sigevent(event));
531 rcu_read_unlock();
532 if (!new_timer->it_pid) {
533 error = -EINVAL;
534 goto out;
535 }
536 new_timer->it_sigev_notify = event->sigev_notify;
537 new_timer->sigq->info.si_signo = event->sigev_signo;
538 new_timer->sigq->info.si_value = event->sigev_value;
539 } else {
540 new_timer->it_sigev_notify = SIGEV_SIGNAL;
541 new_timer->sigq->info.si_signo = SIGALRM;
542 memset(&new_timer->sigq->info.si_value, 0, sizeof(sigval_t));
543 new_timer->sigq->info.si_value.sival_int = new_timer->it_id;
544 new_timer->it_pid = get_pid(task_tgid(current));
545 }
546
547 new_timer->sigq->info.si_tid = new_timer->it_id;
548 new_timer->sigq->info.si_code = SI_TIMER;
549
550 if (copy_to_user(created_timer_id,
551 &new_timer_id, sizeof (new_timer_id))) {
552 error = -EFAULT;
553 goto out;
554 }
555
556 error = kc->timer_create(new_timer);
557 if (error)
558 goto out;
559
560 spin_lock_irq(¤t->sighand->siglock);
561 new_timer->it_signal = current->signal;
562 list_add(&new_timer->list, ¤t->signal->posix_timers);
563 spin_unlock_irq(¤t->sighand->siglock);
564
565 return 0;
566
567
568
569
570
571
572out:
573 release_posix_timer(new_timer, it_id_set);
574 return error;
575}
576
577SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
578 struct sigevent __user *, timer_event_spec,
579 timer_t __user *, created_timer_id)
580{
581 if (timer_event_spec) {
582 sigevent_t event;
583
584 if (copy_from_user(&event, timer_event_spec, sizeof (event)))
585 return -EFAULT;
586 return do_timer_create(which_clock, &event, created_timer_id);
587 }
588 return do_timer_create(which_clock, NULL, created_timer_id);
589}
590
591#ifdef CONFIG_COMPAT
592COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
593 struct compat_sigevent __user *, timer_event_spec,
594 timer_t __user *, created_timer_id)
595{
596 if (timer_event_spec) {
597 sigevent_t event;
598
599 if (get_compat_sigevent(&event, timer_event_spec))
600 return -EFAULT;
601 return do_timer_create(which_clock, &event, created_timer_id);
602 }
603 return do_timer_create(which_clock, NULL, created_timer_id);
604}
605#endif
606
607
608
609
610
611
612
613
614static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
615{
616 struct k_itimer *timr;
617
618
619
620
621
622 if ((unsigned long long)timer_id > INT_MAX)
623 return NULL;
624
625 rcu_read_lock();
626 timr = posix_timer_by_id(timer_id);
627 if (timr) {
628 spin_lock_irqsave(&timr->it_lock, *flags);
629 if (timr->it_signal == current->signal) {
630 rcu_read_unlock();
631 return timr;
632 }
633 spin_unlock_irqrestore(&timr->it_lock, *flags);
634 }
635 rcu_read_unlock();
636
637 return NULL;
638}
639
640static ktime_t common_hrtimer_remaining(struct k_itimer *timr, ktime_t now)
641{
642 struct hrtimer *timer = &timr->it.real.timer;
643
644 return __hrtimer_expires_remaining_adjusted(timer, now);
645}
646
647static s64 common_hrtimer_forward(struct k_itimer *timr, ktime_t now)
648{
649 struct hrtimer *timer = &timr->it.real.timer;
650
651 return hrtimer_forward(timer, now, timr->it_interval);
652}
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
671{
672 const struct k_clock *kc = timr->kclock;
673 ktime_t now, remaining, iv;
674 bool sig_none;
675
676 sig_none = timr->it_sigev_notify == SIGEV_NONE;
677 iv = timr->it_interval;
678
679
680 if (iv) {
681 cur_setting->it_interval = ktime_to_timespec64(iv);
682 } else if (!timr->it_active) {
683
684
685
686
687 if (!sig_none)
688 return;
689 }
690
691 now = kc->clock_get_ktime(timr->it_clock);
692
693
694
695
696
697 if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || sig_none))
698 timr->it_overrun += kc->timer_forward(timr, now);
699
700 remaining = kc->timer_remaining(timr, now);
701
702 if (remaining <= 0) {
703
704
705
706
707 if (!sig_none)
708 cur_setting->it_value.tv_nsec = 1;
709 } else {
710 cur_setting->it_value = ktime_to_timespec64(remaining);
711 }
712}
713
714
715static int do_timer_gettime(timer_t timer_id, struct itimerspec64 *setting)
716{
717 struct k_itimer *timr;
718 const struct k_clock *kc;
719 unsigned long flags;
720 int ret = 0;
721
722 timr = lock_timer(timer_id, &flags);
723 if (!timr)
724 return -EINVAL;
725
726 memset(setting, 0, sizeof(*setting));
727 kc = timr->kclock;
728 if (WARN_ON_ONCE(!kc || !kc->timer_get))
729 ret = -EINVAL;
730 else
731 kc->timer_get(timr, setting);
732
733 unlock_timer(timr, flags);
734 return ret;
735}
736
737
738SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
739 struct __kernel_itimerspec __user *, setting)
740{
741 struct itimerspec64 cur_setting;
742
743 int ret = do_timer_gettime(timer_id, &cur_setting);
744 if (!ret) {
745 if (put_itimerspec64(&cur_setting, setting))
746 ret = -EFAULT;
747 }
748 return ret;
749}
750
751#ifdef CONFIG_COMPAT_32BIT_TIME
752
753SYSCALL_DEFINE2(timer_gettime32, timer_t, timer_id,
754 struct old_itimerspec32 __user *, setting)
755{
756 struct itimerspec64 cur_setting;
757
758 int ret = do_timer_gettime(timer_id, &cur_setting);
759 if (!ret) {
760 if (put_old_itimerspec32(&cur_setting, setting))
761 ret = -EFAULT;
762 }
763 return ret;
764}
765
766#endif
767
768
769
770
771
772
773
774
775
776
777SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
778{
779 struct k_itimer *timr;
780 int overrun;
781 unsigned long flags;
782
783 timr = lock_timer(timer_id, &flags);
784 if (!timr)
785 return -EINVAL;
786
787 overrun = timer_overrun_to_int(timr, 0);
788 unlock_timer(timr, flags);
789
790 return overrun;
791}
792
793static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
794 bool absolute, bool sigev_none)
795{
796 struct hrtimer *timer = &timr->it.real.timer;
797 enum hrtimer_mode mode;
798
799 mode = absolute ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
800
801
802
803
804
805
806
807
808
809 if (timr->it_clock == CLOCK_REALTIME)
810 timr->kclock = absolute ? &clock_realtime : &clock_monotonic;
811
812 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
813 timr->it.real.timer.function = posix_timer_fn;
814
815 if (!absolute)
816 expires = ktime_add_safe(expires, timer->base->get_time());
817 hrtimer_set_expires(timer, expires);
818
819 if (!sigev_none)
820 hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
821}
822
823static int common_hrtimer_try_to_cancel(struct k_itimer *timr)
824{
825 return hrtimer_try_to_cancel(&timr->it.real.timer);
826}
827
828static void common_timer_wait_running(struct k_itimer *timer)
829{
830 hrtimer_cancel_wait_running(&timer->it.real.timer);
831}
832
833
834
835
836
837
838
839static struct k_itimer *timer_wait_running(struct k_itimer *timer,
840 unsigned long *flags)
841{
842 const struct k_clock *kc = READ_ONCE(timer->kclock);
843 timer_t timer_id = READ_ONCE(timer->it_id);
844
845
846 rcu_read_lock();
847 unlock_timer(timer, *flags);
848
849 if (!WARN_ON_ONCE(!kc->timer_wait_running))
850 kc->timer_wait_running(timer);
851
852 rcu_read_unlock();
853
854 return lock_timer(timer_id, flags);
855}
856
857
858int common_timer_set(struct k_itimer *timr, int flags,
859 struct itimerspec64 *new_setting,
860 struct itimerspec64 *old_setting)
861{
862 const struct k_clock *kc = timr->kclock;
863 bool sigev_none;
864 ktime_t expires;
865
866 if (old_setting)
867 common_timer_get(timr, old_setting);
868
869
870 timr->it_interval = 0;
871
872
873
874
875 if (kc->timer_try_to_cancel(timr) < 0)
876 return TIMER_RETRY;
877
878 timr->it_active = 0;
879 timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
880 ~REQUEUE_PENDING;
881 timr->it_overrun_last = 0;
882
883
884 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
885 return 0;
886
887 timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
888 expires = timespec64_to_ktime(new_setting->it_value);
889 if (flags & TIMER_ABSTIME)
890 expires = timens_ktime_to_host(timr->it_clock, expires);
891 sigev_none = timr->it_sigev_notify == SIGEV_NONE;
892
893 kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
894 timr->it_active = !sigev_none;
895 return 0;
896}
897
898static int do_timer_settime(timer_t timer_id, int tmr_flags,
899 struct itimerspec64 *new_spec64,
900 struct itimerspec64 *old_spec64)
901{
902 const struct k_clock *kc;
903 struct k_itimer *timr;
904 unsigned long flags;
905 int error = 0;
906
907 if (!timespec64_valid(&new_spec64->it_interval) ||
908 !timespec64_valid(&new_spec64->it_value))
909 return -EINVAL;
910
911 if (old_spec64)
912 memset(old_spec64, 0, sizeof(*old_spec64));
913
914 timr = lock_timer(timer_id, &flags);
915retry:
916 if (!timr)
917 return -EINVAL;
918
919 kc = timr->kclock;
920 if (WARN_ON_ONCE(!kc || !kc->timer_set))
921 error = -EINVAL;
922 else
923 error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64);
924
925 if (error == TIMER_RETRY) {
926
927 old_spec64 = NULL;
928
929 timr = timer_wait_running(timr, &flags);
930 goto retry;
931 }
932 unlock_timer(timr, flags);
933
934 return error;
935}
936
937
938SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
939 const struct __kernel_itimerspec __user *, new_setting,
940 struct __kernel_itimerspec __user *, old_setting)
941{
942 struct itimerspec64 new_spec, old_spec;
943 struct itimerspec64 *rtn = old_setting ? &old_spec : NULL;
944 int error = 0;
945
946 if (!new_setting)
947 return -EINVAL;
948
949 if (get_itimerspec64(&new_spec, new_setting))
950 return -EFAULT;
951
952 error = do_timer_settime(timer_id, flags, &new_spec, rtn);
953 if (!error && old_setting) {
954 if (put_itimerspec64(&old_spec, old_setting))
955 error = -EFAULT;
956 }
957 return error;
958}
959
960#ifdef CONFIG_COMPAT_32BIT_TIME
961SYSCALL_DEFINE4(timer_settime32, timer_t, timer_id, int, flags,
962 struct old_itimerspec32 __user *, new,
963 struct old_itimerspec32 __user *, old)
964{
965 struct itimerspec64 new_spec, old_spec;
966 struct itimerspec64 *rtn = old ? &old_spec : NULL;
967 int error = 0;
968
969 if (!new)
970 return -EINVAL;
971 if (get_old_itimerspec32(&new_spec, new))
972 return -EFAULT;
973
974 error = do_timer_settime(timer_id, flags, &new_spec, rtn);
975 if (!error && old) {
976 if (put_old_itimerspec32(&old_spec, old))
977 error = -EFAULT;
978 }
979 return error;
980}
981#endif
982
983int common_timer_del(struct k_itimer *timer)
984{
985 const struct k_clock *kc = timer->kclock;
986
987 timer->it_interval = 0;
988 if (kc->timer_try_to_cancel(timer) < 0)
989 return TIMER_RETRY;
990 timer->it_active = 0;
991 return 0;
992}
993
994static inline int timer_delete_hook(struct k_itimer *timer)
995{
996 const struct k_clock *kc = timer->kclock;
997
998 if (WARN_ON_ONCE(!kc || !kc->timer_del))
999 return -EINVAL;
1000 return kc->timer_del(timer);
1001}
1002
1003
1004SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
1005{
1006 struct k_itimer *timer;
1007 unsigned long flags;
1008
1009 timer = lock_timer(timer_id, &flags);
1010
1011retry_delete:
1012 if (!timer)
1013 return -EINVAL;
1014
1015 if (unlikely(timer_delete_hook(timer) == TIMER_RETRY)) {
1016
1017 timer = timer_wait_running(timer, &flags);
1018 goto retry_delete;
1019 }
1020
1021 spin_lock(¤t->sighand->siglock);
1022 list_del(&timer->list);
1023 spin_unlock(¤t->sighand->siglock);
1024
1025
1026
1027
1028 timer->it_signal = NULL;
1029
1030 unlock_timer(timer, flags);
1031 release_posix_timer(timer, IT_ID_SET);
1032 return 0;
1033}
1034
1035
1036
1037
1038static void itimer_delete(struct k_itimer *timer)
1039{
1040retry_delete:
1041 spin_lock_irq(&timer->it_lock);
1042
1043 if (timer_delete_hook(timer) == TIMER_RETRY) {
1044 spin_unlock_irq(&timer->it_lock);
1045 goto retry_delete;
1046 }
1047 list_del(&timer->list);
1048
1049 spin_unlock_irq(&timer->it_lock);
1050 release_posix_timer(timer, IT_ID_SET);
1051}
1052
1053
1054
1055
1056
1057void exit_itimers(struct signal_struct *sig)
1058{
1059 struct k_itimer *tmr;
1060
1061 while (!list_empty(&sig->posix_timers)) {
1062 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
1063 itimer_delete(tmr);
1064 }
1065}
1066
1067SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
1068 const struct __kernel_timespec __user *, tp)
1069{
1070 const struct k_clock *kc = clockid_to_kclock(which_clock);
1071 struct timespec64 new_tp;
1072
1073 if (!kc || !kc->clock_set)
1074 return -EINVAL;
1075
1076 if (get_timespec64(&new_tp, tp))
1077 return -EFAULT;
1078
1079 return kc->clock_set(which_clock, &new_tp);
1080}
1081
1082SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
1083 struct __kernel_timespec __user *, tp)
1084{
1085 const struct k_clock *kc = clockid_to_kclock(which_clock);
1086 struct timespec64 kernel_tp;
1087 int error;
1088
1089 if (!kc)
1090 return -EINVAL;
1091
1092 error = kc->clock_get_timespec(which_clock, &kernel_tp);
1093
1094 if (!error && put_timespec64(&kernel_tp, tp))
1095 error = -EFAULT;
1096
1097 return error;
1098}
1099
1100int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx)
1101{
1102 const struct k_clock *kc = clockid_to_kclock(which_clock);
1103
1104 if (!kc)
1105 return -EINVAL;
1106 if (!kc->clock_adj)
1107 return -EOPNOTSUPP;
1108
1109 return kc->clock_adj(which_clock, ktx);
1110}
1111
1112SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1113 struct __kernel_timex __user *, utx)
1114{
1115 struct __kernel_timex ktx;
1116 int err;
1117
1118 if (copy_from_user(&ktx, utx, sizeof(ktx)))
1119 return -EFAULT;
1120
1121 err = do_clock_adjtime(which_clock, &ktx);
1122
1123 if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
1124 return -EFAULT;
1125
1126 return err;
1127}
1128
1129SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
1130 struct __kernel_timespec __user *, tp)
1131{
1132 const struct k_clock *kc = clockid_to_kclock(which_clock);
1133 struct timespec64 rtn_tp;
1134 int error;
1135
1136 if (!kc)
1137 return -EINVAL;
1138
1139 error = kc->clock_getres(which_clock, &rtn_tp);
1140
1141 if (!error && tp && put_timespec64(&rtn_tp, tp))
1142 error = -EFAULT;
1143
1144 return error;
1145}
1146
1147#ifdef CONFIG_COMPAT_32BIT_TIME
1148
1149SYSCALL_DEFINE2(clock_settime32, clockid_t, which_clock,
1150 struct old_timespec32 __user *, tp)
1151{
1152 const struct k_clock *kc = clockid_to_kclock(which_clock);
1153 struct timespec64 ts;
1154
1155 if (!kc || !kc->clock_set)
1156 return -EINVAL;
1157
1158 if (get_old_timespec32(&ts, tp))
1159 return -EFAULT;
1160
1161 return kc->clock_set(which_clock, &ts);
1162}
1163
1164SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock,
1165 struct old_timespec32 __user *, tp)
1166{
1167 const struct k_clock *kc = clockid_to_kclock(which_clock);
1168 struct timespec64 ts;
1169 int err;
1170
1171 if (!kc)
1172 return -EINVAL;
1173
1174 err = kc->clock_get_timespec(which_clock, &ts);
1175
1176 if (!err && put_old_timespec32(&ts, tp))
1177 err = -EFAULT;
1178
1179 return err;
1180}
1181
1182SYSCALL_DEFINE2(clock_adjtime32, clockid_t, which_clock,
1183 struct old_timex32 __user *, utp)
1184{
1185 struct __kernel_timex ktx;
1186 int err;
1187
1188 err = get_old_timex32(&ktx, utp);
1189 if (err)
1190 return err;
1191
1192 err = do_clock_adjtime(which_clock, &ktx);
1193
1194 if (err >= 0 && put_old_timex32(utp, &ktx))
1195 return -EFAULT;
1196
1197 return err;
1198}
1199
1200SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock,
1201 struct old_timespec32 __user *, tp)
1202{
1203 const struct k_clock *kc = clockid_to_kclock(which_clock);
1204 struct timespec64 ts;
1205 int err;
1206
1207 if (!kc)
1208 return -EINVAL;
1209
1210 err = kc->clock_getres(which_clock, &ts);
1211 if (!err && tp && put_old_timespec32(&ts, tp))
1212 return -EFAULT;
1213
1214 return err;
1215}
1216
1217#endif
1218
1219
1220
1221
1222static int common_nsleep(const clockid_t which_clock, int flags,
1223 const struct timespec64 *rqtp)
1224{
1225 ktime_t texp = timespec64_to_ktime(*rqtp);
1226
1227 return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
1228 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1229 which_clock);
1230}
1231
1232static int common_nsleep_timens(const clockid_t which_clock, int flags,
1233 const struct timespec64 *rqtp)
1234{
1235 ktime_t texp = timespec64_to_ktime(*rqtp);
1236
1237 if (flags & TIMER_ABSTIME)
1238 texp = timens_ktime_to_host(which_clock, texp);
1239
1240 return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
1241 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1242 which_clock);
1243}
1244
1245SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
1246 const struct __kernel_timespec __user *, rqtp,
1247 struct __kernel_timespec __user *, rmtp)
1248{
1249 const struct k_clock *kc = clockid_to_kclock(which_clock);
1250 struct timespec64 t;
1251
1252 if (!kc)
1253 return -EINVAL;
1254 if (!kc->nsleep)
1255 return -EOPNOTSUPP;
1256
1257 if (get_timespec64(&t, rqtp))
1258 return -EFAULT;
1259
1260 if (!timespec64_valid(&t))
1261 return -EINVAL;
1262 if (flags & TIMER_ABSTIME)
1263 rmtp = NULL;
1264 current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
1265 current->restart_block.nanosleep.rmtp = rmtp;
1266
1267 return kc->nsleep(which_clock, flags, &t);
1268}
1269
1270#ifdef CONFIG_COMPAT_32BIT_TIME
1271
1272SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags,
1273 struct old_timespec32 __user *, rqtp,
1274 struct old_timespec32 __user *, rmtp)
1275{
1276 const struct k_clock *kc = clockid_to_kclock(which_clock);
1277 struct timespec64 t;
1278
1279 if (!kc)
1280 return -EINVAL;
1281 if (!kc->nsleep)
1282 return -EOPNOTSUPP;
1283
1284 if (get_old_timespec32(&t, rqtp))
1285 return -EFAULT;
1286
1287 if (!timespec64_valid(&t))
1288 return -EINVAL;
1289 if (flags & TIMER_ABSTIME)
1290 rmtp = NULL;
1291 current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
1292 current->restart_block.nanosleep.compat_rmtp = rmtp;
1293
1294 return kc->nsleep(which_clock, flags, &t);
1295}
1296
1297#endif
1298
1299static const struct k_clock clock_realtime = {
1300 .clock_getres = posix_get_hrtimer_res,
1301 .clock_get_timespec = posix_get_realtime_timespec,
1302 .clock_get_ktime = posix_get_realtime_ktime,
1303 .clock_set = posix_clock_realtime_set,
1304 .clock_adj = posix_clock_realtime_adj,
1305 .nsleep = common_nsleep,
1306 .timer_create = common_timer_create,
1307 .timer_set = common_timer_set,
1308 .timer_get = common_timer_get,
1309 .timer_del = common_timer_del,
1310 .timer_rearm = common_hrtimer_rearm,
1311 .timer_forward = common_hrtimer_forward,
1312 .timer_remaining = common_hrtimer_remaining,
1313 .timer_try_to_cancel = common_hrtimer_try_to_cancel,
1314 .timer_wait_running = common_timer_wait_running,
1315 .timer_arm = common_hrtimer_arm,
1316};
1317
1318static const struct k_clock clock_monotonic = {
1319 .clock_getres = posix_get_hrtimer_res,
1320 .clock_get_timespec = posix_get_monotonic_timespec,
1321 .clock_get_ktime = posix_get_monotonic_ktime,
1322 .nsleep = common_nsleep_timens,
1323 .timer_create = common_timer_create,
1324 .timer_set = common_timer_set,
1325 .timer_get = common_timer_get,
1326 .timer_del = common_timer_del,
1327 .timer_rearm = common_hrtimer_rearm,
1328 .timer_forward = common_hrtimer_forward,
1329 .timer_remaining = common_hrtimer_remaining,
1330 .timer_try_to_cancel = common_hrtimer_try_to_cancel,
1331 .timer_wait_running = common_timer_wait_running,
1332 .timer_arm = common_hrtimer_arm,
1333};
1334
1335static const struct k_clock clock_monotonic_raw = {
1336 .clock_getres = posix_get_hrtimer_res,
1337 .clock_get_timespec = posix_get_monotonic_raw,
1338};
1339
1340static const struct k_clock clock_realtime_coarse = {
1341 .clock_getres = posix_get_coarse_res,
1342 .clock_get_timespec = posix_get_realtime_coarse,
1343};
1344
1345static const struct k_clock clock_monotonic_coarse = {
1346 .clock_getres = posix_get_coarse_res,
1347 .clock_get_timespec = posix_get_monotonic_coarse,
1348};
1349
1350static const struct k_clock clock_tai = {
1351 .clock_getres = posix_get_hrtimer_res,
1352 .clock_get_ktime = posix_get_tai_ktime,
1353 .clock_get_timespec = posix_get_tai_timespec,
1354 .nsleep = common_nsleep,
1355 .timer_create = common_timer_create,
1356 .timer_set = common_timer_set,
1357 .timer_get = common_timer_get,
1358 .timer_del = common_timer_del,
1359 .timer_rearm = common_hrtimer_rearm,
1360 .timer_forward = common_hrtimer_forward,
1361 .timer_remaining = common_hrtimer_remaining,
1362 .timer_try_to_cancel = common_hrtimer_try_to_cancel,
1363 .timer_wait_running = common_timer_wait_running,
1364 .timer_arm = common_hrtimer_arm,
1365};
1366
1367static const struct k_clock clock_boottime = {
1368 .clock_getres = posix_get_hrtimer_res,
1369 .clock_get_ktime = posix_get_boottime_ktime,
1370 .clock_get_timespec = posix_get_boottime_timespec,
1371 .nsleep = common_nsleep_timens,
1372 .timer_create = common_timer_create,
1373 .timer_set = common_timer_set,
1374 .timer_get = common_timer_get,
1375 .timer_del = common_timer_del,
1376 .timer_rearm = common_hrtimer_rearm,
1377 .timer_forward = common_hrtimer_forward,
1378 .timer_remaining = common_hrtimer_remaining,
1379 .timer_try_to_cancel = common_hrtimer_try_to_cancel,
1380 .timer_wait_running = common_timer_wait_running,
1381 .timer_arm = common_hrtimer_arm,
1382};
1383
1384static const struct k_clock * const posix_clocks[] = {
1385 [CLOCK_REALTIME] = &clock_realtime,
1386 [CLOCK_MONOTONIC] = &clock_monotonic,
1387 [CLOCK_PROCESS_CPUTIME_ID] = &clock_process,
1388 [CLOCK_THREAD_CPUTIME_ID] = &clock_thread,
1389 [CLOCK_MONOTONIC_RAW] = &clock_monotonic_raw,
1390 [CLOCK_REALTIME_COARSE] = &clock_realtime_coarse,
1391 [CLOCK_MONOTONIC_COARSE] = &clock_monotonic_coarse,
1392 [CLOCK_BOOTTIME] = &clock_boottime,
1393 [CLOCK_REALTIME_ALARM] = &alarm_clock,
1394 [CLOCK_BOOTTIME_ALARM] = &alarm_clock,
1395 [CLOCK_TAI] = &clock_tai,
1396};
1397
1398static const struct k_clock *clockid_to_kclock(const clockid_t id)
1399{
1400 clockid_t idx = id;
1401
1402 if (id < 0) {
1403 return (id & CLOCKFD_MASK) == CLOCKFD ?
1404 &clock_posix_dynamic : &clock_posix_cpu;
1405 }
1406
1407 if (id >= ARRAY_SIZE(posix_clocks))
1408 return NULL;
1409
1410 return posix_clocks[array_index_nospec(idx, ARRAY_SIZE(posix_clocks))];
1411}
1412