posix-timers.c 29.3 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * linux/kernel/posix-timers.c
L
Linus Torvalds 已提交
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 34 35 36
 *
 *
 * 2002-10-15  Posix Clocks & timers
 *                           by George Anzinger george@mvista.com
 *
 *			     Copyright (C) 2002 2003 by MontaVista Software.
 *
 * 2004-06-01  Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
 *			     Copyright (C) 2004 Boris Hu
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA
 */

/* These are all the functions necessary to implement
 * POSIX clocks & timers
 */
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/time.h>
A
Arjan van de Ven 已提交
37
#include <linux/mutex.h>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

#include <asm/uaccess.h>
#include <linux/list.h>
#include <linux/init.h>
#include <linux/compiler.h>
#include <linux/idr.h>
#include <linux/posix-timers.h>
#include <linux/syscalls.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/module.h>

/*
 * Management arrays for POSIX timers.	 Timers are kept in slab memory
 * Timer ids are allocated by an external routine that keeps track of the
 * id and the timer.  The external interface is:
 *
 * void *idr_find(struct idr *idp, int id);           to find timer_id <id>
 * int idr_get_new(struct idr *idp, void *ptr);       to get a new id and
 *                                                    related it to <ptr>
 * void idr_remove(struct idr *idp, int id);          to release <id>
 * void idr_init(struct idr *idp);                    to initialize <idp>
 *                                                    which we supply.
 * The idr_get_new *may* call slab for more memory so it must not be
 * called under a spin lock.  Likewise idr_remore may release memory
 * (but it may be ok to do this under a lock...).
 * idr_find is just a memory look up and is quite fast.  A -1 return
 * indicates that the requested id does not exist.
 */

/*
 * Lets keep our timers in a slab cache :-)
 */
71
static struct kmem_cache *posix_timers_cache;
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82 83
static struct idr posix_timers_id;
static DEFINE_SPINLOCK(idr_lock);

/*
 * we assume that the new SIGEV_THREAD_ID shares no bits with the other
 * SIGEV values.  Here we put out an error if this assumption fails.
 */
#if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
                       ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
#error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
#endif

84 85 86 87 88 89 90 91
/*
 * parisc wants ENOTSUP instead of EOPNOTSUPP
 */
#ifndef ENOTSUP
# define ENANOSLEEP_NOTSUP EOPNOTSUPP
#else
# define ENANOSLEEP_NOTSUP ENOTSUP
#endif
L
Linus Torvalds 已提交
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

/*
 * The timer ID is turned into a timer address by idr_find().
 * Verifying a valid ID consists of:
 *
 * a) checking that idr_find() returns other than -1.
 * b) checking that the timer id matches the one in the timer itself.
 * c) that the timer owner is in the callers thread group.
 */

/*
 * CLOCKs: The POSIX standard calls for a couple of clocks and allows us
 *	    to implement others.  This structure defines the various
 *	    clocks and allows the possibility of adding others.	 We
 *	    provide an interface to add clocks to the table and expect
 *	    the "arch" code to add at least one clock that is high
 *	    resolution.	 Here we define the standard CLOCK_REALTIME as a
 *	    1/HZ resolution clock.
 *
 * RESOLUTION: Clock resolution is used to round up timer and interval
 *	    times, NOT to report clock times, which are reported with as
 *	    much resolution as the system can muster.  In some cases this
 *	    resolution may depend on the underlying clock hardware and
 *	    may not be quantifiable until run time, and only then is the
 *	    necessary code is written.	The standard says we should say
 *	    something about this issue in the documentation...
 *
 * FUNCTIONS: The CLOCKs structure defines possible functions to handle
 *	    various clock functions.  For clocks that use the standard
 *	    system timer code these entries should be NULL.  This will
 *	    allow dispatch without the overhead of indirect function
 *	    calls.  CLOCKS that depend on other sources (e.g. WWV or GPS)
 *	    must supply functions here, even if the function just returns
 *	    ENOSYS.  The standard POSIX timer management code assumes the
 *	    following: 1.) The k_itimer struct (sched.h) is used for the
127
 *	    timer.  2.) The list, it_lock, it_clock, it_id and it_pid
L
Linus Torvalds 已提交
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
 *	    fields are not modified by timer code.
 *
 *          At this time all functions EXCEPT clock_nanosleep can be
 *          redirected by the CLOCKS structure.  Clock_nanosleep is in
 *          there, but the code ignores it.
 *
 * Permissions: It is assumed that the clock_settime() function defined
 *	    for each clock will take care of permission checks.	 Some
 *	    clocks may be set able by any user (i.e. local process
 *	    clocks) others not.	 Currently the only set able clock we
 *	    have is CLOCK_REALTIME and its high res counter part, both of
 *	    which we beg off on and pass to do_sys_settimeofday().
 */

