posix-timers.c 28.7 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
static int common_nsleep(const clockid_t, int flags, struct timespec *t,
			 struct timespec __user *rmtp);
149
static int common_timer_create(struct k_itimer *new_timer);
150 151 152 153
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 已提交
154

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

N
Namhyung Kim 已提交
157 158 159 160 161 162 163
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 已提交
164 165 166 167 168 169

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

170 171 172 173 174 175 176
/* Get clock_realtime */
static int posix_clock_realtime_get(clockid_t which_clock, struct timespec *tp)
{
	ktime_get_real_ts(tp);
	return 0;
}

177 178 179 180 181 182 183
/* Set clock_realtime */
static int posix_clock_realtime_set(const clockid_t which_clock,
				    const struct timespec *tp)
{
	return do_sys_settimeofday(tp, NULL);
}

184 185 186 187 188 189 190 191
/*
 * 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 已提交
192

193 194 195 196 197 198 199 200 201
/*
 * Get monotonic time for posix timers
 */
static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp)
{
	getrawmonotonic(tp);
	return 0;
}

202 203 204 205 206 207 208 209 210 211 212 213 214 215

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;
}

216
static int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp)
217 218 219 220
{
	*tp = ktime_to_timespec(KTIME_LOW_RES);
	return 0;
}
L
Linus Torvalds 已提交
221 222 223 224 225
/*
 * Initialize everything, well, just everything in Posix clocks/timers ;)
 */
static __init int init_posix_timers(void)
{
226
	struct k_clock clock_realtime = {
227
		.clock_getres	= hrtimer_get_res,
228
		.clock_get	= posix_clock_realtime_get,
229
		.clock_set	= posix_clock_realtime_set,
230
		.nsleep		= common_nsleep,
231
		.nsleep_restart	= hrtimer_nanosleep_restart,
232
		.timer_create	= common_timer_create,
233
		.timer_set	= common_timer_set,
234
		.timer_get	= common_timer_get,
235
		.timer_del	= common_timer_del,
L
Linus Torvalds 已提交
236
	};
237
	struct k_clock clock_monotonic = {
238 239
		.clock_getres	= hrtimer_get_res,
		.clock_get	= posix_ktime_get_ts,
240
		.nsleep		= common_nsleep,
241
		.nsleep_restart	= hrtimer_nanosleep_restart,
242
		.timer_create	= common_timer_create,
243
		.timer_set	= common_timer_set,
244
		.timer_get	= common_timer_get,
245
		.timer_del	= common_timer_del,
L
Linus Torvalds 已提交
246
	};
247
	struct k_clock clock_monotonic_raw = {
248 249
		.clock_getres	= hrtimer_get_res,
		.clock_get	= posix_get_monotonic_raw,
250
	};
251
	struct k_clock clock_realtime_coarse = {
252 253
		.clock_getres	= posix_get_coarse_res,
		.clock_get	= posix_get_realtime_coarse,
254 255
	};
	struct k_clock clock_monotonic_coarse = {
256 257
		.clock_getres	= posix_get_coarse_res,
		.clock_get	= posix_get_monotonic_coarse,
258
	};
L
Linus Torvalds 已提交
259 260 261

	register_posix_clock(CLOCK_REALTIME, &clock_realtime);
	register_posix_clock(CLOCK_MONOTONIC, &clock_monotonic);
262
	register_posix_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
263 264
	register_posix_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
	register_posix_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
L
Linus Torvalds 已提交
265 266

	posix_timers_cache = kmem_cache_create("posix_timers_cache",
267 268
					sizeof (struct k_itimer), 0, SLAB_PANIC,
					NULL);
L
Linus Torvalds 已提交
269 270 271 272 273 274 275 276
	idr_init(&posix_timers_id);
	return 0;
}

__initcall(init_posix_timers);

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

279
	if (timr->it.real.interval.tv64 == 0)
L
Linus Torvalds 已提交
280 281
		return;

D
Davide Libenzi 已提交
282 283 284
	timr->it_overrun += (unsigned int) hrtimer_forward(timer,
						timer->base->get_time(),
						timr->it.real.interval);
285

L
Linus Torvalds 已提交
286 287 288
	timr->it_overrun_last = timr->it_overrun;
	timr->it_overrun = -1;
	++timr->it_requeue_pending;
289
	hrtimer_restart(timer);
L
Linus Torvalds 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
}

