2 * linux/kernel/posix-timers.c
5 * 2002-10-15 Posix Clocks & timers
6 * by George Anzinger george@mvista.com
8 * Copyright (C) 2002 2003 by MontaVista Software.
10 * 2004-06-01 Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
11 * Copyright (C) 2004 Boris Hu
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or (at
16 * your option) any later version.
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 * MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA
30 /* These are all the functions necessary to implement
31 * POSIX clocks & timers
34 #include <linux/interrupt.h>
35 #include <linux/slab.h>
36 #include <linux/time.h>
37 #include <linux/mutex.h>
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 #include <linux/nospec.h>
54 * Management arrays for POSIX timers. Timers are now kept in static hash table
56 * Timer ids are allocated by local routine, which selects proper hash head by
57 * key, constructed from current->signal address and per signal struct counter.
58 * This keeps timer ids unique per process, but now they can intersect between
63 * Lets keep our timers in a slab cache :-)
65 static struct kmem_cache
*posix_timers_cache
;
67 static DEFINE_HASHTABLE(posix_timers_hashtable
, 9);
68 static DEFINE_SPINLOCK(hash_lock
);
71 * we assume that the new SIGEV_THREAD_ID shares no bits with the other
72 * SIGEV values. Here we put out an error if this assumption fails.
74 #if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
75 ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
76 #error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
80 * parisc wants ENOTSUP instead of EOPNOTSUPP
83 # define ENANOSLEEP_NOTSUP EOPNOTSUPP
85 # define ENANOSLEEP_NOTSUP ENOTSUP
89 * The timer ID is turned into a timer address by idr_find().
90 * Verifying a valid ID consists of:
92 * a) checking that idr_find() returns other than -1.
93 * b) checking that the timer id matches the one in the timer itself.
94 * c) that the timer owner is in the callers thread group.
98 * CLOCKs: The POSIX standard calls for a couple of clocks and allows us
99 * to implement others. This structure defines the various
102 * RESOLUTION: Clock resolution is used to round up timer and interval
103 * times, NOT to report clock times, which are reported with as
104 * much resolution as the system can muster. In some cases this
105 * resolution may depend on the underlying clock hardware and
106 * may not be quantifiable until run time, and only then is the
107 * necessary code is written. The standard says we should say
108 * something about this issue in the documentation...
110 * FUNCTIONS: The CLOCKs structure defines possible functions to
111 * handle various clock functions.
113 * The standard POSIX timer management code assumes the
114 * following: 1.) The k_itimer struct (sched.h) is used for
115 * the timer. 2.) The list, it_lock, it_clock, it_id and
116 * it_pid fields are not modified by timer code.
118 * Permissions: It is assumed that the clock_settime() function defined
119 * for each clock will take care of permission checks. Some
120 * clocks may be set able by any user (i.e. local process
121 * clocks) others not. Currently the only set able clock we
122 * have is CLOCK_REALTIME and its high res counter part, both of
123 * which we beg off on and pass to do_sys_settimeofday().
126 static struct k_clock posix_clocks
[MAX_CLOCKS
];
129 * These ones are defined below.
131 static int common_nsleep(const clockid_t
, int flags
, struct timespec
*t
,
132 struct timespec __user
*rmtp
);
133 static int common_timer_create(struct k_itimer
*new_timer
);
134 static void common_timer_get(struct k_itimer
*, struct itimerspec
*);
135 static int common_timer_set(struct k_itimer
*, int,
136 struct itimerspec
*, struct itimerspec
*);
137 static int common_timer_del(struct k_itimer
*timer
);
139 static enum hrtimer_restart
posix_timer_fn(struct hrtimer
*data
);
141 static struct k_itimer
*__lock_timer(timer_t timer_id
, unsigned long *flags
);
143 #define lock_timer(tid, flags) \
144 ({ struct k_itimer *__timr; \
145 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \
149 static int hash(struct signal_struct
*sig
, unsigned int nr
)
151 return hash_32(hash32_ptr(sig
) ^ nr
, HASH_BITS(posix_timers_hashtable
));
154 static struct k_itimer
*__posix_timers_find(struct hlist_head
*head
,
155 struct signal_struct
*sig
,
158 struct k_itimer
*timer
;
160 hlist_for_each_entry_rcu(timer
, head
, t_hash
) {
161 if ((timer
->it_signal
== sig
) && (timer
->it_id
== id
))
167 static struct k_itimer
*posix_timer_by_id(timer_t id
)
169 struct signal_struct
*sig
= current
->signal
;
170 struct hlist_head
*head
= &posix_timers_hashtable
[hash(sig
, id
)];
172 return __posix_timers_find(head
, sig
, id
);
175 static int posix_timer_add(struct k_itimer
*timer
)
177 struct signal_struct
*sig
= current
->signal
;
178 int first_free_id
= sig
->posix_timer_id
;
179 struct hlist_head
*head
;
183 spin_lock(&hash_lock
);
184 head
= &posix_timers_hashtable
[hash(sig
, sig
->posix_timer_id
)];
185 if (!__posix_timers_find(head
, sig
, sig
->posix_timer_id
)) {
186 hlist_add_head_rcu(&timer
->t_hash
, head
);
187 ret
= sig
->posix_timer_id
;
189 if (++sig
->posix_timer_id
< 0)
190 sig
->posix_timer_id
= 0;
191 if ((sig
->posix_timer_id
== first_free_id
) && (ret
== -ENOENT
))
192 /* Loop over all possible ids completed */
194 spin_unlock(&hash_lock
);
195 } while (ret
== -ENOENT
);
199 static inline void unlock_timer(struct k_itimer
*timr
, unsigned long flags
)
201 spin_unlock_irqrestore(&timr
->it_lock
, flags
);
204 /* Get clock_realtime */
205 static int posix_clock_realtime_get(clockid_t which_clock
, struct timespec
*tp
)
207 ktime_get_real_ts(tp
);
211 /* Set clock_realtime */
212 static int posix_clock_realtime_set(const clockid_t which_clock
,
213 const struct timespec
*tp
)
215 return do_sys_settimeofday(tp
, NULL
);
218 static int posix_clock_realtime_adj(const clockid_t which_clock
,
221 return do_adjtimex(t
);
225 * Get monotonic time for posix timers
227 static int posix_ktime_get_ts(clockid_t which_clock
, struct timespec
*tp
)
234 * Get monotonic-raw time for posix timers
236 static int posix_get_monotonic_raw(clockid_t which_clock
, struct timespec
*tp
)
243 static int posix_get_realtime_coarse(clockid_t which_clock
, struct timespec
*tp
)
245 *tp
= current_kernel_time();
249 static int posix_get_monotonic_coarse(clockid_t which_clock
,
252 *tp
= get_monotonic_coarse();
256 static int posix_get_coarse_res(const clockid_t which_clock
, struct timespec
*tp
)
258 *tp
= ktime_to_timespec(KTIME_LOW_RES
);
262 static int posix_get_boottime(const clockid_t which_clock
, struct timespec
*tp
)
264 get_monotonic_boottime(tp
);
268 static int posix_get_tai(clockid_t which_clock
, struct timespec
*tp
)
270 timekeeping_clocktai(tp
);
275 * Initialize everything, well, just everything in Posix clocks/timers ;)
277 static __init
int init_posix_timers(void)
279 struct k_clock clock_realtime
= {
280 .clock_getres
= hrtimer_get_res
,
281 .clock_get
= posix_clock_realtime_get
,
282 .clock_set
= posix_clock_realtime_set
,
283 .clock_adj
= posix_clock_realtime_adj
,
284 .nsleep
= common_nsleep
,
285 .nsleep_restart
= hrtimer_nanosleep_restart
,
286 .timer_create
= common_timer_create
,
287 .timer_set
= common_timer_set
,
288 .timer_get
= common_timer_get
,
289 .timer_del
= common_timer_del
,
291 struct k_clock clock_monotonic
= {
292 .clock_getres
= hrtimer_get_res
,
293 .clock_get
= posix_ktime_get_ts
,
294 .nsleep
= common_nsleep
,
295 .nsleep_restart
= hrtimer_nanosleep_restart
,
296 .timer_create
= common_timer_create
,
297 .timer_set
= common_timer_set
,
298 .timer_get
= common_timer_get
,
299 .timer_del
= common_timer_del
,
301 struct k_clock clock_monotonic_raw
= {
302 .clock_getres
= hrtimer_get_res
,
303 .clock_get
= posix_get_monotonic_raw
,
305 struct k_clock clock_realtime_coarse
= {
306 .clock_getres
= posix_get_coarse_res
,
307 .clock_get
= posix_get_realtime_coarse
,
309 struct k_clock clock_monotonic_coarse
= {
310 .clock_getres
= posix_get_coarse_res
,
311 .clock_get
= posix_get_monotonic_coarse
,
313 struct k_clock clock_tai
= {
314 .clock_getres
= hrtimer_get_res
,
315 .clock_get
= posix_get_tai
,
316 .nsleep
= common_nsleep
,
317 .nsleep_restart
= hrtimer_nanosleep_restart
,
318 .timer_create
= common_timer_create
,
319 .timer_set
= common_timer_set
,
320 .timer_get
= common_timer_get
,
321 .timer_del
= common_timer_del
,
323 struct k_clock clock_boottime
= {
324 .clock_getres
= hrtimer_get_res
,
325 .clock_get
= posix_get_boottime
,
326 .nsleep
= common_nsleep
,
327 .nsleep_restart
= hrtimer_nanosleep_restart
,
328 .timer_create
= common_timer_create
,
329 .timer_set
= common_timer_set
,
330 .timer_get
= common_timer_get
,
331 .timer_del
= common_timer_del
,
334 posix_timers_register_clock(CLOCK_REALTIME
, &clock_realtime
);
335 posix_timers_register_clock(CLOCK_MONOTONIC
, &clock_monotonic
);
336 posix_timers_register_clock(CLOCK_MONOTONIC_RAW
, &clock_monotonic_raw
);
337 posix_timers_register_clock(CLOCK_REALTIME_COARSE
, &clock_realtime_coarse
);
338 posix_timers_register_clock(CLOCK_MONOTONIC_COARSE
, &clock_monotonic_coarse
);
339 posix_timers_register_clock(CLOCK_BOOTTIME
, &clock_boottime
);
340 posix_timers_register_clock(CLOCK_TAI
, &clock_tai
);
342 posix_timers_cache
= kmem_cache_create("posix_timers_cache",
343 sizeof (struct k_itimer
), 0, SLAB_PANIC
,
348 __initcall(init_posix_timers
);
351 * The siginfo si_overrun field and the return value of timer_getoverrun(2)
352 * are of type int. Clamp the overrun value to INT_MAX
354 static inline int timer_overrun_to_int(struct k_itimer
*timr
, int baseval
)
356 s64 sum
= timr
->it_overrun_last
+ (s64
)baseval
;
358 return sum
> (s64
)INT_MAX
? INT_MAX
: (int)sum
;
361 static void schedule_next_timer(struct k_itimer
*timr
)
363 struct hrtimer
*timer
= &timr
->it
.real
.timer
;
365 if (timr
->it
.real
.interval
.tv64
== 0)
368 timr
->it_overrun
+= hrtimer_forward(timer
, timer
->base
->get_time(),
369 timr
->it
.real
.interval
);
371 timr
->it_overrun_last
= timr
->it_overrun
;
372 timr
->it_overrun
= -1LL;
373 ++timr
->it_requeue_pending
;
374 hrtimer_restart(timer
);
378 * This function is exported for use by the signal deliver code. It is
379 * called just prior to the info block being released and passes that
380 * block to us. It's function is to update the overrun entry AND to
381 * restart the timer. It should only be called if the timer is to be
382 * restarted (i.e. we have flagged this in the sys_private entry of the
385 * To protect against the timer going away while the interrupt is queued,
386 * we require that the it_requeue_pending flag be set.
388 void do_schedule_next_timer(struct siginfo
*info
)
390 struct k_itimer
*timr
;
393 timr
= lock_timer(info
->si_tid
, &flags
);
395 if (timr
&& timr
->it_requeue_pending
== info
->si_sys_private
) {
396 if (timr
->it_clock
< 0)
397 posix_cpu_timer_schedule(timr
);
399 schedule_next_timer(timr
);
401 info
->si_overrun
= timer_overrun_to_int(timr
, info
->si_overrun
);
405 unlock_timer(timr
, flags
);
408 int posix_timer_event(struct k_itimer
*timr
, int si_private
)
410 struct task_struct
*task
;
411 int shared
, ret
= -1;
413 * FIXME: if ->sigq is queued we can race with
414 * dequeue_signal()->do_schedule_next_timer().
416 * If dequeue_signal() sees the "right" value of
417 * si_sys_private it calls do_schedule_next_timer().
418 * We re-queue ->sigq and drop ->it_lock().
419 * do_schedule_next_timer() locks the timer
420 * and re-schedules it while ->sigq is pending.
421 * Not really bad, but not that we want.
423 timr
->sigq
->info
.si_sys_private
= si_private
;
426 task
= pid_task(timr
->it_pid
, PIDTYPE_PID
);
428 shared
= !(timr
->it_sigev_notify
& SIGEV_THREAD_ID
);
429 ret
= send_sigqueue(timr
->sigq
, task
, shared
);
432 /* If we failed to send the signal the timer stops. */
435 EXPORT_SYMBOL_GPL(posix_timer_event
);
438 * This function gets called when a POSIX.1b interval timer expires. It
439 * is used as a callback from the kernel internal timer. The
440 * run_timer_list code ALWAYS calls with interrupts on.
442 * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
444 static enum hrtimer_restart
posix_timer_fn(struct hrtimer
*timer
)
446 struct k_itimer
*timr
;
449 enum hrtimer_restart ret
= HRTIMER_NORESTART
;
451 timr
= container_of(timer
, struct k_itimer
, it
.real
.timer
);
452 spin_lock_irqsave(&timr
->it_lock
, flags
);
454 if (timr
->it
.real
.interval
.tv64
!= 0)
455 si_private
= ++timr
->it_requeue_pending
;
457 if (posix_timer_event(timr
, si_private
)) {
459 * signal was not sent because of sig_ignor
460 * we will not get a call back to restart it AND
461 * it should be restarted.
463 if (timr
->it
.real
.interval
.tv64
!= 0) {
464 ktime_t now
= hrtimer_cb_get_time(timer
);
467 * FIXME: What we really want, is to stop this
468 * timer completely and restart it in case the
469 * SIG_IGN is removed. This is a non trivial
470 * change which involves sighand locking
471 * (sigh !), which we don't want to do late in
474 * For now we just let timers with an interval
475 * less than a jiffie expire every jiffie to
476 * avoid softirq starvation in case of SIG_IGN
477 * and a very small interval, which would put
478 * the timer right back on the softirq pending
479 * list. By moving now ahead of time we trick
480 * hrtimer_forward() to expire the timer
481 * later, while we still maintain the overrun
482 * accuracy, but have some inconsistency in
483 * the timer_gettime() case. This is at least
484 * better than a starved softirq. A more
485 * complex fix which solves also another related
486 * inconsistency is already in the pipeline.
488 #ifdef CONFIG_HIGH_RES_TIMERS
490 ktime_t kj
= ktime_set(0, NSEC_PER_SEC
/ HZ
);
492 if (timr
->it
.real
.interval
.tv64
< kj
.tv64
)
493 now
= ktime_add(now
, kj
);
496 timr
->it_overrun
+= hrtimer_forward(timer
, now
,
497 timr
->it
.real
.interval
);
498 ret
= HRTIMER_RESTART
;
499 ++timr
->it_requeue_pending
;
503 unlock_timer(timr
, flags
);
507 static struct pid
*good_sigevent(sigevent_t
* event
)
509 struct task_struct
*rtn
= current
->group_leader
;
511 switch (event
->sigev_notify
) {
512 case SIGEV_SIGNAL
| SIGEV_THREAD_ID
:
513 rtn
= find_task_by_vpid(event
->sigev_notify_thread_id
);
514 if (!rtn
|| !same_thread_group(rtn
, current
))
519 if (event
->sigev_signo
<= 0 || event
->sigev_signo
> SIGRTMAX
)
523 return task_pid(rtn
);
529 void posix_timers_register_clock(const clockid_t clock_id
,
530 struct k_clock
*new_clock
)
532 if ((unsigned) clock_id
>= MAX_CLOCKS
) {
533 printk(KERN_WARNING
"POSIX clock register failed for clock_id %d\n",
538 if (!new_clock
->clock_get
) {
539 printk(KERN_WARNING
"POSIX clock id %d lacks clock_get()\n",
543 if (!new_clock
->clock_getres
) {
544 printk(KERN_WARNING
"POSIX clock id %d lacks clock_getres()\n",
549 posix_clocks
[clock_id
] = *new_clock
;
551 EXPORT_SYMBOL_GPL(posix_timers_register_clock
);
553 static struct k_itimer
* alloc_posix_timer(void)
555 struct k_itimer
*tmr
;
556 tmr
= kmem_cache_zalloc(posix_timers_cache
, GFP_KERNEL
);
559 if (unlikely(!(tmr
->sigq
= sigqueue_alloc()))) {
560 kmem_cache_free(posix_timers_cache
, tmr
);
563 memset(&tmr
->sigq
->info
, 0, sizeof(siginfo_t
));
567 static void k_itimer_rcu_free(struct rcu_head
*head
)
569 struct k_itimer
*tmr
= container_of(head
, struct k_itimer
, it
.rcu
);
571 kmem_cache_free(posix_timers_cache
, tmr
);
575 #define IT_ID_NOT_SET 0
576 static void release_posix_timer(struct k_itimer
*tmr
, int it_id_set
)
580 spin_lock_irqsave(&hash_lock
, flags
);
581 hlist_del_rcu(&tmr
->t_hash
);
582 spin_unlock_irqrestore(&hash_lock
, flags
);
584 put_pid(tmr
->it_pid
);
585 sigqueue_free(tmr
->sigq
);
586 call_rcu(&tmr
->it
.rcu
, k_itimer_rcu_free
);
589 static struct k_clock
*clockid_to_kclock(const clockid_t id
)
595 return (id
& CLOCKFD_MASK
) == CLOCKFD
?
596 &clock_posix_dynamic
: &clock_posix_cpu
;
599 if (id
>= ARRAY_SIZE(posix_clocks
))
602 kc
= &posix_clocks
[array_index_nospec(idx
, ARRAY_SIZE(posix_clocks
))];
603 if (!kc
->clock_getres
)
608 static int common_timer_create(struct k_itimer
*new_timer
)
610 hrtimer_init(&new_timer
->it
.real
.timer
, new_timer
->it_clock
, 0);
614 /* Create a POSIX.1b interval timer. */
616 SYSCALL_DEFINE3(timer_create
, const clockid_t
, which_clock
,
617 struct sigevent __user
*, timer_event_spec
,
618 timer_t __user
*, created_timer_id
)
620 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
621 struct k_itimer
*new_timer
;
622 int error
, new_timer_id
;
624 int it_id_set
= IT_ID_NOT_SET
;
628 if (!kc
->timer_create
)
631 new_timer
= alloc_posix_timer();
632 if (unlikely(!new_timer
))
635 spin_lock_init(&new_timer
->it_lock
);
636 new_timer_id
= posix_timer_add(new_timer
);
637 if (new_timer_id
< 0) {
638 error
= new_timer_id
;
642 it_id_set
= IT_ID_SET
;
643 new_timer
->it_id
= (timer_t
) new_timer_id
;
644 new_timer
->it_clock
= which_clock
;
645 new_timer
->it_overrun
= -1LL;
647 if (timer_event_spec
) {
648 if (copy_from_user(&event
, timer_event_spec
, sizeof (event
))) {
653 new_timer
->it_pid
= get_pid(good_sigevent(&event
));
655 if (!new_timer
->it_pid
) {
660 memset(&event
.sigev_value
, 0, sizeof(event
.sigev_value
));
661 event
.sigev_notify
= SIGEV_SIGNAL
;
662 event
.sigev_signo
= SIGALRM
;
663 event
.sigev_value
.sival_int
= new_timer
->it_id
;
664 new_timer
->it_pid
= get_pid(task_tgid(current
));
667 new_timer
->it_sigev_notify
= event
.sigev_notify
;
668 new_timer
->sigq
->info
.si_signo
= event
.sigev_signo
;
669 new_timer
->sigq
->info
.si_value
= event
.sigev_value
;
670 new_timer
->sigq
->info
.si_tid
= new_timer
->it_id
;
671 new_timer
->sigq
->info
.si_code
= SI_TIMER
;
673 if (copy_to_user(created_timer_id
,
674 &new_timer_id
, sizeof (new_timer_id
))) {
679 error
= kc
->timer_create(new_timer
);
683 spin_lock_irq(¤t
->sighand
->siglock
);
684 new_timer
->it_signal
= current
->signal
;
685 list_add(&new_timer
->list
, ¤t
->signal
->posix_timers
);
686 spin_unlock_irq(¤t
->sighand
->siglock
);
690 * In the case of the timer belonging to another task, after
691 * the task is unlocked, the timer is owned by the other task
692 * and may cease to exist at any time. Don't use or modify
693 * new_timer after the unlock call.
696 release_posix_timer(new_timer
, it_id_set
);
701 * Locking issues: We need to protect the result of the id look up until
702 * we get the timer locked down so it is not deleted under us. The
703 * removal is done under the idr spinlock so we use that here to bridge
704 * the find to the timer lock. To avoid a dead lock, the timer id MUST
705 * be release with out holding the timer lock.
707 static struct k_itimer
*__lock_timer(timer_t timer_id
, unsigned long *flags
)
709 struct k_itimer
*timr
;
712 * timer_t could be any type >= int and we want to make sure any
713 * @timer_id outside positive int range fails lookup.
715 if ((unsigned long long)timer_id
> INT_MAX
)
719 timr
= posix_timer_by_id(timer_id
);
721 spin_lock_irqsave(&timr
->it_lock
, *flags
);
722 if (timr
->it_signal
== current
->signal
) {
726 spin_unlock_irqrestore(&timr
->it_lock
, *flags
);
734 * Get the time remaining on a POSIX.1b interval timer. This function
735 * is ALWAYS called with spin_lock_irq on the timer, thus it must not
738 * We have a couple of messes to clean up here. First there is the case
739 * of a timer that has a requeue pending. These timers should appear to
740 * be in the timer list with an expiry as if we were to requeue them
743 * The second issue is the SIGEV_NONE timer which may be active but is
744 * not really ever put in the timer list (to save system resources).
745 * This timer may be expired, and if so, we will do it here. Otherwise
746 * it is the same as a requeue pending timer WRT to what we should
750 common_timer_get(struct k_itimer
*timr
, struct itimerspec
*cur_setting
)
752 ktime_t now
, remaining
, iv
;
753 struct hrtimer
*timer
= &timr
->it
.real
.timer
;
756 memset(cur_setting
, 0, sizeof(struct itimerspec
));
758 sig_none
= timr
->it_sigev_notify
== SIGEV_NONE
;
759 iv
= timr
->it
.real
.interval
;
761 /* interval timer ? */
763 cur_setting
->it_interval
= ktime_to_timespec(iv
);
764 else if (!hrtimer_active(timer
) && !sig_none
)
767 now
= timer
->base
->get_time();
770 * When a requeue is pending or this is a SIGEV_NONE
771 * timer move the expiry time forward by intervals, so
774 if (iv
.tv64
&& (timr
->it_requeue_pending
& REQUEUE_PENDING
|| sig_none
))
775 timr
->it_overrun
+= hrtimer_forward(timer
, now
, iv
);
777 remaining
= ktime_sub(hrtimer_get_expires(timer
), now
);
778 /* Return 0 only, when the timer is expired and not pending */
779 if (remaining
.tv64
<= 0) {
781 * A single shot SIGEV_NONE timer must return 0, when
785 cur_setting
->it_value
.tv_nsec
= 1;
787 cur_setting
->it_value
= ktime_to_timespec(remaining
);
790 /* Get the time remaining on a POSIX.1b interval timer. */
791 SYSCALL_DEFINE2(timer_gettime
, timer_t
, timer_id
,
792 struct itimerspec __user
*, setting
)
794 struct itimerspec cur_setting
;
795 struct k_itimer
*timr
;
800 timr
= lock_timer(timer_id
, &flags
);
804 kc
= clockid_to_kclock(timr
->it_clock
);
805 if (WARN_ON_ONCE(!kc
|| !kc
->timer_get
))
808 kc
->timer_get(timr
, &cur_setting
);
810 unlock_timer(timr
, flags
);
812 if (!ret
&& copy_to_user(setting
, &cur_setting
, sizeof (cur_setting
)))
819 * Get the number of overruns of a POSIX.1b interval timer. This is to
820 * be the overrun of the timer last delivered. At the same time we are
821 * accumulating overruns on the next timer. The overrun is frozen when
822 * the signal is delivered, either at the notify time (if the info block
823 * is not queued) or at the actual delivery time (as we are informed by
824 * the call back to do_schedule_next_timer(). So all we need to do is
825 * to pick up the frozen overrun.
827 SYSCALL_DEFINE1(timer_getoverrun
, timer_t
, timer_id
)
829 struct k_itimer
*timr
;
833 timr
= lock_timer(timer_id
, &flags
);
837 overrun
= timer_overrun_to_int(timr
, 0);
838 unlock_timer(timr
, flags
);
843 /* Set a POSIX.1b interval timer. */
844 /* timr->it_lock is taken. */
846 common_timer_set(struct k_itimer
*timr
, int flags
,
847 struct itimerspec
*new_setting
, struct itimerspec
*old_setting
)
849 struct hrtimer
*timer
= &timr
->it
.real
.timer
;
850 enum hrtimer_mode mode
;
853 common_timer_get(timr
, old_setting
);
855 /* disable the timer */
856 timr
->it
.real
.interval
.tv64
= 0;
858 * careful here. If smp we could be in the "fire" routine which will
859 * be spinning as we hold the lock. But this is ONLY an SMP issue.
861 if (hrtimer_try_to_cancel(timer
) < 0)
864 timr
->it_requeue_pending
= (timr
->it_requeue_pending
+ 2) &
866 timr
->it_overrun_last
= 0;
868 /* switch off the timer when it_value is zero */
869 if (!new_setting
->it_value
.tv_sec
&& !new_setting
->it_value
.tv_nsec
)
872 mode
= flags
& TIMER_ABSTIME
? HRTIMER_MODE_ABS
: HRTIMER_MODE_REL
;
873 hrtimer_init(&timr
->it
.real
.timer
, timr
->it_clock
, mode
);
874 timr
->it
.real
.timer
.function
= posix_timer_fn
;
876 hrtimer_set_expires(timer
, timespec_to_ktime(new_setting
->it_value
));
878 /* Convert interval */
879 timr
->it
.real
.interval
= timespec_to_ktime(new_setting
->it_interval
);
881 /* SIGEV_NONE timers are not queued ! See common_timer_get */
882 if (timr
->it_sigev_notify
== SIGEV_NONE
) {
883 /* Setup correct expiry time for relative timers */
884 if (mode
== HRTIMER_MODE_REL
) {
885 hrtimer_add_expires(timer
, timer
->base
->get_time());
890 hrtimer_start_expires(timer
, mode
);
894 /* Set a POSIX.1b interval timer */
895 SYSCALL_DEFINE4(timer_settime
, timer_t
, timer_id
, int, flags
,
896 const struct itimerspec __user
*, new_setting
,
897 struct itimerspec __user
*, old_setting
)
899 struct k_itimer
*timr
;
900 struct itimerspec new_spec
, old_spec
;
903 struct itimerspec
*rtn
= old_setting
? &old_spec
: NULL
;
909 if (copy_from_user(&new_spec
, new_setting
, sizeof (new_spec
)))
912 if (!timespec_valid(&new_spec
.it_interval
) ||
913 !timespec_valid(&new_spec
.it_value
))
916 timr
= lock_timer(timer_id
, &flag
);
920 kc
= clockid_to_kclock(timr
->it_clock
);
921 if (WARN_ON_ONCE(!kc
|| !kc
->timer_set
))
924 error
= kc
->timer_set(timr
, flags
, &new_spec
, rtn
);
926 unlock_timer(timr
, flag
);
927 if (error
== TIMER_RETRY
) {
928 rtn
= NULL
; // We already got the old time...
932 if (old_setting
&& !error
&&
933 copy_to_user(old_setting
, &old_spec
, sizeof (old_spec
)))
939 static int common_timer_del(struct k_itimer
*timer
)
941 timer
->it
.real
.interval
.tv64
= 0;
943 if (hrtimer_try_to_cancel(&timer
->it
.real
.timer
) < 0)
948 static inline int timer_delete_hook(struct k_itimer
*timer
)
950 struct k_clock
*kc
= clockid_to_kclock(timer
->it_clock
);
952 if (WARN_ON_ONCE(!kc
|| !kc
->timer_del
))
954 return kc
->timer_del(timer
);
957 /* Delete a POSIX.1b interval timer. */
958 SYSCALL_DEFINE1(timer_delete
, timer_t
, timer_id
)
960 struct k_itimer
*timer
;
964 timer
= lock_timer(timer_id
, &flags
);
968 if (timer_delete_hook(timer
) == TIMER_RETRY
) {
969 unlock_timer(timer
, flags
);
973 spin_lock(¤t
->sighand
->siglock
);
974 list_del(&timer
->list
);
975 spin_unlock(¤t
->sighand
->siglock
);
977 * This keeps any tasks waiting on the spin lock from thinking
978 * they got something (see the lock code above).
980 timer
->it_signal
= NULL
;
982 unlock_timer(timer
, flags
);
983 release_posix_timer(timer
, IT_ID_SET
);
988 * return timer owned by the process, used by exit_itimers
990 static void itimer_delete(struct k_itimer
*timer
)
995 spin_lock_irqsave(&timer
->it_lock
, flags
);
997 if (timer_delete_hook(timer
) == TIMER_RETRY
) {
998 unlock_timer(timer
, flags
);
1001 list_del(&timer
->list
);
1003 * This keeps any tasks waiting on the spin lock from thinking
1004 * they got something (see the lock code above).
1006 timer
->it_signal
= NULL
;
1008 unlock_timer(timer
, flags
);
1009 release_posix_timer(timer
, IT_ID_SET
);
1013 * This is called by do_exit or de_thread, only when there are no more
1014 * references to the shared signal_struct.
1016 void exit_itimers(struct signal_struct
*sig
)
1018 struct k_itimer
*tmr
;
1020 while (!list_empty(&sig
->posix_timers
)) {
1021 tmr
= list_entry(sig
->posix_timers
.next
, struct k_itimer
, list
);
1026 SYSCALL_DEFINE2(clock_settime
, const clockid_t
, which_clock
,
1027 const struct timespec __user
*, tp
)
1029 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
1030 struct timespec new_tp
;
1032 if (!kc
|| !kc
->clock_set
)
1035 if (copy_from_user(&new_tp
, tp
, sizeof (*tp
)))
1038 return kc
->clock_set(which_clock
, &new_tp
);
1041 SYSCALL_DEFINE2(clock_gettime
, const clockid_t
, which_clock
,
1042 struct timespec __user
*,tp
)
1044 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
1045 struct timespec kernel_tp
;
1051 error
= kc
->clock_get(which_clock
, &kernel_tp
);
1053 if (!error
&& copy_to_user(tp
, &kernel_tp
, sizeof (kernel_tp
)))
1059 SYSCALL_DEFINE2(clock_adjtime
, const clockid_t
, which_clock
,
1060 struct timex __user
*, utx
)
1062 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
1071 if (copy_from_user(&ktx
, utx
, sizeof(ktx
)))
1074 err
= kc
->clock_adj(which_clock
, &ktx
);
1076 if (err
>= 0 && copy_to_user(utx
, &ktx
, sizeof(ktx
)))
1082 SYSCALL_DEFINE2(clock_getres
, const clockid_t
, which_clock
,
1083 struct timespec __user
*, tp
)
1085 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
1086 struct timespec rtn_tp
;
1092 error
= kc
->clock_getres(which_clock
, &rtn_tp
);
1094 if (!error
&& tp
&& copy_to_user(tp
, &rtn_tp
, sizeof (rtn_tp
)))
1101 * nanosleep for monotonic and realtime clocks
1103 static int common_nsleep(const clockid_t which_clock
, int flags
,
1104 struct timespec
*tsave
, struct timespec __user
*rmtp
)
1106 return hrtimer_nanosleep(tsave
, rmtp
, flags
& TIMER_ABSTIME
?
1107 HRTIMER_MODE_ABS
: HRTIMER_MODE_REL
,
1111 SYSCALL_DEFINE4(clock_nanosleep
, const clockid_t
, which_clock
, int, flags
,
1112 const struct timespec __user
*, rqtp
,
1113 struct timespec __user
*, rmtp
)
1115 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
1121 return -ENANOSLEEP_NOTSUP
;
1123 if (copy_from_user(&t
, rqtp
, sizeof (struct timespec
)))
1126 if (!timespec_valid(&t
))
1129 return kc
->nsleep(which_clock
, flags
, &t
, rmtp
);
1133 * This will restart clock_nanosleep. This is required only by
1134 * compat_clock_nanosleep_restart for now.
1136 long clock_nanosleep_restart(struct restart_block
*restart_block
)
1138 clockid_t which_clock
= restart_block
->nanosleep
.clockid
;
1139 struct k_clock
*kc
= clockid_to_kclock(which_clock
);
1141 if (WARN_ON_ONCE(!kc
|| !kc
->nsleep_restart
))
1144 return kc
->nsleep_restart(restart_block
);