static struct k_clock posix_clocks[MAX_CLOCKS];
143

L
Linus Torvalds 已提交
144
/*
145
 * These ones are defined below.
L
Linus Torvalds 已提交
146
 */
147 148 149 150 151 152
static int common_nsleep(const clockid_t, int flags, struct timespec *t,
			 struct timespec __user *rmtp);
static void common_timer_get(struct k_itimer *, struct itimerspec *);
static int common_timer_set(struct k_itimer *, int,
			    struct itimerspec *, struct itimerspec *);
static int common_timer_del(struct k_itimer *timer);
L
Linus Torvalds 已提交
153

154
static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
L
Linus Torvalds 已提交
155

N
Namhyung Kim 已提交
156 157 158 159 160 161 162
static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);

#define lock_timer(tid, flags)						   \
({	struct k_itimer *__timr;					   \
	__cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags));  \
	__timr;								   \
})
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184

static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
{
	spin_unlock_irqrestore(&timr->it_lock, flags);
}

/*
 * Call the k_clock hook function if non-null, or the default function.
 */
#define CLOCK_DISPATCH(clock, call, arglist) \
 	((clock) < 0 ? posix_cpu_##call arglist : \
 	 (posix_clocks[clock].call != NULL \
 	  ? (*posix_clocks[clock].call) arglist : common_##call arglist))

/*
 * Default clock hook functions when the struct k_clock passed
 * to register_posix_clock leaves a function pointer null.
 *
 * The function common_CALL is the default implementation for
 * the function pointer CALL in struct k_clock.
 */

185
static inline int common_clock_getres(const clockid_t which_clock,
L
Linus Torvalds 已提交
186 187 188 189 190 191 192
				      struct timespec *tp)
{
	tp->tv_sec = 0;
	tp->tv_nsec = posix_clocks[which_clock].res;
	return 0;
}

193 194 195 196
/*
 * Get real time for posix timers
 */
static int common_clock_get(clockid_t which_clock, struct timespec *tp)
L
Linus Torvalds 已提交
197
{
198
	ktime_get_real_ts(tp);
L
Linus Torvalds 已提交
199 200 201
	return 0;
}

202
static inline int common_clock_set(const clockid_t which_clock,
203
				   const struct timespec *tp)
L
Linus Torvalds 已提交
204 205 206 207
{
	return do_sys_settimeofday(tp, NULL);
}

208
static int common_timer_create(struct k_itimer *new_timer)
L
Linus Torvalds 已提交
209
{
210
	hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
L
Linus Torvalds 已提交
211 212 213
	return 0;
}

214 215 216 217 218
static int no_timer_create(struct k_itimer *new_timer)
{
	return -EOPNOTSUPP;
}

L
Linus Torvalds 已提交
219
/*
220
 * Return nonzero if we know a priori this clockid_t value is bogus.
L
Linus Torvalds 已提交
221
 */
222
static inline int invalid_clockid(const clockid_t which_clock)
L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230 231 232 233 234
{
	if (which_clock < 0)	/* CPU clock, posix_cpu_* will check it */
		return 0;
	if ((unsigned) which_clock >= MAX_CLOCKS)
		return 1;
	if (posix_clocks[which_clock].clock_getres != NULL)
		return 0;
	if (posix_clocks[which_clock].res != 0)
		return 0;
	return 1;
}

235 236 237 238 239 240 241 242
/*
 * Get monotonic time for posix timers
 */
static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp)
{
	ktime_get_ts(tp);
	return 0;
}
L
Linus Torvalds 已提交
243

244 245 246 247 248 249 250 251 252
/*
 * Get monotonic time for posix timers
 */
static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp)
{
	getrawmonotonic(tp);
	return 0;
}

253 254 255 256 257 258 259 260 261 262 263 264 265 266

static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec *tp)
{
	*tp = current_kernel_time();
	return 0;
}

static int posix_get_monotonic_coarse(clockid_t which_clock,
						struct timespec *tp)
{
	*tp = get_monotonic_coarse();
	return 0;
}

267
static int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp)
268 269 270 271
{
	*tp = ktime_to_timespec(KTIME_LOW_RES);
	return 0;
}
L
Linus Torvalds 已提交
272 273 274 275 276
/*
 * Initialize everything, well, just everything in Posix clocks/timers ;)
 */