/*
 * 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);

310 311 312 313 314
	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 已提交
315

316
		info->si_overrun += timr->it_overrun_last;
317 318
	}

319 320
	if (timr)
		unlock_timer(timr, flags);
L
Linus Torvalds 已提交
321 322
}

323
int posix_timer_event(struct k_itimer *timr, int si_private)
L
Linus Torvalds 已提交
324
{
325 326
	struct task_struct *task;
	int shared, ret = -1;
327 328 329 330 331 332 333 334 335 336 337
	/*
	 * 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 已提交
338 339
	timr->sigq->info.si_sys_private = si_private;

340 341 342 343 344 345 346
	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();
347 348
	/* If we failed to send the signal the timer stops. */
	return ret > 0;
L
Linus Torvalds 已提交
349 350 351 352 353 354 355 356 357 358
}
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.
 */
359
static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
L
Linus Torvalds 已提交
360
{
361
	struct k_itimer *timr;
L
Linus Torvalds 已提交
362
	unsigned long flags;
363
	int si_private = 0;
364
	enum hrtimer_restart ret = HRTIMER_NORESTART;
L
Linus Torvalds 已提交
365

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

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

372 373 374 375 376 377 378
	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) {
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
			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 已提交
411
			timr->it_overrun += (unsigned int)
412
				hrtimer_forward(timer, now,
413 414
						timr->it.real.interval);
			ret = HRTIMER_RESTART;
415
			++timr->it_requeue_pending;
L
Linus Torvalds 已提交
416 417 418
		}
	}

419 420 421
	unlock_timer(timr, flags);
	return ret;
}
L
Linus Torvalds 已提交
422

423
static struct pid *good_sigevent(sigevent_t * event)
L
Linus Torvalds 已提交
424 425 426 427
{
	struct task_struct *rtn = current->group_leader;

	if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
428
		(!(rtn = find_task_by_vpid(event->sigev_notify_thread_id)) ||
429
		 !same_thread_group(rtn, current) ||
L
Linus Torvalds 已提交
430 431 432 433 434 435 436
		 (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;

437
	return task_pid(rtn);
L
Linus Torvalds 已提交
438 439
}

440
void register_posix_clock(const clockid_t clock_id, struct k_clock *new_clock)
L
Linus Torvalds 已提交
441 442
{
	if ((unsigned) clock_id >= MAX_CLOCKS) {
443 444 445 446 447 448 449 450 451 452 453 454
		printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",
		       clock_id);
		return;
	}

	if (!new_clock->clock_get) {
		printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",
		       clock_id);
		return;
	}
	if (!new_clock->clock_getres) {
		printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",
L
Linus Torvalds 已提交
455 456 457 458 459 460 461 462 463 464 465
		       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;
466
	tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
L
Linus Torvalds 已提交
467 468 469 470
	if (!tmr)
		return tmr;
	if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
		kmem_cache_free(posix_timers_cache, tmr);
471
		return NULL;
L
Linus Torvalds 已提交
472
	}
473
	memset(&tmr->sigq->info, 0, sizeof(siginfo_t));
L
Linus Torvalds 已提交
474 475 476 477 478 479 480 481 482 483 484 485 486
	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);
	}
487
	put_pid(tmr->it_pid);
L
Linus Torvalds 已提交
488 489 490 491
	sigqueue_free(tmr->sigq);
	kmem_cache_free(posix_timers_cache, tmr);
}

492 493 494 495 496 497 498 499 500 501
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];
}

502 503 504 505 506 507
static int common_timer_create(struct k_itimer *new_timer)
{
	hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
	return 0;
}

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

510 511 512
SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
		struct sigevent __user *, timer_event_spec,
		timer_t __user *, created_timer_id)
L
Linus Torvalds 已提交
513
{
514
	struct k_clock *kc = clockid_to_kclock(which_clock);
515
	struct k_itimer *new_timer;
516
	int error, new_timer_id;
L
Linus Torvalds 已提交
517 518 519
	sigevent_t event;
	int it_id_set = IT_ID_NOT_SET;

520
	if (!kc)
L
Linus Torvalds 已提交
521
		return -EINVAL;
522 523
	if (!kc->timer_create)
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531 532 533 534 535

	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);
536
	error = idr_get_new(&posix_timers_id, new_timer, &new_timer_id);
L
Linus Torvalds 已提交
537
	spin_unlock_irq(&idr_lock);
