1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/mm.h>
34#include <linux/interrupt.h>
35#include <linux/slab.h>
36#include <linux/time.h>
37#include <linux/mutex.h>
38
39#include <asm/uaccess.h>
40#include <linux/list.h>
41#include <linux/init.h>
42#include <linux/compiler.h>
43#include <linux/hash.h>
44#include <linux/posix-clock.h>
45#include <linux/posix-timers.h>
46#include <linux/syscalls.h>
47#include <linux/wait.h>
48#include <linux/workqueue.h>
49#include <linux/export.h>
50#include <linux/hashtable.h>
51
52#include "timekeeping.h"
53
54
55
56
57
58
59
60
61
62
63
64
65
66static struct kmem_cache *posix_timers_cache;
67
68static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
69static DEFINE_SPINLOCK(hash_lock);
70
71
72
73
74
75#if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
76 ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
77#error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
78#endif
79
80
81
82
83#ifndef ENOTSUP
84# define ENANOSLEEP_NOTSUP EOPNOTSUPP
85#else
86# define ENANOSLEEP_NOTSUP ENOTSUP
87#endif
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127static struct k_clock posix_clocks[MAX_CLOCKS];
128
129
130
131
132static int common_nsleep(const clockid_t, int flags, struct timespec *t,
133 struct timespec __user *rmtp);
134static int common_timer_create(struct k_itimer *new_timer);
135static void common_timer_get(struct k_itimer *, struct itimerspec *);
136static int common_timer_set(struct k_itimer *, int,
137 struct itimerspec *, struct itimerspec *);
138static int common_timer_del(struct k_itimer *timer);
139
140static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
141
142static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
143
144#define lock_timer(tid, flags) \
145({ struct k_itimer *__timr; \
146 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \
147 __timr; \
148})
149
150static int hash(struct signal_struct *sig, unsigned int nr)
151{
152 return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable));
153}
154
155static struct k_itimer *__posix_timers_find(struct hlist_head *head,
156 struct signal_struct *sig,
157 timer_t id)
158{
159 struct k_itimer *timer;
160
161 hlist_for_each_entry_rcu(timer, head, t_hash) {
162 if ((timer->it_signal == sig) && (timer->it_id == id))
163 return timer;
164 }
165 return NULL;
166}
167
168static struct k_itimer *posix_timer_by_id(timer_t id)
169{
170 struct signal_struct *sig = current->signal;
171 struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)];
172
173 return __posix_timers_find(head, sig, id);
174}
175
176static int posix_timer_add(struct k_itimer *timer)
177{
178 struct signal_struct *sig = current->signal;
179 int first_free_id = sig->posix_timer_id;
180 struct hlist_head *head;
181 int ret = -ENOENT;
182
183 do {
184 spin_lock(&hash_lock);
185 head = &posix_timers_hashtable[hash(sig, sig->posix_timer_id)];
186 if (!__posix_timers_find(head, sig, sig->posix_timer_id)) {
187 hlist_add_head_rcu(&timer->t_hash, head);
188 ret = sig->posix_timer_id;
189 }
190 if (++sig->posix_timer_id < 0)
191 sig->posix_timer_id = 0;
192 if ((sig->posix_timer_id == first_free_id) && (ret == -ENOENT))
193
194 ret = -EAGAIN;
195 spin_unlock(&hash_lock);
196 } while (ret == -ENOENT);
197 return ret;
198}
199
200static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
201{
202 spin_unlock_irqrestore(&timr->it_lock, flags);
203}
204
205
206static int posix_clock_realtime_get(clockid_t which_clock, struct timespec *tp)
207{
208 ktime_get_real_ts(tp);
209 return 0;
210}
211
212
213static int posix_clock_realtime_set(const clockid_t which_clock,
214 const struct timespec *tp)
215{
216 return do_sys_settimeofday(tp, NULL);
217}
218
219static int posix_clock_realtime_adj(const clockid_t which_clock,
220 struct timex *t)
221{
222 return do_adjtimex(t);
223}
224
225
226
227
228static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp)
229{
230 ktime_get_ts(tp);
231 return 0;
232}
233
234
235
236
237static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp)
238{
239 getrawmonotonic(tp);
240 return 0;
241}
242
243
244static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec *tp)
245{
246 *tp = current_kernel_time();
247 return 0;
248}
249
250static int posix_get_monotonic_coarse(clockid_t which_clock,
251 struct timespec *tp)
252{
253 *tp = get_monotonic_coarse();
254 return 0;
255}
256
257static int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp)
258{
259 *tp = ktime_to_timespec(KTIME_LOW_RES);
260 return 0;
261}
262
263static int posix_get_boottime(const clockid_t which_clock, struct timespec *tp)
264{
265 get_monotonic_boottime(tp);
266 return 0;
267}
268
269static int posix_get_tai(clockid_t which_clock, struct timespec *tp)
270{
271 timekeeping_clocktai(tp);
272 return 0;
273}
274
275
276
277
278static __init int init_posix_timers(void)
279{
280 struct k_clock clock_realtime = {
281 .clock_getres = hrtimer_get_res,
282 .clock_get = posix_clock_realtime_get,
283 .clock_set = posix_clock_realtime_set,
284 .clock_adj = posix_clock_realtime_adj,
285 .nsleep = common_nsleep,
286 .nsleep_restart = hrtimer_nanosleep_restart,
287 .timer_create = common_timer_create,
288 .timer_set = common_timer_set,
289 .timer_get = common_timer_get,
290 .timer_del = common_timer_del,
291 };
292 struct k_clock clock_monotonic = {
293 .clock_getres = hrtimer_get_res,
294 .clock_get = posix_ktime_get_ts,
295 .nsleep = common_nsleep,
296 .nsleep_restart = hrtimer_nanosleep_restart,
297 .timer_create = common_timer_create,
298 .timer_set = common_timer_set,
299 .timer_get = common_timer_get,
300 .timer_del = common_timer_del,
301 };
302 struct k_clock clock_monotonic_raw = {
303 .clock_getres = hrtimer_get_res,
304 .clock_get = posix_get_monotonic_raw,
305 };
306 struct k_clock clock_realtime_coarse = {
307 .clock_getres = posix_get_coarse_res,
308 .clock_get = posix_get_realtime_coarse,
309 };
310 struct k_clock clock_monotonic_coarse = {
311 .clock_getres = posix_get_coarse_res,
312 .clock_get = posix_get_monotonic_coarse,
313 };
314 struct k_clock clock_tai = {
315 .clock_getres = hrtimer_get_res,
316 .clock_get = posix_get_tai,
317 .nsleep = common_nsleep,
318 .nsleep_restart = hrtimer_nanosleep_restart,
319 .timer_create = common_timer_create,
320 .timer_set = common_timer_set,
321 .timer_get = common_timer_get,
322 .timer_del = common_timer_del,
323 };
324 struct k_clock clock_boottime = {
325 .clock_getres = hrtimer_get_res,
326 .clock_get = posix_get_boottime,
327 .nsleep = common_nsleep,
328 .nsleep_restart = hrtimer_nanosleep_restart,
329 .timer_create = common_timer_create,
330 .timer_set = common_timer_set,
331 .timer_get = common_timer_get,
332 .timer_del = common_timer_del,
333 };
334
335 posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime);
336 posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic);
337 posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
338 posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
339 posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
340 posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime);
341 posix_timers_register_clock(CLOCK_TAI, &clock_tai);
342
343 posix_timers_cache = kmem_cache_create("posix_timers_cache",
344 sizeof (struct k_itimer), 0, SLAB_PANIC,
345 NULL);
346 return 0;
347}
348
349__initcall(init_posix_timers);
350
351static void schedule_next_timer(struct k_itimer *timr)
352{
353 struct hrtimer *timer = &timr->it.real.timer;
354
355 if (timr->it.real.interval.tv64 == 0)
356 return;
357
358 timr->it_overrun += (unsigned int) hrtimer_forward(timer,
359 timer->base->get_time(),
360 timr->it.real.interval);
361
362 timr->it_overrun_last = timr->it_overrun;
363 timr->it_overrun = -1;
364 ++timr->it_requeue_pending;
365 hrtimer_restart(timer);
366}
367
368
369
370
371
372
373
374
375
376
377
378
379void do_schedule_next_timer(struct siginfo *info)
380{
381 struct k_itimer *timr;
382 unsigned long flags;
383
384 timr = lock_timer(info->si_tid, &flags);
385
386 if (timr && timr->it_requeue_pending == info->si_sys_private) {
387 if (timr->it_clock < 0)
388 posix_cpu_timer_schedule(timr);
389 else
390 schedule_next_timer(timr);
391
392 info->si_overrun += timr->it_overrun_last;
393 }
394
395 if (timr)
396 unlock_timer(timr, flags);
397}
398
399int posix_timer_event(struct k_itimer *timr, int si_private)
400{
401 struct task_struct *task;
402 int shared, ret = -1;
403
404
405
406
407
408
409
410
411
412
413
414 timr->sigq->info.si_sys_private = si_private;
415
416 rcu_read_lock();
417 task = pid_task(timr->it_pid, PIDTYPE_PID);
418 if (task) {
419 shared = !(timr->it_sigev_notify & SIGEV_THREAD_ID);
420 ret = send_sigqueue(timr->sigq, task, shared);
421 }
422 rcu_read_unlock();
423
424 return ret > 0;
425}
426EXPORT_SYMBOL_GPL(posix_timer_event);
427
428
429
430
431
432
433
434
435static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
436{
437 struct k_itimer *timr;
438 unsigned long flags;
439 int si_private = 0;
440 enum hrtimer_restart ret = HRTIMER_NORESTART;
441
442 timr = container_of(timer, struct k_itimer, it.real.timer);
443 spin_lock_irqsave(&timr->it_lock, flags);
444
445 if (timr->it.real.interval.tv64 != 0)
446 si_private = ++timr->it_requeue_pending;
447
448 if (posix_timer_event(timr, si_private)) {
449
450
451
452
453
454 if (timr->it.real.interval.tv64 != 0) {
455 ktime_t now = hrtimer_cb_get_time(timer);
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479#ifdef CONFIG_HIGH_RES_TIMERS
480 {
481 ktime_t kj = ktime_set(0, NSEC_PER_SEC / HZ);
482
483 if (timr->it.real.interval.tv64 < kj.tv64)
484 now = ktime_add(now, kj);
485 }
486#endif
487 timr->it_overrun += (unsigned int)
488 hrtimer_forward(timer, now,
489 timr->it.real.interval);
490 ret = HRTIMER_RESTART;
491 ++timr->it_requeue_pending;
492 }
493 }
494
495 unlock_timer(timr, flags);
496 return ret;
497}
498
499static struct pid *good_sigevent(sigevent_t * event)
500{
501 struct task_struct *rtn = current->group_leader;
502
503 if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
504 (!(rtn = find_task_by_vpid(event->sigev_notify_thread_id)) ||
505 !same_thread_group(rtn, current) ||
506 (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL))
507 return NULL;
508
509 if (((event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) &&
510 ((event->sigev_signo <= 0) || (event->sigev_signo > SIGRTMAX)))
511 return NULL;
512
513 return task_pid(rtn);
514}
515
516void posix_timers_register_clock(const clockid_t clock_id,
517 struct k_clock *new_clock)
518{
519 if ((unsigned) clock_id >= MAX_CLOCKS) {
520 printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",
521 clock_id);
522 return;
523 }
524
525 if (!new_clock->clock_get) {
526 printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",
527 clock_id);
528 return;
529 }
530 if (!new_clock->clock_getres) {
531 printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",
532 clock_id);
533 return;
534 }
535
536 posix_clocks[clock_id] = *new_clock;
537}
538EXPORT_SYMBOL_GPL(posix_timers_register_clock);
539
540static struct k_itimer * alloc_posix_timer(void)
541{
542 struct k_itimer *tmr;
543 tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
544 if (!tmr)
545 return tmr;
546 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
547 kmem_cache_free(posix_timers_cache, tmr);
548 return NULL;
549 }
550 memset(&tmr->sigq->info, 0, sizeof(siginfo_t));
551 return tmr;
552}
553
554static void k_itimer_rcu_free(struct rcu_head *head)
555{
556 struct k_itimer *tmr = container_of(head, struct k_itimer, it.rcu);
557
558 kmem_cache_free(posix_timers_cache, tmr);
559}
560
561#define IT_ID_SET 1
562#define IT_ID_NOT_SET 0
563static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
564{
565 if (it_id_set) {
566 unsigned long flags;
567 spin_lock_irqsave(&hash_lock, flags);
568 hlist_del_rcu(&tmr->t_hash);
569 spin_unlock_irqrestore(&hash_lock, flags);
570 }
571 put_pid(tmr->it_pid);
572 sigqueue_free(tmr->sigq);
573 call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
574}
575
576static struct k_clock *clockid_to_kclock(const clockid_t id)
577{
578 if (id < 0)
579 return (id & CLOCKFD_MASK) == CLOCKFD ?
580 &clock_posix_dynamic : &clock_posix_cpu;
581
582 if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)
583 return NULL;
584 return &posix_clocks[id];
585}
586
587static int common_timer_create(struct k_itimer *new_timer)
588{
589 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
590 return 0;
591}
592
593
594
595SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
596 struct sigevent __user *, timer_event_spec,
597 timer_t __user *, created_timer_id)
598{
599 struct k_clock *kc = clockid_to_kclock(which_clock);
600 struct k_itimer *new_timer;
601 int error, new_timer_id;
602 sigevent_t event;
603 int it_id_set = IT_ID_NOT_SET;
604
605 if (!kc)
606 return -EINVAL;
607 if (!kc->timer_create)
608 return -EOPNOTSUPP;
609
610 new_timer = alloc_posix_timer();
611 if (unlikely(!new_timer))
612 return -EAGAIN;
613
614 spin_lock_init(&new_timer->it_lock);
615 new_timer_id = posix_timer_add(new_timer);
616 if (new_timer_id < 0) {
617 error = new_timer_id;
618 goto out;
619 }
620
621 it_id_set = IT_ID_SET;
622 new_timer->it_id = (timer_t) new_timer_id;
623 new_timer->it_clock = which_clock;
624 new_timer->it_overrun = -1;
625
626 if (timer_event_spec) {
627 if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
628 error = -EFAULT;
629 goto out;
630 }
631 rcu_read_lock();
632 new_timer->it_pid = get_pid(good_sigevent(&event));
633 rcu_read_unlock();
634 if (!new_timer->it_pid) {
635 error = -EINVAL;
636 goto out;
637 }
638 } else {
639 memset(&event.sigev_value, 0, sizeof(event.sigev_value));
640 event.sigev_notify = SIGEV_SIGNAL;
641 event.sigev_signo = SIGALRM;
642 event.sigev_value.sival_int = new_timer->it_id;
643 new_timer->it_pid = get_pid(task_tgid(current));
644 }
645
646 new_timer->it_sigev_notify = event.sigev_notify;
647 new_timer->sigq->info.si_signo = event.sigev_signo;
648 new_timer->sigq->info.si_value = event.sigev_value;
649 new_timer->sigq->info.si_tid = new_timer->it_id;
650 new_timer->sigq->info.si_code = SI_TIMER;
651
652 if (copy_to_user(created_timer_id,
653 &new_timer_id, sizeof (new_timer_id))) {
654 error = -EFAULT;
655 goto out;
656 }
657
658 error = kc->timer_create(new_timer);
659 if (error)
660 goto out;
661
662 spin_lock_irq(¤t->sighand->siglock);
663 new_timer->it_signal = current->signal;
664 list_add(&new_timer->list, ¤t->signal->posix_timers);
665 spin_unlock_irq(¤t->sighand->siglock);
666
667 return 0;
668
669
670
671
672
673
674out:
675 release_posix_timer(new_timer, it_id_set);
676 return error;
677}
678
679
680
681
682
683
684
685
686static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
687{
688 struct k_itimer *timr;
689
690
691
692
693
694 if ((unsigned long long)timer_id > INT_MAX)
695 return NULL;
696
697 rcu_read_lock();
698 timr = posix_timer_by_id(timer_id);
699 if (timr) {
700 spin_lock_irqsave(&timr->it_lock, *flags);
701 if (timr->it_signal == current->signal) {
702 rcu_read_unlock();
703 return timr;
704 }
705 spin_unlock_irqrestore(&timr->it_lock, *flags);
706 }
707 rcu_read_unlock();
708
709 return NULL;
710}
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728static void
729common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
730{
731 ktime_t now, remaining, iv;
732 struct hrtimer *timer = &timr->it.real.timer;
733
734 memset(cur_setting, 0, sizeof(struct itimerspec));
735
736 iv = timr->it.real.interval;
737
738
739 if (iv.tv64)
740 cur_setting->it_interval = ktime_to_timespec(iv);
741 else if (!hrtimer_active(timer) &&
742 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
743 return;
744
745 now = timer->base->get_time();
746
747
748
749
750
751
752 if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
753 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
754 timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
755
756 remaining = ktime_sub(hrtimer_get_expires(timer), now);
757
758 if (remaining.tv64 <= 0) {
759
760
761
762
763 if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
764 cur_setting->it_value.tv_nsec = 1;
765 } else
766 cur_setting->it_value = ktime_to_timespec(remaining);
767}
768
769
770SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
771 struct itimerspec __user *, setting)
772{
773 struct itimerspec cur_setting;
774 struct k_itimer *timr;
775 struct k_clock *kc;
776 unsigned long flags;
777 int ret = 0;
778
779 timr = lock_timer(timer_id, &flags);
780 if (!timr)
781 return -EINVAL;
782
783 kc = clockid_to_kclock(timr->it_clock);
784 if (WARN_ON_ONCE(!kc || !kc->timer_get))
785 ret = -EINVAL;
786 else
787 kc->timer_get(timr, &cur_setting);
788
789 unlock_timer(timr, flags);
790
791 if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
792 return -EFAULT;
793
794 return ret;
795}
796
797
798
799
800
801
802
803
804
805
806SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
807{
808 struct k_itimer *timr;
809 int overrun;
810 unsigned long flags;
811
812 timr = lock_timer(timer_id, &flags);
813 if (!timr)
814 return -EINVAL;
815
816 overrun = timr->it_overrun_last;
817 unlock_timer(timr, flags);
818
819 return overrun;
820}
821
822
823
824static int
825common_timer_set(struct k_itimer *timr, int flags,
826 struct itimerspec *new_setting, struct itimerspec *old_setting)
827{
828 struct hrtimer *timer = &timr->it.real.timer;
829 enum hrtimer_mode mode;
830
831 if (old_setting)
832 common_timer_get(timr, old_setting);
833
834
835 timr->it.real.interval.tv64 = 0;
836
837
838
839
840 if (hrtimer_try_to_cancel(timer) < 0)
841 return TIMER_RETRY;
842
843 timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
844 ~REQUEUE_PENDING;
845 timr->it_overrun_last = 0;
846
847
848 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
849 return 0;
850
851 mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
852 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
853 timr->it.real.timer.function = posix_timer_fn;
854
855 hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
856
857
858 timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
859
860
861 if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
862
863 if (mode == HRTIMER_MODE_REL) {
864 hrtimer_add_expires(timer, timer->base->get_time());
865 }
866 return 0;
867 }
868
869 hrtimer_start_expires(timer, mode);
870 return 0;
871}
872
873
874SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
875 const struct itimerspec __user *, new_setting,
876 struct itimerspec __user *, old_setting)
877{
878 struct k_itimer *timr;
879 struct itimerspec new_spec, old_spec;
880 int error = 0;
881 unsigned long flag;
882 struct itimerspec *rtn = old_setting ? &old_spec : NULL;
883 struct k_clock *kc;
884
885 if (!new_setting)
886 return -EINVAL;
887
888 if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
889 return -EFAULT;
890
891 if (!timespec_valid(&new_spec.it_interval) ||
892 !timespec_valid(&new_spec.it_value))
893 return -EINVAL;
894retry:
895 timr = lock_timer(timer_id, &flag);
896 if (!timr)
897 return -EINVAL;
898
899 kc = clockid_to_kclock(timr->it_clock);
900 if (WARN_ON_ONCE(!kc || !kc->timer_set))
901 error = -EINVAL;
902 else
903 error = kc->timer_set(timr, flags, &new_spec, rtn);
904
905 unlock_timer(timr, flag);
906 if (error == TIMER_RETRY) {
907 rtn = NULL;
908 goto retry;
909 }
910
911 if (old_setting && !error &&
912 copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
913 error = -EFAULT;
914
915 return error;
916}
917
918static int common_timer_del(struct k_itimer *timer)
919{
920 timer->it.real.interval.tv64 = 0;
921
922 if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
923 return TIMER_RETRY;
924 return 0;
925}
926
927static inline int timer_delete_hook(struct k_itimer *timer)
928{
929 struct k_clock *kc = clockid_to_kclock(timer->it_clock);
930
931 if (WARN_ON_ONCE(!kc || !kc->timer_del))
932 return -EINVAL;
933 return kc->timer_del(timer);
934}
935
936
937SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
938{
939 struct k_itimer *timer;
940 unsigned long flags;
941
942retry_delete:
943 timer = lock_timer(timer_id, &flags);
944 if (!timer)
945 return -EINVAL;
946
947 if (timer_delete_hook(timer) == TIMER_RETRY) {
948 unlock_timer(timer, flags);
949 goto retry_delete;
950 }
951
952 spin_lock(¤t->sighand->siglock);
953 list_del(&timer->list);
954 spin_unlock(¤t->sighand->siglock);
955
956
957
958
959 timer->it_signal = NULL;
960
961 unlock_timer(timer, flags);
962 release_posix_timer(timer, IT_ID_SET);
963 return 0;
964}
965
966
967
968
969static void itimer_delete(struct k_itimer *timer)
970{
971 unsigned long flags;
972
973retry_delete:
974 spin_lock_irqsave(&timer->it_lock, flags);
975
976 if (timer_delete_hook(timer) == TIMER_RETRY) {
977 unlock_timer(timer, flags);
978 goto retry_delete;
979 }
980 list_del(&timer->list);
981
982
983
984
985 timer->it_signal = NULL;
986
987 unlock_timer(timer, flags);
988 release_posix_timer(timer, IT_ID_SET);
989}
990
991
992
993
994
995void exit_itimers(struct signal_struct *sig)
996{
997 struct k_itimer *tmr;
998
999 while (!list_empty(&sig->posix_timers)) {
1000 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
1001 itimer_delete(tmr);
1002 }
1003}
1004
1005SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
1006 const struct timespec __user *, tp)
1007{
1008 struct k_clock *kc = clockid_to_kclock(which_clock);
1009 struct timespec new_tp;
1010
1011 if (!kc || !kc->clock_set)
1012 return -EINVAL;
1013
1014 if (copy_from_user(&new_tp, tp, sizeof (*tp)))
1015 return -EFAULT;
1016
1017 return kc->clock_set(which_clock, &new_tp);
1018}
1019
1020SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
1021 struct timespec __user *,tp)
1022{
1023 struct k_clock *kc = clockid_to_kclock(which_clock);
1024 struct timespec kernel_tp;
1025 int error;
1026
1027 if (!kc)
1028 return -EINVAL;
1029
1030 error = kc->clock_get(which_clock, &kernel_tp);
1031
1032 if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
1033 error = -EFAULT;
1034
1035 return error;
1036}
1037
1038SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1039 struct timex __user *, utx)
1040{
1041 struct k_clock *kc = clockid_to_kclock(which_clock);
1042 struct timex ktx;
1043 int err;
1044
1045 if (!kc)
1046 return -EINVAL;
1047 if (!kc->clock_adj)
1048 return -EOPNOTSUPP;
1049
1050 if (copy_from_user(&ktx, utx, sizeof(ktx)))
1051 return -EFAULT;
1052
1053 err = kc->clock_adj(which_clock, &ktx);
1054
1055 if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
1056 return -EFAULT;
1057
1058 return err;
1059}
1060
1061SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
1062 struct timespec __user *, tp)
1063{
1064 struct k_clock *kc = clockid_to_kclock(which_clock);
1065 struct timespec rtn_tp;
1066 int error;
1067
1068 if (!kc)
1069 return -EINVAL;
1070
1071 error = kc->clock_getres(which_clock, &rtn_tp);
1072
1073 if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp)))
1074 error = -EFAULT;
1075
1076 return error;
1077}
1078
1079
1080
1081
1082static int common_nsleep(const clockid_t which_clock, int flags,
1083 struct timespec *tsave, struct timespec __user *rmtp)
1084{
1085 return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
1086 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1087 which_clock);
1088}
1089
1090SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
1091 const struct timespec __user *, rqtp,
1092 struct timespec __user *, rmtp)
1093{
1094 struct k_clock *kc = clockid_to_kclock(which_clock);
1095 struct timespec t;
1096
1097 if (!kc)
1098 return -EINVAL;
1099 if (!kc->nsleep)
1100 return -ENANOSLEEP_NOTSUP;
1101
1102 if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
1103 return -EFAULT;
1104
1105 if (!timespec_valid(&t))
1106 return -EINVAL;
1107
1108 return kc->nsleep(which_clock, flags, &t, rmtp);
1109}
1110
1111
1112
1113
1114
1115long clock_nanosleep_restart(struct restart_block *restart_block)
1116{
1117 clockid_t which_clock = restart_block->nanosleep.clockid;
1118 struct k_clock *kc = clockid_to_kclock(which_clock);
1119
1120 if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
1121 return -EINVAL;
1122
1123 return kc->nsleep_restart(restart_block);
1124}
1125