static __init int init_posix_timers(void)
{
277
	struct k_clock clock_realtime = {
278
		.clock_getres	= hrtimer_get_res,
279
		.nsleep		= common_nsleep,
L
Linus Torvalds 已提交
280
	};
281
	struct k_clock clock_monotonic = {
282 283 284
		.clock_getres	= hrtimer_get_res,
		.clock_get	= posix_ktime_get_ts,
		.clock_set	= do_posix_clock_nosettime,
285
		.nsleep		= common_nsleep,
L
Linus Torvalds 已提交
286
	};
287
	struct k_clock clock_monotonic_raw = {
288 289 290 291
		.clock_getres	= hrtimer_get_res,
		.clock_get	= posix_get_monotonic_raw,
		.clock_set	= do_posix_clock_nosettime,
		.timer_create	= no_timer_create,
292
	};
293
	struct k_clock clock_realtime_coarse = {
294 295 296 297
		.clock_getres	= posix_get_coarse_res,
		.clock_get	= posix_get_realtime_coarse,
		.clock_set	= do_posix_clock_nosettime,
		.timer_create	= no_timer_create,
298 299
	};
	struct k_clock clock_monotonic_coarse = {
300 301 302 303
		.clock_getres	= posix_get_coarse_res,
		.clock_get	= posix_get_monotonic_coarse,
		.clock_set	= do_posix_clock_nosettime,
		.timer_create	= no_timer_create,
304
	};
L
Linus Torvalds 已提交
305 306 307

	register_posix_clock(CLOCK_REALTIME, &clock_realtime);
	register_posix_clock(CLOCK_MONOTONIC, &clock_monotonic);
308
	register_posix_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
309 310
	register_posix_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
	register_posix_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
L
Linus Torvalds 已提交
311 312

	posix_timers_cache = kmem_cache_create("posix_timers_cache",
313 314
					sizeof (struct k_itimer), 0, SLAB_PANIC,
					NULL);
L
Linus Torvalds 已提交
315 316 317 318 319 320 321 322
	idr_init(&posix_timers_id);
	return 0;
}

__initcall(init_posix_timers);

static void schedule_next_timer(struct k_itimer *timr)
{
323 324
	struct hrtimer *timer = &timr->it.real.timer;

325
	if (timr->it.real.interval.tv64 == 0)
L
Linus Torvalds 已提交
326 327
		return;

D
Davide Libenzi 已提交
328 329 330
	timr->it_overrun += (unsigned int) hrtimer_forward(timer,
						timer->base->get_time(),
						timr->it.real.interval);
331

L
Linus Torvalds 已提交
332 333 334
	timr->it_overrun_last = timr->it_overrun;
	timr->it_overrun = -1;
	++timr->it_requeue_pending;
335
	hrtimer_restart(timer);
L
Linus Torvalds 已提交
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
}

/*
 * This function is exported for use by the signal deliver code.  It is
 * called just prior to the info block being released and passes that
 * block to us.  It's function is to update the overrun entry AND to
 * restart the timer.  It should only be called if the timer is to be
 * restarted (i.e. we have flagged this in the sys_private entry of the
 * info block).
 *
 * To protect aginst the timer going away while the interrupt is queued,
 * we require that the it_requeue_pending flag be set.
 */
void do_schedule_next_timer(struct siginfo *info)
{
	struct k_itimer *timr;
	unsigned long flags;

	timr = lock_timer(info->si_tid, &flags);

356 357 358 359 360
	if (timr && timr->it_requeue_pending == info->si_sys_private) {
		if (timr->it_clock < 0)
			posix_cpu_timer_schedule(timr);
		else
			schedule_next_timer(timr);
L
Linus Torvalds 已提交
361

362
		info->si_overrun += timr->it_overrun_last;
363 364
	}

365 366
	if (timr)
		unlock_timer(timr, flags);
L
Linus Torvalds 已提交
367 368
}

369
int posix_timer_event(struct k_itimer *timr, int si_private)
L
Linus Torvalds 已提交
370
{
371 372
	struct task_struct *task;
	int shared, ret = -1;
373 374 375 376 377 378 379 380 381 382 383
	/*
	 * FIXME: if ->sigq is queued we can race with
	 * dequeue_signal()->do_schedule_next_timer().
	 *
	 * If dequeue_signal() sees the "right" value of
	 * si_sys_private it calls do_schedule_next_timer().
	 * We re-queue ->sigq and drop ->it_lock().
	 * do_schedule_next_timer() locks the timer
	 * and re-schedules it while ->sigq is pending.
	 * Not really bad, but not that we want.
	 */
L
Linus Torvalds 已提交
384 385
	timr->sigq->info.si_sys_private = si_private;

386 387 388 389 390 391 392
	rcu_read_lock();
	task = pid_task(timr->it_pid, PIDTYPE_PID);
	if (task) {
		shared = !(timr->it_sigev_notify & SIGEV_THREAD_ID);
		ret = send_sigqueue(timr->sigq, task, shared);
	}
	rcu_read_unlock();
393 394
	/* If we failed to send the signal the timer stops. */
	return ret > 0;
L
Linus Torvalds 已提交
395 396 397 398 399 400 401 402 403 404
}
EXPORT_SYMBOL_GPL(posix_timer_event);