538 539 540
	if (error) {
		if (error == -EAGAIN)
			goto retry;
L
Linus Torvalds 已提交
541
		/*
J
Joe Perches 已提交
542
		 * Weird looking, but we return EAGAIN if the IDR is
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
		 * 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;
		}
559
		rcu_read_lock();
560
		new_timer->it_pid = get_pid(good_sigevent(&event));
561
		rcu_read_unlock();
562
		if (!new_timer->it_pid) {
L
Linus Torvalds 已提交
563 564 565 566
			error = -EINVAL;
			goto out;
		}
	} else {
567 568 569
		event.sigev_notify = SIGEV_SIGNAL;
		event.sigev_signo = SIGALRM;
		event.sigev_value.sival_int = new_timer->it_id;
570
		new_timer->it_pid = get_pid(task_tgid(current));
L
Linus Torvalds 已提交
571 572
	}

573 574 575
	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;
576
	new_timer->sigq->info.si_tid   = new_timer->it_id;
577
	new_timer->sigq->info.si_code  = SI_TIMER;
578

579 580 581 582 583 584
	if (copy_to_user(created_timer_id,
			 &new_timer_id, sizeof (new_timer_id))) {
		error = -EFAULT;
		goto out;
	}

585
	error = kc->timer_create(new_timer);
586 587 588
	if (error)
		goto out;

589
	spin_lock_irq(&current->sighand->siglock);
590
	new_timer->it_signal = current->signal;
591 592
	list_add(&new_timer->list, &current->signal->posix_timers);
	spin_unlock_irq(&current->sighand->siglock);
593 594

	return 0;
595
	/*
L
Linus Torvalds 已提交
596 597 598 599 600 601
	 * 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:
602
	release_posix_timer(new_timer, it_id_set);
L
Linus Torvalds 已提交
603 604 605 606 607 608 609 610 611 612
	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 已提交
613
static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
L
Linus Torvalds 已提交
614 615 616 617 618 619 620 621
{
	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);
622
	timr = idr_find(&posix_timers_id, (int)timer_id);
L
Linus Torvalds 已提交
623 624
	if (timr) {
		spin_lock(&timr->it_lock);
625
		if (timr->it_signal == current->signal) {
626
			spin_unlock(&idr_lock);
627 628 629 630 631
			return timr;
		}
		spin_unlock(&timr->it_lock);
	}
	spin_unlock_irqrestore(&idr_lock, *flags);
L
Linus Torvalds 已提交
632

633
	return NULL;
L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
}

/*
 * 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)
{
655
	ktime_t now, remaining, iv;
656
	struct hrtimer *timer = &timr->it.real.timer;
L
Linus Torvalds 已提交
657

658 659
	memset(cur_setting, 0, sizeof(struct itimerspec));

660 661
	iv = timr->it.real.interval;

662
	/* interval timer ? */
663 664 665 666
	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)
667
		return;
668 669 670

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

671
	/*
672 673 674
	 * When a requeue is pending or this is a SIGEV_NONE
	 * timer move the expiry time forward by intervals, so
	 * expiry is > now.
675
	 */
676 677
	if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
	    (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
D
Davide Libenzi 已提交
678
		timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
679

680
	remaining = ktime_sub(hrtimer_get_expires(timer), now);
681
	/* Return 0 only, when the timer is expired and not pending */
682 683 684 685 686 687 688 689
	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
690
		cur_setting->it_value = ktime_to_timespec(remaining);
L
Linus Torvalds 已提交
691 692 693
}

/* Get the time remaining on a POSIX.1b interval timer. */
694 695
SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
		struct itimerspec __user *, setting)
L
Linus Torvalds 已提交
696 697
{
	struct itimerspec cur_setting;
698 699
	struct k_itimer *timr;
	struct k_clock *kc;
L
Linus Torvalds 已提交
700
	unsigned long flags;
701
	int ret = 0;
L
Linus Torvalds 已提交
702 703 704 705 706

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

707 708 709 710 711
	kc = clockid_to_kclock(timr->it_clock);
	if (WARN_ON_ONCE(!kc || !kc->timer_get))
		ret = -EINVAL;
	else
		kc->timer_get(timr, &cur_setting);
L
Linus Torvalds 已提交
712 713 714

	unlock_timer(timr, flags);

715
	if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
L
Linus Torvalds 已提交
716 717
		return -EFAULT;

718
	return ret;
L
Linus Torvalds 已提交
719
}
720

L
Linus Torvalds 已提交
721 722 723 724 725 726 727 728 729
/*
 * 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.
 */
