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 <asm/semaphore.h>
41#include <linux/list.h>
42#include <linux/init.h>
43#include <linux/compiler.h>
44#include <linux/idr.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/module.h>
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72static struct kmem_cache *posix_timers_cache;
73static struct idr posix_timers_id;
74static DEFINE_SPINLOCK(idr_lock);
75
76
77
78
79
80#if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
81 ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
82#error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
83#endif
84
85
86
87
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
127
128
129
130
131
132
133
134
135static struct k_clock posix_clocks[MAX_CLOCKS];
136
137
138
139
140static int common_nsleep(const clockid_t, int flags, struct timespec *t,
141 struct timespec __user *rmtp);
142static void common_timer_get(struct k_itimer *, struct itimerspec *);
143static int common_timer_set(struct k_itimer *, int,
144 struct itimerspec *, struct itimerspec *);
145static int common_timer_del(struct k_itimer *timer);
146
147static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
148
149static struct k_itimer *lock_timer(timer_t timer_id, unsigned long *flags);
150
151static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
152{
153 spin_unlock_irqrestore(&timr->it_lock, flags);
154}
155
156
157
158
159#define CLOCK_DISPATCH(clock, call, arglist) \
160 ((clock) < 0 ? posix_cpu_##call arglist : \
161 (posix_clocks[clock].call != NULL \
162 ? (*posix_clocks[clock].call) arglist : common_##call arglist))
163
164
165
166
167
168
169
170
171
172static inline int common_clock_getres(const clockid_t which_clock,
173 struct timespec *tp)
174{
175 tp->tv_sec = 0;
176 tp->tv_nsec = posix_clocks[which_clock].res;
177 return 0;
178}
179
180
181
182
183static int common_clock_get(clockid_t which_clock, struct timespec *tp)
184{
185 ktime_get_real_ts(tp);
186 return 0;
187}
188
189static inline int common_clock_set(const clockid_t which_clock,
190 struct timespec *tp)
191{
192 return do_sys_settimeofday(tp, NULL);
193}
194
195static int common_timer_create(struct k_itimer *new_timer)
196{
197 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
198 return 0;
199}
200
201
202
203
204static inline int invalid_clockid(const clockid_t which_clock)
205{
206 if (which_clock < 0)
207 return 0;
208 if ((unsigned) which_clock >= MAX_CLOCKS)
209 return 1;
210 if (posix_clocks[which_clock].clock_getres != NULL)
211 return 0;
212 if (posix_clocks[which_clock].res != 0)
213 return 0;
214 return 1;
215}
216
217
218
219
220static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp)
221{
222 ktime_get_ts(tp);
223 return 0;
224}
225
226
227
228
229static __init int init_posix_timers(void)
230{
231 struct k_clock clock_realtime = {
232 .clock_getres = hrtimer_get_res,
233 };
234 struct k_clock clock_monotonic = {
235 .clock_getres = hrtimer_get_res,
236 .clock_get = posix_ktime_get_ts,
237 .clock_set = do_posix_clock_nosettime,
238 };
239
240 register_posix_clock(CLOCK_REALTIME, &clock_realtime);
241 register_posix_clock(CLOCK_MONOTONIC, &clock_monotonic);
242
243 posix_timers_cache = kmem_cache_create("posix_timers_cache",
244 sizeof (struct k_itimer), 0, SLAB_PANIC,
245 NULL);
246 idr_init(&posix_timers_id);
247 return 0;
248}
249
250__initcall(init_posix_timers);
251
252static void schedule_next_timer(struct k_itimer *timr)
253{
254 struct hrtimer *timer = &timr->it.real.timer;
255
256 if (timr->it.real.interval.tv64 == 0)
257 return;
258
259 timr->it_overrun += hrtimer_forward(timer, timer->base->get_time(),
260 timr->it.real.interval);
261
262 timr->it_overrun_last = timr->it_overrun;
263 timr->it_overrun = -1;
264 ++timr->it_requeue_pending;
265 hrtimer_restart(timer);
266}
267
268
269
270
271
272
273
274
275
276
277
278
279void do_schedule_next_timer(struct siginfo *info)
280{
281 struct k_itimer *timr;
282 unsigned long flags;
283
284 timr = lock_timer(info->si_tid, &flags);
285
286 if (timr && timr->it_requeue_pending == info->si_sys_private) {
287 if (timr->it_clock < 0)
288 posix_cpu_timer_schedule(timr);
289 else
290 schedule_next_timer(timr);
291
292 info->si_overrun = timr->it_overrun_last;
293 }
294
295 if (timr)
296 unlock_timer(timr, flags);
297}
298
299int posix_timer_event(struct k_itimer *timr,int si_private)
300{
301 memset(&timr->sigq->info, 0, sizeof(siginfo_t));
302 timr->sigq->info.si_sys_private = si_private;
303
304
305 timr->sigq->info.si_signo = timr->it_sigev_signo;
306 timr->sigq->info.si_errno = 0;
307 timr->sigq->info.si_code = SI_TIMER;
308 timr->sigq->info.si_tid = timr->it_id;
309 timr->sigq->info.si_value = timr->it_sigev_value;
310
311 if (timr->it_sigev_notify & SIGEV_THREAD_ID) {
312 struct task_struct *leader;
313 int ret = send_sigqueue(timr->it_sigev_signo, timr->sigq,
314 timr->it_process);
315
316 if (likely(ret >= 0))
317 return ret;
318
319 timr->it_sigev_notify = SIGEV_SIGNAL;
320 leader = timr->it_process->group_leader;
321 put_task_struct(timr->it_process);
322 timr->it_process = leader;
323 }
324
325 return send_group_sigqueue(timr->it_sigev_signo, timr->sigq,
326 timr->it_process);
327}
328EXPORT_SYMBOL_GPL(posix_timer_event);
329
330
331
332
333
334
335
336
337static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
338{
339 struct k_itimer *timr;
340 unsigned long flags;
341 int si_private = 0;
342 enum hrtimer_restart ret = HRTIMER_NORESTART;
343
344 timr = container_of(timer, struct k_itimer, it.real.timer);
345 spin_lock_irqsave(&timr->it_lock, flags);
346
347 if (timr->it.real.interval.tv64 != 0)
348 si_private = ++timr->it_requeue_pending;
349
350 if (posix_timer_event(timr, si_private)) {
351
352
353
354
355
356 if (timr->it.real.interval.tv64 != 0) {
357 ktime_t now = hrtimer_cb_get_time(timer);
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381#ifdef CONFIG_HIGH_RES_TIMERS
382 {
383 ktime_t kj = ktime_set(0, NSEC_PER_SEC / HZ);
384
385 if (timr->it.real.interval.tv64 < kj.tv64)
386 now = ktime_add(now, kj);
387 }
388#endif
389 timr->it_overrun +=
390 hrtimer_forward(timer, now,
391 timr->it.real.interval);
392 ret = HRTIMER_RESTART;
393 ++timr->it_requeue_pending;
394 }
395 }
396
397 unlock_timer(timr, flags);
398 return ret;
399}
400
401static struct task_struct * good_sigevent(sigevent_t * event)
402{
403 struct task_struct *rtn = current->group_leader;
404
405 if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
406 (!(rtn = find_task_by_pid(event->sigev_notify_thread_id)) ||
407 !same_thread_group(rtn, current) ||
408 (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL))
409 return NULL;
410
411 if (((event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) &&
412 ((event->sigev_signo <= 0) || (event->sigev_signo > SIGRTMAX)))
413 return NULL;
414
415 return rtn;
416}
417
418void register_posix_clock(const clockid_t clock_id, struct k_clock *new_clock)
419{
420 if ((unsigned) clock_id >= MAX_CLOCKS) {
421 printk("POSIX clock register failed for clock_id %d\n",
422 clock_id);
423 return;
424 }
425
426 posix_clocks[clock_id] = *new_clock;
427}
428EXPORT_SYMBOL_GPL(register_posix_clock);
429
430static struct k_itimer * alloc_posix_timer(void)
431{
432 struct k_itimer *tmr;
433 tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
434 if (!tmr)
435 return tmr;
436 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
437 kmem_cache_free(posix_timers_cache, tmr);
438 tmr = NULL;
439 }
440 return tmr;
441}
442
443#define IT_ID_SET 1
444#define IT_ID_NOT_SET 0
445static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
446{
447 if (it_id_set) {
448 unsigned long flags;
449 spin_lock_irqsave(&idr_lock, flags);
450 idr_remove(&posix_timers_id, tmr->it_id);
451 spin_unlock_irqrestore(&idr_lock, flags);
452 }
453 sigqueue_free(tmr->sigq);
454 if (unlikely(tmr->it_process) &&
455 tmr->it_sigev_notify == (SIGEV_SIGNAL|SIGEV_THREAD_ID))
456 put_task_struct(tmr->it_process);
457 kmem_cache_free(posix_timers_cache, tmr);
458}
459
460
461
462asmlinkage long
463sys_timer_create(const clockid_t which_clock,
464 struct sigevent __user *timer_event_spec,
465 timer_t __user * created_timer_id)
466{
467 int error = 0;
468 struct k_itimer *new_timer = NULL;
469 int new_timer_id;
470 struct task_struct *process = NULL;
471 unsigned long flags;
472 sigevent_t event;
473 int it_id_set = IT_ID_NOT_SET;
474
475 if (invalid_clockid(which_clock))
476 return -EINVAL;
477
478 new_timer = alloc_posix_timer();
479 if (unlikely(!new_timer))
480 return -EAGAIN;
481
482 spin_lock_init(&new_timer->it_lock);
483 retry:
484 if (unlikely(!idr_pre_get(&posix_timers_id, GFP_KERNEL))) {
485 error = -EAGAIN;
486 goto out;
487 }
488 spin_lock_irq(&idr_lock);
489 error = idr_get_new(&posix_timers_id, (void *) new_timer,
490 &new_timer_id);
491 spin_unlock_irq(&idr_lock);
492 if (error == -EAGAIN)
493 goto retry;
494 else if (error) {
495
496
497
498
499 error = -EAGAIN;
500 goto out;
501 }
502
503 it_id_set = IT_ID_SET;
504 new_timer->it_id = (timer_t) new_timer_id;
505 new_timer->it_clock = which_clock;
506 new_timer->it_overrun = -1;
507 error = CLOCK_DISPATCH(which_clock, timer_create, (new_timer));
508 if (error)
509 goto out;
510
511
512
513
514
515 if (copy_to_user(created_timer_id,
516 &new_timer_id, sizeof (new_timer_id))) {
517 error = -EFAULT;
518 goto out;
519 }
520 if (timer_event_spec) {
521 if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
522 error = -EFAULT;
523 goto out;
524 }
525 new_timer->it_sigev_notify = event.sigev_notify;
526 new_timer->it_sigev_signo = event.sigev_signo;
527 new_timer->it_sigev_value = event.sigev_value;
528
529 read_lock(&tasklist_lock);
530 if ((process = good_sigevent(&event))) {
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546 spin_lock_irqsave(&process->sighand->siglock, flags);
547 if (!(process->flags & PF_EXITING)) {
548 new_timer->it_process = process;
549 list_add(&new_timer->list,
550 &process->signal->posix_timers);
551 if (new_timer->it_sigev_notify == (SIGEV_SIGNAL|SIGEV_THREAD_ID))
552 get_task_struct(process);
553 spin_unlock_irqrestore(&process->sighand->siglock, flags);
554 } else {
555 spin_unlock_irqrestore(&process->sighand->siglock, flags);
556 process = NULL;
557 }
558 }
559 read_unlock(&tasklist_lock);
560 if (!process) {
561 error = -EINVAL;
562 goto out;
563 }
564 } else {
565 new_timer->it_sigev_notify = SIGEV_SIGNAL;
566 new_timer->it_sigev_signo = SIGALRM;
567 new_timer->it_sigev_value.sival_int = new_timer->it_id;
568 process = current->group_leader;
569 spin_lock_irqsave(&process->sighand->siglock, flags);
570 new_timer->it_process = process;
571 list_add(&new_timer->list, &process->signal->posix_timers);
572 spin_unlock_irqrestore(&process->sighand->siglock, flags);
573 }
574
575
576
577
578
579
580
581
582out:
583 if (error)
584 release_posix_timer(new_timer, it_id_set);
585
586 return error;
587}
588
589
590
591
592
593
594
595
596static struct k_itimer * lock_timer(timer_t timer_id, unsigned long *flags)
597{
598 struct k_itimer *timr;
599
600
601
602
603
604
605 spin_lock_irqsave(&idr_lock, *flags);
606 timr = (struct k_itimer *) idr_find(&posix_timers_id, (int) timer_id);
607 if (timr) {
608 spin_lock(&timr->it_lock);
609
610 if ((timr->it_id != timer_id) || !(timr->it_process) ||
611 !same_thread_group(timr->it_process, current)) {
612 spin_unlock(&timr->it_lock);
613 spin_unlock_irqrestore(&idr_lock, *flags);
614 timr = NULL;
615 } else
616 spin_unlock(&idr_lock);
617 } else
618 spin_unlock_irqrestore(&idr_lock, *flags);
619
620 return timr;
621}
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639static void
640common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
641{
642 ktime_t now, remaining, iv;
643 struct hrtimer *timer = &timr->it.real.timer;
644
645 memset(cur_setting, 0, sizeof(struct itimerspec));
646
647 iv = timr->it.real.interval;
648
649
650 if (iv.tv64)
651 cur_setting->it_interval = ktime_to_timespec(iv);
652 else if (!hrtimer_active(timer) &&
653 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
654 return;
655
656 now = timer->base->get_time();
657
658
659
660
661
662
663 if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
664 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
665 timr->it_overrun += hrtimer_forward(timer, now, iv);
666
667 remaining = ktime_sub(timer->expires, now);
668
669 if (remaining.tv64 <= 0) {
670
671
672
673
674 if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
675 cur_setting->it_value.tv_nsec = 1;
676 } else
677 cur_setting->it_value = ktime_to_timespec(remaining);
678}
679
680
681asmlinkage long
682sys_timer_gettime(timer_t timer_id, struct itimerspec __user *setting)
683{
684 struct k_itimer *timr;
685 struct itimerspec cur_setting;
686 unsigned long flags;
687
688 timr = lock_timer(timer_id, &flags);
689 if (!timr)
690 return -EINVAL;
691
692 CLOCK_DISPATCH(timr->it_clock, timer_get, (timr, &cur_setting));
693
694 unlock_timer(timr, flags);
695
696 if (copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
697 return -EFAULT;
698
699 return 0;
700}
701
702
703
704
705
706
707
708
709
710
711asmlinkage long
712sys_timer_getoverrun(timer_t timer_id)
713{
714 struct k_itimer *timr;
715 int overrun;
716 unsigned long flags;
717
718 timr = lock_timer(timer_id, &flags);
719 if (!timr)
720 return -EINVAL;
721
722 overrun = timr->it_overrun_last;
723 unlock_timer(timr, flags);
724
725 return overrun;
726}
727
728
729
730static int
731common_timer_set(struct k_itimer *timr, int flags,
732 struct itimerspec *new_setting, struct itimerspec *old_setting)
733{
734 struct hrtimer *timer = &timr->it.real.timer;
735 enum hrtimer_mode mode;
736
737 if (old_setting)
738 common_timer_get(timr, old_setting);
739
740
741 timr->it.real.interval.tv64 = 0;
742
743
744
745
746 if (hrtimer_try_to_cancel(timer) < 0)
747 return TIMER_RETRY;
748
749 timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
750 ~REQUEUE_PENDING;
751 timr->it_overrun_last = 0;
752
753
754 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
755 return 0;
756
757 mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
758 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
759 timr->it.real.timer.function = posix_timer_fn;
760
761 timer->expires = timespec_to_ktime(new_setting->it_value);
762
763
764 timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
765
766
767 if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
768
769 if (mode == HRTIMER_MODE_REL)
770 timer->expires = ktime_add(timer->expires,
771 timer->base->get_time());
772 return 0;
773 }
774
775 hrtimer_start(timer, timer->expires, mode);
776 return 0;
777}
778
779
780asmlinkage long
781sys_timer_settime(timer_t timer_id, int flags,
782 const struct itimerspec __user *new_setting,
783 struct itimerspec __user *old_setting)
784{
785 struct k_itimer *timr;
786 struct itimerspec new_spec, old_spec;
787 int error = 0;
788 unsigned long flag;
789 struct itimerspec *rtn = old_setting ? &old_spec : NULL;
790
791 if (!new_setting)
792 return -EINVAL;
793
794 if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
795 return -EFAULT;
796
797 if (!timespec_valid(&new_spec.it_interval) ||
798 !timespec_valid(&new_spec.it_value))
799 return -EINVAL;
800retry:
801 timr = lock_timer(timer_id, &flag);
802 if (!timr)
803 return -EINVAL;
804
805 error = CLOCK_DISPATCH(timr->it_clock, timer_set,
806 (timr, flags, &new_spec, rtn));
807
808 unlock_timer(timr, flag);
809 if (error == TIMER_RETRY) {
810 rtn = NULL;
811 goto retry;
812 }
813
814 if (old_setting && !error &&
815 copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
816 error = -EFAULT;
817
818 return error;
819}
820
821static inline int common_timer_del(struct k_itimer *timer)
822{
823 timer->it.real.interval.tv64 = 0;
824
825 if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
826 return TIMER_RETRY;
827 return 0;
828}
829
830static inline int timer_delete_hook(struct k_itimer *timer)
831{
832 return CLOCK_DISPATCH(timer->it_clock, timer_del, (timer));
833}
834
835
836asmlinkage long
837sys_timer_delete(timer_t timer_id)
838{
839 struct k_itimer *timer;
840 unsigned long flags;
841
842retry_delete:
843 timer = lock_timer(timer_id, &flags);
844 if (!timer)
845 return -EINVAL;
846
847 if (timer_delete_hook(timer) == TIMER_RETRY) {
848 unlock_timer(timer, flags);
849 goto retry_delete;
850 }
851
852 spin_lock(¤t->sighand->siglock);
853 list_del(&timer->list);
854 spin_unlock(¤t->sighand->siglock);
855
856
857
858
859 if (timer->it_process) {
860 if (timer->it_sigev_notify == (SIGEV_SIGNAL|SIGEV_THREAD_ID))
861 put_task_struct(timer->it_process);
862 timer->it_process = NULL;
863 }
864 unlock_timer(timer, flags);
865 release_posix_timer(timer, IT_ID_SET);
866 return 0;
867}
868
869
870
871
872static void itimer_delete(struct k_itimer *timer)
873{
874 unsigned long flags;
875
876retry_delete:
877 spin_lock_irqsave(&timer->it_lock, flags);
878
879 if (timer_delete_hook(timer) == TIMER_RETRY) {
880 unlock_timer(timer, flags);
881 goto retry_delete;
882 }
883 list_del(&timer->list);
884
885
886
887
888 if (timer->it_process) {
889 if (timer->it_sigev_notify == (SIGEV_SIGNAL|SIGEV_THREAD_ID))
890 put_task_struct(timer->it_process);
891 timer->it_process = NULL;
892 }
893 unlock_timer(timer, flags);
894 release_posix_timer(timer, IT_ID_SET);
895}
896
897
898
899
900
901void exit_itimers(struct signal_struct *sig)
902{
903 struct k_itimer *tmr;
904
905 while (!list_empty(&sig->posix_timers)) {
906 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
907 itimer_delete(tmr);
908 }
909}
910
911
912int do_posix_clock_nosettime(const clockid_t clockid, struct timespec *tp)
913{
914 return -EINVAL;
915}
916EXPORT_SYMBOL_GPL(do_posix_clock_nosettime);
917
918int do_posix_clock_nonanosleep(const clockid_t clock, int flags,
919 struct timespec *t, struct timespec __user *r)
920{
921#ifndef ENOTSUP
922 return -EOPNOTSUPP;
923#else
924 return -ENOTSUP;
925#endif
926}
927EXPORT_SYMBOL_GPL(do_posix_clock_nonanosleep);
928
929asmlinkage long sys_clock_settime(const clockid_t which_clock,
930 const struct timespec __user *tp)
931{
932 struct timespec new_tp;
933
934 if (invalid_clockid(which_clock))
935 return -EINVAL;
936 if (copy_from_user(&new_tp, tp, sizeof (*tp)))
937 return -EFAULT;
938
939 return CLOCK_DISPATCH(which_clock, clock_set, (which_clock, &new_tp));
940}
941
942asmlinkage long
943sys_clock_gettime(const clockid_t which_clock, struct timespec __user *tp)
944{
945 struct timespec kernel_tp;
946 int error;
947
948 if (invalid_clockid(which_clock))
949 return -EINVAL;
950 error = CLOCK_DISPATCH(which_clock, clock_get,
951 (which_clock, &kernel_tp));
952 if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
953 error = -EFAULT;
954
955 return error;
956
957}
958
959asmlinkage long
960sys_clock_getres(const clockid_t which_clock, struct timespec __user *tp)
961{
962 struct timespec rtn_tp;
963 int error;
964
965 if (invalid_clockid(which_clock))
966 return -EINVAL;
967
968 error = CLOCK_DISPATCH(which_clock, clock_getres,
969 (which_clock, &rtn_tp));
970
971 if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp))) {
972 error = -EFAULT;
973 }
974
975 return error;
976}
977
978
979
980
981static int common_nsleep(const clockid_t which_clock, int flags,
982 struct timespec *tsave, struct timespec __user *rmtp)
983{
984 struct timespec rmt;
985 int ret;
986
987 ret = hrtimer_nanosleep(tsave, rmtp ? &rmt : NULL,
988 flags & TIMER_ABSTIME ?
989 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
990 which_clock);
991
992 if (ret && rmtp) {
993 if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
994 return -EFAULT;
995 }
996
997 return ret;
998}
999
1000asmlinkage long
1001sys_clock_nanosleep(const clockid_t which_clock, int flags,
1002 const struct timespec __user *rqtp,
1003 struct timespec __user *rmtp)
1004{
1005 struct timespec t;
1006
1007 if (invalid_clockid(which_clock))
1008 return -EINVAL;
1009
1010 if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
1011 return -EFAULT;
1012
1013 if (!timespec_valid(&t))
1014 return -EINVAL;
1015
1016 return CLOCK_DISPATCH(which_clock, nsleep,
1017 (which_clock, flags, &t, rmtp));
1018}
1019
1020
1021
1022
1023static int common_nsleep_restart(struct restart_block *restart_block)
1024{
1025 return hrtimer_nanosleep_restart(restart_block);
1026}
1027
1028
1029
1030
1031
1032long
1033clock_nanosleep_restart(struct restart_block *restart_block)
1034{
1035 clockid_t which_clock = restart_block->arg0;
1036
1037 return CLOCK_DISPATCH(which_clock, nsleep_restart,
1038 (restart_block));
1039}
1040