/*
 * This function gets called when a POSIX.1b interval timer expires.  It
 * is used as a callback from the kernel internal timer.  The
 * run_timer_list code ALWAYS calls with interrupts on.

 * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
 */
405
static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
L
Linus Torvalds 已提交
406
{
407
	struct k_itimer *timr;
L
Linus Torvalds 已提交
408
	unsigned long flags;
409
	int si_private = 0;
410
	enum hrtimer_restart ret = HRTIMER_NORESTART;
L
Linus Torvalds 已提交
411

412
	timr = container_of(timer, struct k_itimer, it.real.timer);
L
Linus Torvalds 已提交
413 414
	spin_lock_irqsave(&timr->it_lock, flags);

415 416
	if (timr->it.real.interval.tv64 != 0)
		si_private = ++timr->it_requeue_pending;
L
Linus Torvalds 已提交
417

418 419 420 421 422 423 424
	if (posix_timer_event(timr, si_private)) {
		/*
		 * signal was not sent because of sig_ignor
		 * we will not get a call back to restart it AND
		 * it should be restarted.
		 */
		if (timr->it.real.interval.tv64 != 0) {
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
			ktime_t now = hrtimer_cb_get_time(timer);

			/*
			 * FIXME: What we really want, is to stop this
			 * timer completely and restart it in case the
			 * SIG_IGN is removed. This is a non trivial
			 * change which involves sighand locking
			 * (sigh !), which we don't want to do late in
			 * the release cycle.
			 *
			 * For now we just let timers with an interval
			 * less than a jiffie expire every jiffie to
			 * avoid softirq starvation in case of SIG_IGN
			 * and a very small interval, which would put
			 * the timer right back on the softirq pending
			 * list. By moving now ahead of time we trick
			 * hrtimer_forward() to expire the timer
			 * later, while we still maintain the overrun
			 * accuracy, but have some inconsistency in
			 * the timer_gettime() case. This is at least
			 * better than a starved softirq. A more
			 * complex fix which solves also another related
			 * inconsistency is already in the pipeline.
			 */
#ifdef CONFIG_HIGH_RES_TIMERS
			{
				ktime_t kj = ktime_set(0, NSEC_PER_SEC / HZ);

				if (timr->it.real.interval.tv64 < kj.tv64)
					now = ktime_add(now, kj);
			}
#endif
D
Davide Libenzi 已提交
457
			timr->it_overrun += (unsigned int)
458
				hrtimer_forward(timer, now,
459 460
						timr->it.real.interval);
			ret = HRTIMER_RESTART;
461
			++timr->it_requeue_pending;
L
Linus Torvalds 已提交
462 463 464
		}
	}

465 466 467
	unlock_timer(timr, flags);
	return ret;
}
L
Linus Torvalds 已提交
468

469
static struct pid *good_sigevent(sigevent_t * event)
L
Linus Torvalds 已提交
470 471 472 473
{
	struct task_struct *rtn = current->group_leader;

	if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
474
		(!(rtn = find_task_by_vpid(event->sigev_notify_thread_id)) ||
475
		 !same_thread_group(rtn, current) ||
L
Linus Torvalds 已提交
476 477 478 479 480 481 482
		 (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL))
		return NULL;

	if (((event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) &&
	    ((event->sigev_signo <= 0) || (event->sigev_signo > SIGRTMAX)))
		return NULL;

483
	return task_pid(rtn);
L
Linus Torvalds 已提交
484 485
}

486
void register_posix_clock(const clockid_t clock_id, struct k_clock *new_clock)
L
Linus Torvalds 已提交
487 488 489 490 491 492 493 494 495 496 497 498 499 500
{
	if ((unsigned) clock_id >= MAX_CLOCKS) {
		printk("POSIX clock register failed for clock_id %d\n",
		       clock_id);
		return;
	}

	posix_clocks[clock_id] = *new_clock;
}
EXPORT_SYMBOL_GPL(register_posix_clock);

static struct k_itimer * alloc_posix_timer(void)
{
	struct k_itimer *tmr;
501
	tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
L
Linus Torvalds 已提交
502 503 504 505
	if (!tmr)
		return tmr;
	if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
		kmem_cache_free(posix_timers_cache, tmr);
506
		return NULL;
L
Linus Torvalds 已提交
507
	}
508
	memset(&tmr->sigq->info, 0, sizeof(siginfo_t));
L
Linus Torvalds 已提交
509 510 511 512 513 514 515 516 517 518 519 520 521
	return tmr;
}