730
SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
L
Linus Torvalds 已提交
731 732 733
{
	struct k_itimer *timr;
	int overrun;
734
	unsigned long flags;
L
Linus Torvalds 已提交
735 736 737 738 739 740 741 742 743 744 745 746 747

	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. */
748
static int
L
Linus Torvalds 已提交
749 750 751
common_timer_set(struct k_itimer *timr, int flags,
		 struct itimerspec *new_setting, struct itimerspec *old_setting)
{
752
	struct hrtimer *timer = &timr->it.real.timer;
753
	enum hrtimer_mode mode;
L
Linus Torvalds 已提交
754 755 756 757 758

	if (old_setting)
		common_timer_get(timr, old_setting);

	/* disable the timer */
759
	timr->it.real.interval.tv64 = 0;
L
Linus Torvalds 已提交
760 761 762 763
	/*
	 * 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.
	 */
764
	if (hrtimer_try_to_cancel(timer) < 0)
L
Linus Torvalds 已提交
765 766 767 768 769 770
		return TIMER_RETRY;

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

771 772 773
	/* 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 已提交
774

775
	mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
776 777
	hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
	timr->it.real.timer.function = posix_timer_fn;
778

779
	hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
780 781 782 783 784

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

	/* SIGEV_NONE timers are not queued ! See common_timer_get */
785 786
	if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
		/* Setup correct expiry time for relative timers */
787
		if (mode == HRTIMER_MODE_REL) {
788
			hrtimer_add_expires(timer, timer->base->get_time());
789
		}
790
		return 0;
791
	}
792

793
	hrtimer_start_expires(timer, mode);
L
Linus Torvalds 已提交
794 795 796 797
	return 0;
}

/* Set a POSIX.1b interval timer */
798 799 800
SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
		const struct itimerspec __user *, new_setting,
		struct itimerspec __user *, old_setting)
L
Linus Torvalds 已提交
801 802 803 804
{
	struct k_itimer *timr;
	struct itimerspec new_spec, old_spec;
	int error = 0;
805
	unsigned long flag;
L
Linus Torvalds 已提交
806
	struct itimerspec *rtn = old_setting ? &old_spec : NULL;
807
	struct k_clock *kc;
L
Linus Torvalds 已提交
808 809 810 811 812 813 814

	if (!new_setting)
		return -EINVAL;

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

815 816
	if (!timespec_valid(&new_spec.it_interval) ||
	    !timespec_valid(&new_spec.it_value))
L
Linus Torvalds 已提交
817 818 819 820 821 822
		return -EINVAL;
retry:
	timr = lock_timer(timer_id, &flag);
	if (!timr)
		return -EINVAL;

823 824 825 826 827
	kc = clockid_to_kclock(timr->it_clock);
	if (WARN_ON_ONCE(!kc || !kc->timer_set))
		error = -EINVAL;
	else
		error = kc->timer_set(timr, flags, &new_spec, rtn);
L
Linus Torvalds 已提交
828 829 830 831 832 833 834

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

835 836
	if (old_setting && !error &&
	    copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
L
Linus Torvalds 已提交
837 838 839 840 841
		error = -EFAULT;

	return error;
}

842
static int common_timer_del(struct k_itimer *timer)
L
Linus Torvalds 已提交
843
{
844
	timer->it.real.interval.tv64 = 0;
845

846
	if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
L
Linus Torvalds 已提交
847 848 849 850 851 852
		return TIMER_RETRY;
	return 0;
}

static inline int timer_delete_hook(struct k_itimer *timer)
{
853 854 855 856 857
	struct k_clock *kc = clockid_to_kclock(timer->it_clock);

	if (WARN_ON_ONCE(!kc || !kc->timer_del))
		return -EINVAL;
	return kc->timer_del(timer);
L
Linus Torvalds 已提交
858 859 860
}

/* Delete a POSIX.1b interval timer. */
861
SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
L
Linus Torvalds 已提交
862 863
{
	struct k_itimer *timer;
864
	unsigned long flags;
L
Linus Torvalds 已提交
865 866 867 868 869 870

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

871
	if (timer_delete_hook(timer) == TIMER_RETRY) {
L
Linus Torvalds 已提交
872 873 874
		unlock_timer(timer, flags);
		goto retry_delete;
	}
875

L
Linus Torvalds 已提交
876 877 878 879 880 881 882
	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).
	 */
883
	timer->it_signal = NULL;
884

L
Linus Torvalds 已提交
885 886 887 888
	unlock_timer(timer, flags);
	release_posix_timer(timer, IT_ID_SET);
	return 0;
}
889

