mm/page_alloc: prevent merging between isolated and other pageblocks
[linux-2.6-block.git] / kernel / time / posix-timers.c
CommitLineData
1da177e4 1/*
f30c2269 2 * linux/kernel/posix-timers.c
1da177e4
LT
3 *
4 *
5 * 2002-10-15 Posix Clocks & timers
6 * by George Anzinger george@mvista.com
7 *
8 * Copyright (C) 2002 2003 by MontaVista Software.
9 *
10 * 2004-06-01 Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
11 * Copyright (C) 2004 Boris Hu
12 *
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.
17 *
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.
22
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.
26 *
27 * MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA
28 */
29
30/* These are all the functions necessary to implement
31 * POSIX clocks & timers
32 */
33#include <linux/mm.h>
1da177e4
LT
34#include <linux/interrupt.h>
35#include <linux/slab.h>
36#include <linux/time.h>
97d1f15b 37#include <linux/mutex.h>
1da177e4
LT
38
39#include <asm/uaccess.h>
1da177e4
LT
40#include <linux/list.h>
41#include <linux/init.h>
42#include <linux/compiler.h>
5ed67f05 43#include <linux/hash.h>
0606f422 44#include <linux/posix-clock.h>
1da177e4
LT
45#include <linux/posix-timers.h>
46#include <linux/syscalls.h>
47#include <linux/wait.h>
48#include <linux/workqueue.h>
9984de1a 49#include <linux/export.h>
5ed67f05 50#include <linux/hashtable.h>
1da177e4 51
8b094cd0
TG
52#include "timekeeping.h"
53
1da177e4 54/*
5ed67f05
PE
55 * Management arrays for POSIX timers. Timers are now kept in static hash table
56 * with 512 entries.
57 * Timer ids are allocated by local routine, which selects proper hash head by
58 * key, constructed from current->signal address and per signal struct counter.
59 * This keeps timer ids unique per process, but now they can intersect between
60 * processes.
1da177e4
LT
61 */
62
63/*
64 * Lets keep our timers in a slab cache :-)
65 */
e18b890b 66static struct kmem_cache *posix_timers_cache;
5ed67f05
PE
67
68static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
69static DEFINE_SPINLOCK(hash_lock);
1da177e4 70
1da177e4
LT
71/*
72 * we assume that the new SIGEV_THREAD_ID shares no bits with the other
73 * SIGEV values. Here we put out an error if this assumption fails.
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
65da528d
TG
80/*
81 * parisc wants ENOTSUP instead of EOPNOTSUPP
82 */
83#ifndef ENOTSUP
84# define ENANOSLEEP_NOTSUP EOPNOTSUPP
85#else
86# define ENANOSLEEP_NOTSUP ENOTSUP
87#endif
1da177e4
LT
88
89/*
90 * The timer ID is turned into a timer address by idr_find().
91 * Verifying a valid ID consists of:
92 *
93 * a) checking that idr_find() returns other than -1.
94 * b) checking that the timer id matches the one in the timer itself.
95 * c) that the timer owner is in the callers thread group.
96 */
97
98/*
99 * CLOCKs: The POSIX standard calls for a couple of clocks and allows us
100 * to implement others. This structure defines the various
0061748d 101 * clocks.
1da177e4
LT
102 *
103 * RESOLUTION: Clock resolution is used to round up timer and interval
104 * times, NOT to report clock times, which are reported with as
105 * much resolution as the system can muster. In some cases this
106 * resolution may depend on the underlying clock hardware and
107 * may not be quantifiable until run time, and only then is the
108 * necessary code is written. The standard says we should say
109 * something about this issue in the documentation...
110 *
0061748d
RC
111 * FUNCTIONS: The CLOCKs structure defines possible functions to
112 * handle various clock functions.
1da177e4 113 *
0061748d
RC
114 * The standard POSIX timer management code assumes the
115 * following: 1.) The k_itimer struct (sched.h) is used for
116 * the timer. 2.) The list, it_lock, it_clock, it_id and
117 * it_pid fields are not modified by timer code.
1da177e4
LT
118 *
119 * Permissions: It is assumed that the clock_settime() function defined
120 * for each clock will take care of permission checks. Some
121 * clocks may be set able by any user (i.e. local process
122 * clocks) others not. Currently the only set able clock we
123 * have is CLOCK_REALTIME and its high res counter part, both of
124 * which we beg off on and pass to do_sys_settimeofday().
125 */
126
127static struct k_clock posix_clocks[MAX_CLOCKS];
becf8b5d 128
1da177e4 129/*
becf8b5d 130 * These ones are defined below.
1da177e4 131 */
becf8b5d
TG
132static int common_nsleep(const clockid_t, int flags, struct timespec *t,
133 struct timespec __user *rmtp);
838394fb 134static int common_timer_create(struct k_itimer *new_timer);
becf8b5d
TG
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);
1da177e4 139
c9cb2e3d 140static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
1da177e4 141
20f33a03
NK
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})
1da177e4 149
5ed67f05
PE
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{
5ed67f05
PE
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 /* Loop over all possible ids completed */
194 ret = -EAGAIN;
195 spin_unlock(&hash_lock);
196 } while (ret == -ENOENT);
197 return ret;
198}
199
1da177e4
LT
200static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
201{
202 spin_unlock_irqrestore(&timr->it_lock, flags);
203}
204
42285777
TG
205/* Get clock_realtime */
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
26f9a479
TG
212/* Set clock_realtime */
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
f1f1d5eb
RC
219static int posix_clock_realtime_adj(const clockid_t which_clock,
220 struct timex *t)
221{
222 return do_adjtimex(t);
223}
224
becf8b5d
TG
225/*
226 * Get monotonic time for posix timers
227 */
228static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp)
229{
230 ktime_get_ts(tp);
231 return 0;
232}
1da177e4 233
2d42244a 234/*
7fdd7f89 235 * Get monotonic-raw time for posix timers
2d42244a
JS
236 */
237static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp)
238{
239 getrawmonotonic(tp);
240 return 0;
241}
242
da15cfda 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
6622e670 257static int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp)
da15cfda 258{
259 *tp = ktime_to_timespec(KTIME_LOW_RES);
260 return 0;
261}
7fdd7f89
JS
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
1ff3c967
JS
269static int posix_get_tai(clockid_t which_clock, struct timespec *tp)
270{
271 timekeeping_clocktai(tp);
272 return 0;
273}
7fdd7f89 274
056a3cac
TG
275static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec *tp)
276{
277 tp->tv_sec = 0;
278 tp->tv_nsec = hrtimer_resolution;
279 return 0;
280}
281
1da177e4
LT
282/*
283 * Initialize everything, well, just everything in Posix clocks/timers ;)
284 */
285static __init int init_posix_timers(void)
286{
becf8b5d 287 struct k_clock clock_realtime = {
056a3cac 288 .clock_getres = posix_get_hrtimer_res,
42285777 289 .clock_get = posix_clock_realtime_get,
26f9a479 290 .clock_set = posix_clock_realtime_set,
f1f1d5eb 291 .clock_adj = posix_clock_realtime_adj,
a5cd2880 292 .nsleep = common_nsleep,
59bd5bc2 293 .nsleep_restart = hrtimer_nanosleep_restart,
838394fb 294 .timer_create = common_timer_create,
27722df1 295 .timer_set = common_timer_set,
a7319fa2 296 .timer_get = common_timer_get,
6761c670 297 .timer_del = common_timer_del,
1da177e4 298 };
becf8b5d 299 struct k_clock clock_monotonic = {
056a3cac 300 .clock_getres = posix_get_hrtimer_res,
2fd1f040 301 .clock_get = posix_ktime_get_ts,
a5cd2880 302 .nsleep = common_nsleep,
59bd5bc2 303 .nsleep_restart = hrtimer_nanosleep_restart,
838394fb 304 .timer_create = common_timer_create,
27722df1 305 .timer_set = common_timer_set,
a7319fa2 306 .timer_get = common_timer_get,
6761c670 307 .timer_del = common_timer_del,
1da177e4 308 };
2d42244a 309 struct k_clock clock_monotonic_raw = {
056a3cac 310 .clock_getres = posix_get_hrtimer_res,
2fd1f040 311 .clock_get = posix_get_monotonic_raw,
2d42244a 312 };
da15cfda 313 struct k_clock clock_realtime_coarse = {
2fd1f040
TG
314 .clock_getres = posix_get_coarse_res,
315 .clock_get = posix_get_realtime_coarse,
da15cfda 316 };
317 struct k_clock clock_monotonic_coarse = {
2fd1f040
TG
318 .clock_getres = posix_get_coarse_res,
319 .clock_get = posix_get_monotonic_coarse,
da15cfda 320 };
1ff3c967 321 struct k_clock clock_tai = {
056a3cac 322 .clock_getres = posix_get_hrtimer_res,
1ff3c967 323 .clock_get = posix_get_tai,
90adda98
JS
324 .nsleep = common_nsleep,
325 .nsleep_restart = hrtimer_nanosleep_restart,
326 .timer_create = common_timer_create,
327 .timer_set = common_timer_set,
328 .timer_get = common_timer_get,
329 .timer_del = common_timer_del,
1ff3c967 330 };
7fdd7f89 331 struct k_clock clock_boottime = {
056a3cac 332 .clock_getres = posix_get_hrtimer_res,
7fdd7f89
JS
333 .clock_get = posix_get_boottime,
334 .nsleep = common_nsleep,
335 .nsleep_restart = hrtimer_nanosleep_restart,
336 .timer_create = common_timer_create,
337 .timer_set = common_timer_set,
338 .timer_get = common_timer_get,
339 .timer_del = common_timer_del,
340 };
1da177e4 341
52708737
TG
342 posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime);
343 posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic);
344 posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
345 posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
346 posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
7fdd7f89 347 posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime);
1ff3c967 348 posix_timers_register_clock(CLOCK_TAI, &clock_tai);
1da177e4
LT
349
350 posix_timers_cache = kmem_cache_create("posix_timers_cache",
040b5c6f
AD
351 sizeof (struct k_itimer), 0, SLAB_PANIC,
352 NULL);
1da177e4
LT
353 return 0;
354}
355
356__initcall(init_posix_timers);
357
1da177e4
LT
358static void schedule_next_timer(struct k_itimer *timr)
359{
44f21475
RZ
360 struct hrtimer *timer = &timr->it.real.timer;
361
becf8b5d 362 if (timr->it.real.interval.tv64 == 0)
1da177e4
LT
363 return;
364
4d672e7a
DL
365 timr->it_overrun += (unsigned int) hrtimer_forward(timer,
366 timer->base->get_time(),
367 timr->it.real.interval);
44f21475 368
1da177e4
LT
369 timr->it_overrun_last = timr->it_overrun;
370 timr->it_overrun = -1;
371 ++timr->it_requeue_pending;
44f21475 372 hrtimer_restart(timer);
1da177e4
LT
373}
374
375/*
376 * This function is exported for use by the signal deliver code. It is
377 * called just prior to the info block being released and passes that
378 * block to us. It's function is to update the overrun entry AND to
379 * restart the timer. It should only be called if the timer is to be
380 * restarted (i.e. we have flagged this in the sys_private entry of the
381 * info block).
382 *
25985edc 383 * To protect against the timer going away while the interrupt is queued,
1da177e4
LT
384 * we require that the it_requeue_pending flag be set.
385 */
386void do_schedule_next_timer(struct siginfo *info)
387{
388 struct k_itimer *timr;
389 unsigned long flags;
390
391 timr = lock_timer(info->si_tid, &flags);
392
becf8b5d
TG
393 if (timr && timr->it_requeue_pending == info->si_sys_private) {
394 if (timr->it_clock < 0)
395 posix_cpu_timer_schedule(timr);
396 else
397 schedule_next_timer(timr);
1da177e4 398
54da1174 399 info->si_overrun += timr->it_overrun_last;
becf8b5d
TG
400 }
401
b6557fbc
TG
402 if (timr)
403 unlock_timer(timr, flags);
1da177e4
LT
404}
405
ba661292 406int posix_timer_event(struct k_itimer *timr, int si_private)
1da177e4 407{
27af4245
ON
408 struct task_struct *task;
409 int shared, ret = -1;
ba661292
ON
410 /*
411 * FIXME: if ->sigq is queued we can race with
412 * dequeue_signal()->do_schedule_next_timer().
413 *
414 * If dequeue_signal() sees the "right" value of
415 * si_sys_private it calls do_schedule_next_timer().
416 * We re-queue ->sigq and drop ->it_lock().
417 * do_schedule_next_timer() locks the timer
418 * and re-schedules it while ->sigq is pending.
419 * Not really bad, but not that we want.
420 */
1da177e4 421 timr->sigq->info.si_sys_private = si_private;
1da177e4 422
27af4245
ON
423 rcu_read_lock();
424 task = pid_task(timr->it_pid, PIDTYPE_PID);
425 if (task) {
426 shared = !(timr->it_sigev_notify & SIGEV_THREAD_ID);
427 ret = send_sigqueue(timr->sigq, task, shared);
428 }
429 rcu_read_unlock();
4aa73611
ON
430 /* If we failed to send the signal the timer stops. */
431 return ret > 0;
1da177e4
LT
432}
433EXPORT_SYMBOL_GPL(posix_timer_event);
434
435/*
436 * This function gets called when a POSIX.1b interval timer expires. It
437 * is used as a callback from the kernel internal timer. The
438 * run_timer_list code ALWAYS calls with interrupts on.
439
440 * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
441 */
c9cb2e3d 442static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
1da177e4 443{
05cfb614 444 struct k_itimer *timr;
1da177e4 445 unsigned long flags;
becf8b5d 446 int si_private = 0;
c9cb2e3d 447 enum hrtimer_restart ret = HRTIMER_NORESTART;
1da177e4 448
05cfb614 449 timr = container_of(timer, struct k_itimer, it.real.timer);
1da177e4 450 spin_lock_irqsave(&timr->it_lock, flags);
1da177e4 451
becf8b5d
TG
452 if (timr->it.real.interval.tv64 != 0)
453 si_private = ++timr->it_requeue_pending;
1da177e4 454
becf8b5d
TG
455 if (posix_timer_event(timr, si_private)) {
456 /*
457 * signal was not sent because of sig_ignor
458 * we will not get a call back to restart it AND
459 * it should be restarted.
460 */
461 if (timr->it.real.interval.tv64 != 0) {
58229a18
TG
462 ktime_t now = hrtimer_cb_get_time(timer);
463
464 /*
465 * FIXME: What we really want, is to stop this
466 * timer completely and restart it in case the
467 * SIG_IGN is removed. This is a non trivial
468 * change which involves sighand locking
469 * (sigh !), which we don't want to do late in
470 * the release cycle.
471 *
472 * For now we just let timers with an interval
473 * less than a jiffie expire every jiffie to
474 * avoid softirq starvation in case of SIG_IGN
475 * and a very small interval, which would put
476 * the timer right back on the softirq pending
477 * list. By moving now ahead of time we trick
478 * hrtimer_forward() to expire the timer
479 * later, while we still maintain the overrun
480 * accuracy, but have some inconsistency in
481 * the timer_gettime() case. This is at least
482 * better than a starved softirq. A more
483 * complex fix which solves also another related
484 * inconsistency is already in the pipeline.
485 */
486#ifdef CONFIG_HIGH_RES_TIMERS
487 {
488 ktime_t kj = ktime_set(0, NSEC_PER_SEC / HZ);
489
490 if (timr->it.real.interval.tv64 < kj.tv64)
491 now = ktime_add(now, kj);
492 }
493#endif
4d672e7a 494 timr->it_overrun += (unsigned int)
58229a18 495 hrtimer_forward(timer, now,
becf8b5d
TG
496 timr->it.real.interval);
497 ret = HRTIMER_RESTART;
a0a0c28c 498 ++timr->it_requeue_pending;
1da177e4 499 }
1da177e4 500 }
1da177e4 501
becf8b5d
TG
502 unlock_timer(timr, flags);
503 return ret;
504}
1da177e4 505
27af4245 506static struct pid *good_sigevent(sigevent_t * event)
1da177e4
LT
507{
508 struct task_struct *rtn = current->group_leader;
509
510 if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
8dc86af0 511 (!(rtn = find_task_by_vpid(event->sigev_notify_thread_id)) ||
bac0abd6 512 !same_thread_group(rtn, current) ||
1da177e4
LT
513 (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL))
514 return NULL;
515
516 if (((event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) &&
517 ((event->sigev_signo <= 0) || (event->sigev_signo > SIGRTMAX)))
518 return NULL;
519
27af4245 520 return task_pid(rtn);
1da177e4
LT
521}
522
52708737
TG
523void posix_timers_register_clock(const clockid_t clock_id,
524 struct k_clock *new_clock)
1da177e4
LT
525{
526 if ((unsigned) clock_id >= MAX_CLOCKS) {
4359ac0a
TG
527 printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",
528 clock_id);
529 return;
530 }
531
532 if (!new_clock->clock_get) {
533 printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",
534 clock_id);
535 return;
536 }
537 if (!new_clock->clock_getres) {
538 printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",
1da177e4
LT
539 clock_id);
540 return;
541 }
542
543 posix_clocks[clock_id] = *new_clock;
544}
52708737 545EXPORT_SYMBOL_GPL(posix_timers_register_clock);
1da177e4
LT
546
547static struct k_itimer * alloc_posix_timer(void)
548{
549 struct k_itimer *tmr;
c3762229 550 tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
1da177e4
LT
551 if (!tmr)
552 return tmr;
1da177e4
LT
553 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
554 kmem_cache_free(posix_timers_cache, tmr);
aa94fbd5 555 return NULL;
1da177e4 556 }
ba661292 557 memset(&tmr->sigq->info, 0, sizeof(siginfo_t));
1da177e4
LT
558 return tmr;
559}
560
8af08871
ED
561static void k_itimer_rcu_free(struct rcu_head *head)
562{
563 struct k_itimer *tmr = container_of(head, struct k_itimer, it.rcu);
564
565 kmem_cache_free(posix_timers_cache, tmr);
566}
567
1da177e4
LT
568#define IT_ID_SET 1
569#define IT_ID_NOT_SET 0
570static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
571{
572 if (it_id_set) {
573 unsigned long flags;
5ed67f05
PE
574 spin_lock_irqsave(&hash_lock, flags);
575 hlist_del_rcu(&tmr->t_hash);
576 spin_unlock_irqrestore(&hash_lock, flags);
1da177e4 577 }
89992102 578 put_pid(tmr->it_pid);
1da177e4 579 sigqueue_free(tmr->sigq);
8af08871 580 call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
1da177e4
LT
581}
582
cc785ac2
TG
583static struct k_clock *clockid_to_kclock(const clockid_t id)
584{
585 if (id < 0)
0606f422
RC
586 return (id & CLOCKFD_MASK) == CLOCKFD ?
587 &clock_posix_dynamic : &clock_posix_cpu;
cc785ac2
TG
588
589 if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)
590 return NULL;
591 return &posix_clocks[id];
592}
593
838394fb
TG
594static int common_timer_create(struct k_itimer *new_timer)
595{
596 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
597 return 0;
598}
599
1da177e4
LT
600/* Create a POSIX.1b interval timer. */
601
362e9c07
HC
602SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
603 struct sigevent __user *, timer_event_spec,
604 timer_t __user *, created_timer_id)
1da177e4 605{
838394fb 606 struct k_clock *kc = clockid_to_kclock(which_clock);
2cd499e3 607 struct k_itimer *new_timer;
ef864c95 608 int error, new_timer_id;
1da177e4
LT
609 sigevent_t event;
610 int it_id_set = IT_ID_NOT_SET;
611
838394fb 612 if (!kc)
1da177e4 613 return -EINVAL;
838394fb
TG
614 if (!kc->timer_create)
615 return -EOPNOTSUPP;
1da177e4
LT
616
617 new_timer = alloc_posix_timer();
618 if (unlikely(!new_timer))
619 return -EAGAIN;
620
621 spin_lock_init(&new_timer->it_lock);
5ed67f05
PE
622 new_timer_id = posix_timer_add(new_timer);
623 if (new_timer_id < 0) {
624 error = new_timer_id;
1da177e4
LT
625 goto out;
626 }
627
628 it_id_set = IT_ID_SET;
629 new_timer->it_id = (timer_t) new_timer_id;
630 new_timer->it_clock = which_clock;
631 new_timer->it_overrun = -1;
1da177e4 632
1da177e4
LT
633 if (timer_event_spec) {
634 if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
635 error = -EFAULT;
636 goto out;
637 }
36b2f046 638 rcu_read_lock();
89992102 639 new_timer->it_pid = get_pid(good_sigevent(&event));
36b2f046 640 rcu_read_unlock();
89992102 641 if (!new_timer->it_pid) {
1da177e4
LT
642 error = -EINVAL;
643 goto out;
644 }
645 } else {
6891c450 646 memset(&event.sigev_value, 0, sizeof(event.sigev_value));
5a9fa730
ON
647 event.sigev_notify = SIGEV_SIGNAL;
648 event.sigev_signo = SIGALRM;
649 event.sigev_value.sival_int = new_timer->it_id;
89992102 650 new_timer->it_pid = get_pid(task_tgid(current));
1da177e4
LT
651 }
652
5a9fa730
ON
653 new_timer->it_sigev_notify = event.sigev_notify;
654 new_timer->sigq->info.si_signo = event.sigev_signo;
655 new_timer->sigq->info.si_value = event.sigev_value;
717835d9 656 new_timer->sigq->info.si_tid = new_timer->it_id;
5a9fa730 657 new_timer->sigq->info.si_code = SI_TIMER;
717835d9 658
2b08de00
AV
659 if (copy_to_user(created_timer_id,
660 &new_timer_id, sizeof (new_timer_id))) {
661 error = -EFAULT;
662 goto out;
663 }
664
838394fb 665 error = kc->timer_create(new_timer);
45e0fffc
AV
666 if (error)
667 goto out;
668
36b2f046 669 spin_lock_irq(&current->sighand->siglock);
27af4245 670 new_timer->it_signal = current->signal;
36b2f046
ON
671 list_add(&new_timer->list, &current->signal->posix_timers);
672 spin_unlock_irq(&current->sighand->siglock);
ef864c95
ON
673
674 return 0;
838394fb 675 /*
1da177e4
LT
676 * In the case of the timer belonging to another task, after
677 * the task is unlocked, the timer is owned by the other task
678 * and may cease to exist at any time. Don't use or modify
679 * new_timer after the unlock call.
680 */
1da177e4 681out:
ef864c95 682 release_posix_timer(new_timer, it_id_set);
1da177e4
LT
683 return error;
684}
685
1da177e4
LT
686/*
687 * Locking issues: We need to protect the result of the id look up until
688 * we get the timer locked down so it is not deleted under us. The
689 * removal is done under the idr spinlock so we use that here to bridge
690 * the find to the timer lock. To avoid a dead lock, the timer id MUST
691 * be release with out holding the timer lock.
692 */
20f33a03 693static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
1da177e4
LT
694{
695 struct k_itimer *timr;
8af08871 696
e182bb38
TH
697 /*
698 * timer_t could be any type >= int and we want to make sure any
699 * @timer_id outside positive int range fails lookup.
700 */
701 if ((unsigned long long)timer_id > INT_MAX)
702 return NULL;
703
8af08871 704 rcu_read_lock();
5ed67f05 705 timr = posix_timer_by_id(timer_id);
1da177e4 706 if (timr) {
8af08871 707 spin_lock_irqsave(&timr->it_lock, *flags);
89992102 708 if (timr->it_signal == current->signal) {
8af08871 709 rcu_read_unlock();
31d92845
ON
710 return timr;
711 }
8af08871 712 spin_unlock_irqrestore(&timr->it_lock, *flags);
31d92845 713 }
8af08871 714 rcu_read_unlock();
1da177e4 715
31d92845 716 return NULL;
1da177e4
LT
717}
718
719/*
720 * Get the time remaining on a POSIX.1b interval timer. This function
721 * is ALWAYS called with spin_lock_irq on the timer, thus it must not
722 * mess with irq.
723 *
724 * We have a couple of messes to clean up here. First there is the case
725 * of a timer that has a requeue pending. These timers should appear to
726 * be in the timer list with an expiry as if we were to requeue them
727 * now.
728 *
729 * The second issue is the SIGEV_NONE timer which may be active but is
730 * not really ever put in the timer list (to save system resources).
731 * This timer may be expired, and if so, we will do it here. Otherwise
732 * it is the same as a requeue pending timer WRT to what we should
733 * report.
734 */
735static void
736common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
737{
3b98a532 738 ktime_t now, remaining, iv;
becf8b5d 739 struct hrtimer *timer = &timr->it.real.timer;
1da177e4 740
becf8b5d 741 memset(cur_setting, 0, sizeof(struct itimerspec));
becf8b5d 742
3b98a532
RZ
743 iv = timr->it.real.interval;
744
becf8b5d 745 /* interval timer ? */
3b98a532
RZ
746 if (iv.tv64)
747 cur_setting->it_interval = ktime_to_timespec(iv);
748 else if (!hrtimer_active(timer) &&
749 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
becf8b5d 750 return;
3b98a532
RZ
751
752 now = timer->base->get_time();
753
becf8b5d 754 /*
3b98a532
RZ
755 * When a requeue is pending or this is a SIGEV_NONE
756 * timer move the expiry time forward by intervals, so
757 * expiry is > now.
becf8b5d 758 */
3b98a532
RZ
759 if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
760 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
4d672e7a 761 timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
3b98a532 762
572c3917 763 remaining = __hrtimer_expires_remaining_adjusted(timer, now);
becf8b5d 764 /* Return 0 only, when the timer is expired and not pending */
3b98a532
RZ
765 if (remaining.tv64 <= 0) {
766 /*
767 * A single shot SIGEV_NONE timer must return 0, when
768 * it is expired !
769 */
770 if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
771 cur_setting->it_value.tv_nsec = 1;
772 } else
becf8b5d 773 cur_setting->it_value = ktime_to_timespec(remaining);
1da177e4
LT
774}
775
776/* Get the time remaining on a POSIX.1b interval timer. */
362e9c07
HC
777SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
778 struct itimerspec __user *, setting)
1da177e4 779{
1da177e4 780 struct itimerspec cur_setting;
a7319fa2
TG
781 struct k_itimer *timr;
782 struct k_clock *kc;
1da177e4 783 unsigned long flags;
a7319fa2 784 int ret = 0;
1da177e4
LT
785
786 timr = lock_timer(timer_id, &flags);
787 if (!timr)
788 return -EINVAL;
789
a7319fa2
TG
790 kc = clockid_to_kclock(timr->it_clock);
791 if (WARN_ON_ONCE(!kc || !kc->timer_get))
792 ret = -EINVAL;
793 else
794 kc->timer_get(timr, &cur_setting);
1da177e4
LT
795
796 unlock_timer(timr, flags);
797
a7319fa2 798 if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
1da177e4
LT
799 return -EFAULT;
800
a7319fa2 801 return ret;
1da177e4 802}
becf8b5d 803
1da177e4
LT
804/*
805 * Get the number of overruns of a POSIX.1b interval timer. This is to
806 * be the overrun of the timer last delivered. At the same time we are
807 * accumulating overruns on the next timer. The overrun is frozen when
808 * the signal is delivered, either at the notify time (if the info block
809 * is not queued) or at the actual delivery time (as we are informed by
810 * the call back to do_schedule_next_timer(). So all we need to do is
811 * to pick up the frozen overrun.
812 */
362e9c07 813SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
1da177e4
LT
814{
815 struct k_itimer *timr;
816 int overrun;
5ba25331 817 unsigned long flags;
1da177e4
LT
818
819 timr = lock_timer(timer_id, &flags);
820 if (!timr)
821 return -EINVAL;
822
823 overrun = timr->it_overrun_last;
824 unlock_timer(timr, flags);
825
826 return overrun;
827}
1da177e4
LT
828
829/* Set a POSIX.1b interval timer. */
830/* timr->it_lock is taken. */
858119e1 831static int
1da177e4
LT
832common_timer_set(struct k_itimer *timr, int flags,
833 struct itimerspec *new_setting, struct itimerspec *old_setting)
834{
becf8b5d 835 struct hrtimer *timer = &timr->it.real.timer;
7978672c 836 enum hrtimer_mode mode;
1da177e4
LT
837
838 if (old_setting)
839 common_timer_get(timr, old_setting);
840
841 /* disable the timer */
becf8b5d 842 timr->it.real.interval.tv64 = 0;
1da177e4
LT
843 /*
844 * careful here. If smp we could be in the "fire" routine which will
845 * be spinning as we hold the lock. But this is ONLY an SMP issue.
846 */
becf8b5d 847 if (hrtimer_try_to_cancel(timer) < 0)
1da177e4 848 return TIMER_RETRY;
1da177e4
LT
849
850 timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
851 ~REQUEUE_PENDING;
852 timr->it_overrun_last = 0;
1da177e4 853
becf8b5d
TG
854 /* switch off the timer when it_value is zero */
855 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
856 return 0;
1da177e4 857
c9cb2e3d 858 mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
7978672c 859 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
7978672c 860 timr->it.real.timer.function = posix_timer_fn;
becf8b5d 861
cc584b21 862 hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
becf8b5d
TG
863
864 /* Convert interval */
865 timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
866
867 /* SIGEV_NONE timers are not queued ! See common_timer_get */
952bbc87
TG
868 if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
869 /* Setup correct expiry time for relative timers */
5a7780e7 870 if (mode == HRTIMER_MODE_REL) {
cc584b21 871 hrtimer_add_expires(timer, timer->base->get_time());
5a7780e7 872 }
becf8b5d 873 return 0;
952bbc87 874 }
becf8b5d 875
cc584b21 876 hrtimer_start_expires(timer, mode);
1da177e4
LT
877 return 0;
878}
879
880/* Set a POSIX.1b interval timer */
362e9c07
HC
881SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
882 const struct itimerspec __user *, new_setting,
883 struct itimerspec __user *, old_setting)
1da177e4
LT
884{
885 struct k_itimer *timr;
886 struct itimerspec new_spec, old_spec;
887 int error = 0;
5ba25331 888 unsigned long flag;
1da177e4 889 struct itimerspec *rtn = old_setting ? &old_spec : NULL;
27722df1 890 struct k_clock *kc;
1da177e4
LT
891
892 if (!new_setting)
893 return -EINVAL;
894
895 if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
896 return -EFAULT;
897
becf8b5d
TG
898 if (!timespec_valid(&new_spec.it_interval) ||
899 !timespec_valid(&new_spec.it_value))
1da177e4
LT
900 return -EINVAL;
901retry:
902 timr = lock_timer(timer_id, &flag);
903 if (!timr)
904 return -EINVAL;
905
27722df1
TG
906 kc = clockid_to_kclock(timr->it_clock);
907 if (WARN_ON_ONCE(!kc || !kc->timer_set))
908 error = -EINVAL;
909 else
910 error = kc->timer_set(timr, flags, &new_spec, rtn);
1da177e4
LT
911
912 unlock_timer(timr, flag);
913 if (error == TIMER_RETRY) {
914 rtn = NULL; // We already got the old time...
915 goto retry;
916 }
917
becf8b5d
TG
918 if (old_setting && !error &&
919 copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
1da177e4
LT
920 error = -EFAULT;
921
922 return error;
923}
924
6761c670 925static int common_timer_del(struct k_itimer *timer)
1da177e4 926{
becf8b5d 927 timer->it.real.interval.tv64 = 0;
f972be33 928
becf8b5d 929 if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
1da177e4 930 return TIMER_RETRY;
1da177e4
LT
931 return 0;
932}
933
934static inline int timer_delete_hook(struct k_itimer *timer)
935{
6761c670
TG
936 struct k_clock *kc = clockid_to_kclock(timer->it_clock);
937
938 if (WARN_ON_ONCE(!kc || !kc->timer_del))
939 return -EINVAL;
940 return kc->timer_del(timer);
1da177e4
LT
941}
942
943/* Delete a POSIX.1b interval timer. */
362e9c07 944SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
1da177e4
LT
945{
946 struct k_itimer *timer;
5ba25331 947 unsigned long flags;
1da177e4 948
1da177e4 949retry_delete:
1da177e4
LT
950 timer = lock_timer(timer_id, &flags);
951 if (!timer)
952 return -EINVAL;
953
becf8b5d 954 if (timer_delete_hook(timer) == TIMER_RETRY) {
1da177e4
LT
955 unlock_timer(timer, flags);
956 goto retry_delete;
957 }
becf8b5d 958
1da177e4
LT
959 spin_lock(&current->sighand->siglock);
960 list_del(&timer->list);
961 spin_unlock(&current->sighand->siglock);
962 /*
963 * This keeps any tasks waiting on the spin lock from thinking
964 * they got something (see the lock code above).
965 */
89992102 966 timer->it_signal = NULL;
4b7a1304 967
1da177e4
LT
968 unlock_timer(timer, flags);
969 release_posix_timer(timer, IT_ID_SET);
970 return 0;
971}
becf8b5d 972
1da177e4
LT
973/*
974 * return timer owned by the process, used by exit_itimers
975 */
858119e1 976static void itimer_delete(struct k_itimer *timer)
1da177e4
LT
977{
978 unsigned long flags;
979
1da177e4 980retry_delete:
1da177e4
LT
981 spin_lock_irqsave(&timer->it_lock, flags);
982
becf8b5d 983 if (timer_delete_hook(timer) == TIMER_RETRY) {
1da177e4
LT
984 unlock_timer(timer, flags);
985 goto retry_delete;
986 }
1da177e4
LT
987 list_del(&timer->list);
988 /*
989 * This keeps any tasks waiting on the spin lock from thinking
990 * they got something (see the lock code above).
991 */
89992102 992 timer->it_signal = NULL;
4b7a1304 993
1da177e4
LT
994 unlock_timer(timer, flags);
995 release_posix_timer(timer, IT_ID_SET);
996}
997
998/*
25f407f0 999 * This is called by do_exit or de_thread, only when there are no more
1da177e4
LT
1000 * references to the shared signal_struct.
1001 */
1002void exit_itimers(struct signal_struct *sig)
1003{
1004 struct k_itimer *tmr;
1005
1006 while (!list_empty(&sig->posix_timers)) {
1007 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
1008 itimer_delete(tmr);
1009 }
1010}
1011
362e9c07
HC
1012SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
1013 const struct timespec __user *, tp)
1da177e4 1014{
26f9a479 1015 struct k_clock *kc = clockid_to_kclock(which_clock);
1da177e4
LT
1016 struct timespec new_tp;
1017
26f9a479 1018 if (!kc || !kc->clock_set)
1da177e4 1019 return -EINVAL;
26f9a479 1020
1da177e4
LT
1021 if (copy_from_user(&new_tp, tp, sizeof (*tp)))
1022 return -EFAULT;
1023
26f9a479 1024 return kc->clock_set(which_clock, &new_tp);
1da177e4
LT
1025}
1026
362e9c07
HC
1027SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
1028 struct timespec __user *,tp)
1da177e4 1029{
42285777 1030 struct k_clock *kc = clockid_to_kclock(which_clock);
1da177e4
LT
1031 struct timespec kernel_tp;
1032 int error;
1033
42285777 1034 if (!kc)
1da177e4 1035 return -EINVAL;
42285777
TG
1036
1037 error = kc->clock_get(which_clock, &kernel_tp);
1038
1da177e4
LT
1039 if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
1040 error = -EFAULT;
1041
1042 return error;
1da177e4
LT
1043}
1044
f1f1d5eb
RC
1045SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1046 struct timex __user *, utx)
1047{
1048 struct k_clock *kc = clockid_to_kclock(which_clock);
1049 struct timex ktx;
1050 int err;
1051
1052 if (!kc)
1053 return -EINVAL;
1054 if (!kc->clock_adj)
1055 return -EOPNOTSUPP;
1056
1057 if (copy_from_user(&ktx, utx, sizeof(ktx)))
1058 return -EFAULT;
1059
1060 err = kc->clock_adj(which_clock, &ktx);
1061
f0dbe81f 1062 if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
f1f1d5eb
RC
1063 return -EFAULT;
1064
1065 return err;
1066}
1067
362e9c07
HC
1068SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
1069 struct timespec __user *, tp)
1da177e4 1070{
e5e542ee 1071 struct k_clock *kc = clockid_to_kclock(which_clock);
1da177e4
LT
1072 struct timespec rtn_tp;
1073 int error;
1074
e5e542ee 1075 if (!kc)
1da177e4
LT
1076 return -EINVAL;
1077
e5e542ee 1078 error = kc->clock_getres(which_clock, &rtn_tp);
1da177e4 1079
e5e542ee 1080 if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp)))
1da177e4 1081 error = -EFAULT;
1da177e4
LT
1082
1083 return error;
1084}
1085
97735f25
TG
1086/*
1087 * nanosleep for monotonic and realtime clocks
1088 */
1089static int common_nsleep(const clockid_t which_clock, int flags,
1090 struct timespec *tsave, struct timespec __user *rmtp)
1091{
080344b9
ON
1092 return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
1093 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1094 which_clock);
97735f25 1095}
1da177e4 1096
362e9c07
HC
1097SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
1098 const struct timespec __user *, rqtp,
1099 struct timespec __user *, rmtp)
1da177e4 1100{
a5cd2880 1101 struct k_clock *kc = clockid_to_kclock(which_clock);
1da177e4 1102 struct timespec t;
1da177e4 1103
a5cd2880 1104 if (!kc)
1da177e4 1105 return -EINVAL;
a5cd2880
TG
1106 if (!kc->nsleep)
1107 return -ENANOSLEEP_NOTSUP;
1da177e4
LT
1108
1109 if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
1110 return -EFAULT;
1111
5f82b2b7 1112 if (!timespec_valid(&t))
1da177e4
LT
1113 return -EINVAL;
1114
a5cd2880 1115 return kc->nsleep(which_clock, flags, &t, rmtp);
1da177e4 1116}
1711ef38 1117
1711ef38
TA
1118/*
1119 * This will restart clock_nanosleep. This is required only by
1120 * compat_clock_nanosleep_restart for now.
1121 */
59bd5bc2 1122long clock_nanosleep_restart(struct restart_block *restart_block)
1711ef38 1123{
ab8177bc 1124 clockid_t which_clock = restart_block->nanosleep.clockid;
59bd5bc2
TG
1125 struct k_clock *kc = clockid_to_kclock(which_clock);
1126
1127 if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
1128 return -EINVAL;
1711ef38 1129
59bd5bc2 1130 return kc->nsleep_restart(restart_block);
1711ef38 1131}