#define IT_ID_SET	1
#define IT_ID_NOT_SET	0
static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
{
	if (it_id_set) {
		unsigned long flags;
		spin_lock_irqsave(&idr_lock, flags);
		idr_remove(&posix_timers_id, tmr->it_id);
		spin_unlock_irqrestore(&idr_lock, flags);
	}
522
	put_pid(tmr->it_pid);
L
Linus Torvalds 已提交
523 524 525 526
	sigqueue_free(tmr->sigq);
	kmem_cache_free(posix_timers_cache, tmr);
}

527 528 529 530 531 532 533 534 535 536
static struct k_clock *clockid_to_kclock(const clockid_t id)
{
	if (id < 0)
		return &clock_posix_cpu;

	if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)
		return NULL;
	return &posix_clocks[id];
}

L
Linus Torvalds 已提交
537 538
/* Create a POSIX.1b interval timer. */

539 540 541
SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
		struct sigevent __user *, timer_event_spec,
		timer_t __user *, created_timer_id)
L
Linus Torvalds 已提交
542
{
543
	struct k_itimer *new_timer;
544
	int error, new_timer_id;
L
Linus Torvalds 已提交
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
	sigevent_t event;
	int it_id_set = IT_ID_NOT_SET;

	if (invalid_clockid(which_clock))
		return -EINVAL;

	new_timer = alloc_posix_timer();
	if (unlikely(!new_timer))
		return -EAGAIN;

	spin_lock_init(&new_timer->it_lock);
 retry:
	if (unlikely(!idr_pre_get(&posix_timers_id, GFP_KERNEL))) {
		error = -EAGAIN;
		goto out;
	}
	spin_lock_irq(&idr_lock);
562
	error = idr_get_new(&posix_timers_id, new_timer, &new_timer_id);
L
Linus Torvalds 已提交
563
	spin_unlock_irq(&idr_lock);
564 565 566
	if (error) {
		if (error == -EAGAIN)
			goto retry;
L
Linus Torvalds 已提交
567
		/*
J
Joe Perches 已提交
568
		 * Weird looking, but we return EAGAIN if the IDR is
L
Linus Torvalds 已提交
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
		 * full (proper POSIX return value for this)
		 */
		error = -EAGAIN;
		goto out;
	}

	it_id_set = IT_ID_SET;
	new_timer->it_id = (timer_t) new_timer_id;
	new_timer->it_clock = which_clock;
	new_timer->it_overrun = -1;

	if (timer_event_spec) {
		if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
			error = -EFAULT;
			goto out;
		}
585
		rcu_read_lock();
586
		new_timer->it_pid = get_pid(good_sigevent(&event));
587
		rcu_read_unlock();
588
		if (!new_timer->it_pid) {
L
Linus Torvalds 已提交
589 590 591 592
			error = -EINVAL;
			goto out;
		}
	} else {
593 594 595
		event.sigev_notify = SIGEV_SIGNAL;
		event.sigev_signo = SIGALRM;
		event.sigev_value.sival_int = new_timer->it_id;
596
		new_timer->it_pid = get_pid(task_tgid(current));
L
Linus Torvalds 已提交
597 598
	}

599 600 601
	new_timer->it_sigev_notify     = event.sigev_notify;
	new_timer->sigq->info.si_signo = event.sigev_signo;
	new_timer->sigq->info.si_value = event.sigev_value;
602
	new_timer->sigq->info.si_tid   = new_timer->it_id;
603
	new_timer->sigq->info.si_code  = SI_TIMER;
604

605 606 607 608 609 610
	if (copy_to_user(created_timer_id,
			 &new_timer_id, sizeof (new_timer_id))) {
		error = -EFAULT;
		goto out;
	}

611 612 613 614
	error = CLOCK_DISPATCH(which_clock, timer_create, (new_timer));
	if (error)
		goto out;

615
	spin_lock_irq(&current->sighand->siglock);
616
	new_timer->it_signal = current->signal;
617 618
	list_add(&new_timer->list, &current->signal->posix_timers);
	spin_unlock_irq(&current->sighand->siglock);
619 620

	return 0;
L
Linus Torvalds 已提交
621 622 623 624 625 626 627
 	/*
	 * In the case of the timer belonging to another task, after
	 * the task is unlocked, the timer is owned by the other task
	 * and may cease to exist at any time.  Don't use or modify
	 * new_timer after the unlock call.
	 */
out:
628
	release_posix_timer(new_timer, it_id_set);
L
Linus Torvalds 已提交
629 630 631 632 633 634 635 636 637 638
	return error;
}