L
Linus Torvalds 已提交
890 891 892
/*
 * return timer owned by the process, used by exit_itimers
 */
893
static void itimer_delete(struct k_itimer *timer)
L
Linus Torvalds 已提交
894 895 896 897 898 899
{
	unsigned long flags;

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

900
	if (timer_delete_hook(timer) == TIMER_RETRY) {
L
Linus Torvalds 已提交
901 902 903 904 905 906 907 908
		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).
	 */
909
	timer->it_signal = NULL;
910

L
Linus Torvalds 已提交
911 912 913 914 915
	unlock_timer(timer, flags);
	release_posix_timer(timer, IT_ID_SET);
}

/*
916
 * This is called by do_exit or de_thread, only when there are no more
L
Linus Torvalds 已提交
917 918 919 920 921 922 923 924 925 926 927 928
 * 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);
	}
}

929 930
SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
		const struct timespec __user *, tp)
L
Linus Torvalds 已提交
931
{
932
	struct k_clock *kc = clockid_to_kclock(which_clock);
L
Linus Torvalds 已提交
933 934
	struct timespec new_tp;

935
	if (!kc || !kc->clock_set)
L
Linus Torvalds 已提交
936
		return -EINVAL;
937

L
Linus Torvalds 已提交
938 939 940
	if (copy_from_user(&new_tp, tp, sizeof (*tp)))
		return -EFAULT;

941
	return kc->clock_set(which_clock, &new_tp);
L
Linus Torvalds 已提交
942 943
}

944 945
SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
		struct timespec __user *,tp)
L
Linus Torvalds 已提交
946
{
947
	struct k_clock *kc = clockid_to_kclock(which_clock);
L
Linus Torvalds 已提交
948 949 950
	struct timespec kernel_tp;
	int error;

951
	if (!kc)
L
Linus Torvalds 已提交
952
		return -EINVAL;
953 954 955

	error = kc->clock_get(which_clock, &kernel_tp);

L
Linus Torvalds 已提交
956 957 958 959 960 961
	if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
		error = -EFAULT;

	return error;
}

962 963
SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
		struct timespec __user *, tp)
L
Linus Torvalds 已提交
964
{
965
	struct k_clock *kc = clockid_to_kclock(which_clock);
L
Linus Torvalds 已提交
966 967 968
	struct timespec rtn_tp;
	int error;

969
	if (!kc)
L
Linus Torvalds 已提交
970 971
		return -EINVAL;

972
	error = kc->clock_getres(which_clock, &rtn_tp);
L
Linus Torvalds 已提交
973

974
	if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp)))
L
Linus Torvalds 已提交
975 976 977 978 979
		error = -EFAULT;

	return error;
}

980 981 982 983 984 985
/*
 * nanosleep for monotonic and realtime clocks
 */
static int common_nsleep(const clockid_t which_clock, int flags,
			 struct timespec *tsave, struct timespec __user *rmtp)
{
986 987 988
	return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
				 which_clock);
989
}
L
Linus Torvalds 已提交
990

991 992 993
SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
		const struct timespec __user *, rqtp,
		struct timespec __user *, rmtp)
L
Linus Torvalds 已提交
994
{
995
	struct k_clock *kc = clockid_to_kclock(which_clock);
L
Linus Torvalds 已提交
996 997
	struct timespec t;

998
	if (!kc)
L
Linus Torvalds 已提交
999
		return -EINVAL;
1000 1001
	if (!kc->nsleep)
		return -ENANOSLEEP_NOTSUP;
L
Linus Torvalds 已提交
1002 1003 1004 1005

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

1006
	if (!timespec_valid(&t))
L
Linus Torvalds 已提交
1007 1008
		return -EINVAL;

1009
	return kc->nsleep(which_clock, flags, &t, rmtp);
L
Linus Torvalds 已提交
1010
}
1011 1012 1013 1014 1015

/*
 * This will restart clock_nanosleep. This is required only by
 * compat_clock_nanosleep_restart for now.
 */
1016
long clock_nanosleep_restart(struct restart_block *restart_block)
1017
{
1018
	clockid_t which_clock = restart_block->nanosleep.index;
1019 1020 1021 1022
	struct k_clock *kc = clockid_to_kclock(which_clock);

	if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
		return -EINVAL;
1023

1024
	return kc->nsleep_restart(restart_block);
1025
}