/*
 * Locking issues: We need to protect the result of the id look up until
 * we get the timer locked down so it is not deleted under us.  The
 * removal is done under the idr spinlock so we use that here to bridge
 * the find to the timer lock.  To avoid a dead lock, the timer id MUST
 * be release with out holding the timer lock.
 */
N
Namhyung Kim 已提交
639
static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647
{
	struct k_itimer *timr;
	/*
	 * Watch out here.  We do a irqsave on the idr_lock and pass the
	 * flags part over to the timer lock.  Must not let interrupts in
	 * while we are moving the lock.
	 */
	spin_lock_irqsave(&idr_lock, *flags);
648
	timr = idr_find(&posix_timers_id, (int)timer_id);
L
Linus Torvalds 已提交
649 650
	if (timr) {
		spin_lock(&timr->it_lock);
651
		if (timr->it_signal == current->signal) {
652
			spin_unlock(&idr_lock);
653 654 655 656 657
			return timr;
		}
		spin_unlock(&timr->it_lock);
	}
	spin_unlock_irqrestore(&idr_lock, *flags);
L
Linus Torvalds 已提交
658

659
	return NULL;
L
Linus Torvalds 已提交
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
}

/*
 * Get the time remaining on a POSIX.1b interval timer.  This function
 * is ALWAYS called with spin_lock_irq on the timer, thus it must not
 * mess with irq.
 *
 * We have a couple of messes to clean up here.  First there is the case
 * of a timer that has a requeue pending.  These timers should appear to
 * be in the timer list with an expiry as if we were to requeue them
 * now.
 *
 * The second issue is the SIGEV_NONE timer which may be active but is
 * not really ever put in the timer list (to save system resources).
 * This timer may be expired, and if so, we will do it here.  Otherwise
 * it is the same as a requeue pending timer WRT to what we should
 * report.
 */
static void
common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
{
681
	ktime_t now, remaining, iv;
682
	struct hrtimer *timer = &timr->it.real.timer;
L
Linus Torvalds 已提交
683

684 685
	memset(cur_setting, 0, sizeof(struct itimerspec));

686 687
	iv = timr->it.real.interval;

688
	/* interval timer ? */
689 690 691 692
	if (iv.tv64)
		cur_setting->it_interval = ktime_to_timespec(iv);
	else if (!hrtimer_active(timer) &&
		 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
693
		return;
694 695 696

	now = timer->base->get_time();

697
	/*
698 699 700
	 * When a requeue is pending or this is a SIGEV_NONE
	 * timer move the expiry time forward by intervals, so
	 * expiry is > now.
701
	 */
702 703
	if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
	    (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
D
Davide Libenzi 已提交
704
		timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
705

706
	remaining = ktime_sub(hrtimer_get_expires(timer), now);
707
	/* Return 0 only, when the timer is expired and not pending */
708 709 710 711 712 713 714 715
	if (remaining.tv64 <= 0) {
		/*
		 * A single shot SIGEV_NONE timer must return 0, when
		 * it is expired !
		 */
		if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
			cur_setting->it_value.tv_nsec = 1;
	} else
716
		cur_setting->it_value = ktime_to_timespec(remaining);
L
Linus Torvalds 已提交
717 718 719
}

/* Get the time remaining on a POSIX.1b interval timer. */
720 721
SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
		struct itimerspec __user *, setting)
L
Linus Torvalds 已提交
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
{
	struct k_itimer *timr;
	struct itimerspec cur_setting;
	unsigned long flags;

	timr = lock_timer(timer_id, &flags);
	if (!timr)
		return -EINVAL;

	CLOCK_DISPATCH(timr->it_clock, timer_get, (timr, &cur_setting));

	unlock_timer(timr, flags);

	if (copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
		return -EFAULT;

	return 0;
}
740

L
Linus Torvalds 已提交
741 742 743 744 745 746 747 748 749
/*
 * Get the number of overruns of a POSIX.1b interval timer.  This is to
 * be the overrun of the timer last delivered.  At the same time we are
 * accumulating overruns on the next timer.  The overrun is frozen when
 * the signal is delivered, either at the notify time (if the info block
 * is not queued) or at the actual delivery time (as we are informed by
 * the call back to do_schedule_next_timer().  So all we need to do is
 * to pick up the frozen overrun.
 */
750
SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
L
Linus Torvalds 已提交
751 752 753
{
	struct k_itimer *timr;
	int overrun;
754
	unsigned long flags;
L
Linus Torvalds 已提交
755 756 757 758 759 760 761 762 763 764 765 766 767

	timr = lock_timer(timer_id, &flags);
	if (!timr)
		return -EINVAL;

	overrun = timr->it_overrun_last;
	unlock_timer(timr, flags);

	return overrun;
}

/* Set a POSIX.1b interval timer. */
/* timr->it_lock is taken. */
768
static int
L
Linus Torvalds 已提交
769 770 771
common_timer_set(struct k_itimer *timr, int flags,
		 struct itimerspec *new_setting, struct itimerspec *old_setting)
{
772
	struct hrtimer *timer = &timr->it.real.timer;
773
	enum hrtimer_mode mode;
L
Linus Torvalds 已提交
774 775 776 777 778

	if (old_setting)
		common_timer_get(timr, old_setting);

	/* disable the timer */
779
	timr->it.real.interval.tv64 = 0;
L
Linus Torvalds 已提交
780 781 782 783
	/*
	 * careful here.  If smp we could be in the "fire" routine which will
	 * be spinning as we hold the lock.  But this is ONLY an SMP issue.
	 */
784
	if (hrtimer_try_to_cancel(timer) < 0)
L
Linus Torvalds 已提交
785 786 787 788 789 790
		return TIMER_RETRY;

	timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 
		~REQUEUE_PENDING;
	timr->it_overrun_last = 0;

791 792 793
	/* switch off the timer when it_value is zero */
	if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
		return 0;
L
Linus Torvalds 已提交
794

795
	mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
796 797
	hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
	timr->it.real.timer.function = posix_timer_fn;
798

799
	hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
800 801 802 803 804

	/* Convert interval */
	timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);

	/* SIGEV_NONE timers are not queued ! See common_timer_get */
805 806
	if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
		/* Setup correct expiry time for relative timers */
807
		if (mode == HRTIMER_MODE_REL) {
808
			hrtimer_add_expires(timer, timer->base->get_time());
809
		}
810
		return 0;
811
	}
812

813
	hrtimer_start_expires(timer, mode);
L
Linus Torvalds 已提交
814 815 816 817
	return 0;
}

/* Set a POSIX.1b interval timer */
818 819 820
SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
		const struct itimerspec __user *, new_setting,
		struct itimerspec __user *, old_setting)
L
Linus Torvalds 已提交
821 822 823 824
{
	struct k_itimer *timr;
	struct itimerspec new_spec, old_spec;
	int error = 0;
825
	unsigned long flag;
L
Linus Torvalds 已提交
826 827 828 829 830 831 832 833
	struct itimerspec *rtn = old_setting ? &old_spec : NULL;

	if (!new_setting)
		return -EINVAL;

	if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
		return -EFAULT;

834 835
	if (!timespec_valid(&new_spec.it_interval) ||
	    !timespec_valid(&new_spec.it_value))
L
Linus Torvalds 已提交
836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
		return -EINVAL;
retry:
	timr = lock_timer(timer_id, &flag);
	if (!timr)
		return -EINVAL;

	error = CLOCK_DISPATCH(timr->it_clock, timer_set,
			       (timr, flags, &new_spec, rtn));

	unlock_timer(timr, flag);
	if (error == TIMER_RETRY) {
		rtn = NULL;	// We already got the old time...
		goto retry;
	}

851 852
	if (old_setting && !error &&
	    copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
L
Linus Torvalds 已提交
853 854 855 856 857 858 859
		error = -EFAULT;

	return error;
}

static inline int common_timer_del(struct k_itimer *timer)
{
860
	timer->it.real.interval.tv64 = 0;
861

862
	if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
L
Linus Torvalds 已提交
863 864 865 866 867 868 869 870 871 872
		return TIMER_RETRY;
	return 0;
}

static inline int timer_delete_hook(struct k_itimer *timer)
{
	return CLOCK_DISPATCH(timer->it_clock, timer_del, (timer));
}

/* Delete a POSIX.1b interval timer. */
873
SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
L
Linus Torvalds 已提交
874 875
{
	struct k_itimer *timer;
876
	unsigned long flags;
L
Linus Torvalds 已提交
877 878 879 880 881 882

retry_delete:
	timer = lock_timer(timer_id, &flags);
	if (!timer)
		return -EINVAL;

883
	if (timer_delete_hook(timer) == TIMER_RETRY) {
L
Linus Torvalds 已提交
884 885 886
		unlock_timer(timer, flags);
		goto retry_delete;
	}
887

L
Linus Torvalds 已提交
888 889 890 891 892 893 894
	spin_lock(&current->sighand->siglock);
	list_del(&timer->list);
	spin_unlock(&current->sighand->siglock);
	/*
	 * This keeps any tasks waiting on the spin lock from thinking
	 * they got something (see the lock code above).
	 */
895
	timer->it_signal = NULL;
896

L
Linus Torvalds 已提交
897 898 899 900
	unlock_timer(timer, flags);
	release_posix_timer(timer, IT_ID_SET);
	return 0;
}
901

L
Linus Torvalds 已提交
902 903 904
/*
 * return timer owned by the process, used by exit_itimers
 */
905
static void itimer_delete(struct k_itimer *timer)
L
Linus Torvalds 已提交
906 907 908 909 910 911
{
	unsigned long flags;

retry_delete:
	spin_lock_irqsave(&timer->it_lock, flags);

912
	if (timer_delete_hook(timer) == TIMER_RETRY) {
L
Linus Torvalds 已提交
913 914 915 916 917 918 919 920
		unlock_timer(timer, flags);
		goto retry_delete;
	}
	list_del(&timer->list);
	/*
	 * This keeps any tasks waiting on the spin lock from thinking
	 * they got something (see the lock code above).
	 */
921
	timer->it_signal = NULL;
922

L
Linus Torvalds 已提交
923 924 925 926 927
	unlock_timer(timer, flags);
	release_posix_timer(timer, IT_ID_SET);
}

/*
928
 * This is called by do_exit or de_thread, only when there are no more
L
Linus Torvalds 已提交
929 930 931 932 933 934 935 936 937 938 939 940
 * references to the shared signal_struct.
 */
void exit_itimers(struct signal_struct *sig)
{
	struct k_itimer *tmr;

	while (!list_empty(&sig->posix_timers)) {
		tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
		itimer_delete(tmr);
	}
}

941
/* Not available / possible... functions */
942
int do_posix_clock_nosettime(const clockid_t clockid, const struct timespec *tp)
L
Linus Torvalds 已提交
943 944 945 946 947
{
	return -EINVAL;
}
EXPORT_SYMBOL_GPL(do_posix_clock_nosettime);

948 949
SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
		const struct timespec __user *, tp)
L
Linus Torvalds 已提交
950 951 952 953 954 955 956 957 958 959 960
{
	struct timespec new_tp;

	if (invalid_clockid(which_clock))
		return -EINVAL;
	if (copy_from_user(&new_tp, tp, sizeof (*tp)))
		return -EFAULT;

	return CLOCK_DISPATCH(which_clock, clock_set, (which_clock, &new_tp));
}

961 962
SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
		struct timespec __user *,tp)
L
Linus Torvalds 已提交
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
{
	struct timespec kernel_tp;
	int error;

	if (invalid_clockid(which_clock))
		return -EINVAL;
	error = CLOCK_DISPATCH(which_clock, clock_get,
			       (which_clock, &kernel_tp));
	if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
		error = -EFAULT;

	return error;

}

978 979
SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
		struct timespec __user *, tp)
L
Linus Torvalds 已提交
980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
{
	struct timespec rtn_tp;
	int error;

	if (invalid_clockid(which_clock))
		return -EINVAL;

	error = CLOCK_DISPATCH(which_clock, clock_getres,
			       (which_clock, &rtn_tp));

	if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp))) {
		error = -EFAULT;
	}

	return error;
}

997 998 999 1000 1001 1002
/*
 * nanosleep for monotonic and realtime clocks
 */
static int common_nsleep(const clockid_t which_clock, int flags,
			 struct timespec *tsave, struct timespec __user *rmtp)
{
1003 1004 1005
	return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
				 which_clock);
1006
}
L
Linus Torvalds 已提交
1007

1008 1009 1010
SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
		const struct timespec __user *, rqtp,
		struct timespec __user *, rmtp)
L
Linus Torvalds 已提交
1011
{
1012
	struct k_clock *kc = clockid_to_kclock(which_clock);
L
Linus Torvalds 已提交
1013 1014
	struct timespec t;

1015
	if (!kc)
L
Linus Torvalds 已提交
1016
		return -EINVAL;
1017 1018
	if (!kc->nsleep)
		return -ENANOSLEEP_NOTSUP;
L
Linus Torvalds 已提交
1019 1020 1021 1022

	if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
		return -EFAULT;

1023
	if (!timespec_valid(&t))
L
Linus Torvalds 已提交
1024 1025
		return -EINVAL;

1026
	return kc->nsleep(which_clock, flags, &t, rmtp);
L
Linus Torvalds 已提交
1027
}
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048

/*
 * nanosleep_restart for monotonic and realtime clocks
 */
static int common_nsleep_restart(struct restart_block *restart_block)
{
	return hrtimer_nanosleep_restart(restart_block);
}

/*
 * This will restart clock_nanosleep. This is required only by
 * compat_clock_nanosleep_restart for now.
 */
long
clock_nanosleep_restart(struct restart_block *restart_block)
{
	clockid_t which_clock = restart_block->arg0;

	return CLOCK_DISPATCH(which_clock, nsleep_restart,
			      (restart_block));
}