[linux.git] / kernel / time / itimer.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 1992 Darren Senn
 */

/* These are all the functions necessary to implement itimers */

#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/syscalls.h>
#include <linux/time.h>
#include <linux/sched/signal.h>
#include <linux/sched/cputime.h>
#include <linux/posix-timers.h>
#include <linux/hrtimer.h>
#include <trace/events/timer.h>
#include <linux/compat.h>

#include <linux/uaccess.h>

/**
 * itimer_get_remtime - get remaining time for the timer
 *
 * @timer: the timer to read
 *
 * Returns the delta between the expiry time and now, which can be
 * less than zero or 1usec for an pending expired timer
 */
static struct timespec64 itimer_get_remtime(struct hrtimer *timer)
{
	ktime_t rem = __hrtimer_get_remaining(timer, true);

	/*
	 * Racy but safe: if the itimer expires after the above
	 * hrtimer_get_remtime() call but before this condition
	 * then we return 0 - which is correct.
	 */
	if (hrtimer_active(timer)) {
		if (rem <= 0)
			rem = NSEC_PER_USEC;
	} else
		rem = 0;

	return ktime_to_timespec64(rem);
}

static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
			   struct itimerspec64 *const value)
{
	u64 val, interval;
	struct cpu_itimer *it = &tsk->signal->it[clock_id];

	spin_lock_irq(&tsk->sighand->siglock);

	val = it->expires;
	interval = it->incr;
	if (val) {
		u64 t, samples[CPUCLOCK_MAX];

		thread_group_sample_cputime(tsk, samples);
		t = samples[clock_id];

		if (val < t)
			/* about to fire */
			val = TICK_NSEC;
		else
			val -= t;
	}

	spin_unlock_irq(&tsk->sighand->siglock);

	value->it_value = ns_to_timespec64(val);
	value->it_interval = ns_to_timespec64(interval);
}

static int do_getitimer(int which, struct itimerspec64 *value)
{
	struct task_struct *tsk = current;

	switch (which) {
	case ITIMER_REAL:
		spin_lock_irq(&tsk->sighand->siglock);
		value->it_value = itimer_get_remtime(&tsk->signal->real_timer);
		value->it_interval =
			ktime_to_timespec64(tsk->signal->it_real_incr);
		spin_unlock_irq(&tsk->sighand->siglock);
		break;
	case ITIMER_VIRTUAL:
		get_cpu_itimer(tsk, CPUCLOCK_VIRT, value);
		break;
	case ITIMER_PROF:
		get_cpu_itimer(tsk, CPUCLOCK_PROF, value);
		break;
	default:
		return(-EINVAL);
	}
	return 0;
}

static int put_itimerval(struct __kernel_old_itimerval __user *o,
			 const struct itimerspec64 *i)
{
	struct __kernel_old_itimerval v;

	v.it_interval.tv_sec = i->it_interval.tv_sec;
	v.it_interval.tv_usec = i->it_interval.tv_nsec / NSEC_PER_USEC;
	v.it_value.tv_sec = i->it_value.tv_sec;
	v.it_value.tv_usec = i->it_value.tv_nsec / NSEC_PER_USEC;
	return copy_to_user(o, &v, sizeof(struct __kernel_old_itimerval)) ? -EFAULT : 0;
}


SYSCALL_DEFINE2(getitimer, int, which, struct __kernel_old_itimerval __user *, value)
{
	struct itimerspec64 get_buffer;
	int error = do_getitimer(which, &get_buffer);

	if (!error && put_itimerval(value, &get_buffer))
		error = -EFAULT;
	return error;
}

#if defined(CONFIG_COMPAT) || defined(CONFIG_ALPHA)
struct old_itimerval32 {
	struct old_timeval32	it_interval;
	struct old_timeval32	it_value;
};

static int put_old_itimerval32(struct old_itimerval32 __user *o,
			       const struct itimerspec64 *i)
{
	struct old_itimerval32 v32;

	v32.it_interval.tv_sec = i->it_interval.tv_sec;
	v32.it_interval.tv_usec = i->it_interval.tv_nsec / NSEC_PER_USEC;
	v32.it_value.tv_sec = i->it_value.tv_sec;
	v32.it_value.tv_usec = i->it_value.tv_nsec / NSEC_PER_USEC;
	return copy_to_user(o, &v32, sizeof(struct old_itimerval32)) ? -EFAULT : 0;
}

COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
		       struct old_itimerval32 __user *, value)
{
	struct itimerspec64 get_buffer;
	int error = do_getitimer(which, &get_buffer);

	if (!error && put_old_itimerval32(value, &get_buffer))
		error = -EFAULT;
	return error;
}
#endif

/*
 * The timer is automagically restarted, when interval != 0
 */
enum hrtimer_restart it_real_fn(struct hrtimer *timer)
{
	struct signal_struct *sig =
		container_of(timer, struct signal_struct, real_timer);
	struct pid *leader_pid = sig->pids[PIDTYPE_TGID];

	trace_itimer_expire(ITIMER_REAL, leader_pid, 0);
	kill_pid_info(SIGALRM, SEND_SIG_PRIV, leader_pid);

	return HRTIMER_NORESTART;
}

static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
			   const struct itimerspec64 *const value,
			   struct itimerspec64 *const ovalue)
{
	u64 oval, nval, ointerval, ninterval;
	struct cpu_itimer *it = &tsk->signal->it[clock_id];

	nval = timespec64_to_ns(&value->it_value);
	ninterval = timespec64_to_ns(&value->it_interval);

	spin_lock_irq(&tsk->sighand->siglock);

	oval = it->expires;
	ointerval = it->incr;
	if (oval || nval) {
		if (nval > 0)
			nval += TICK_NSEC;
		set_process_cpu_timer(tsk, clock_id, &nval, &oval);
	}
	it->expires = nval;
	it->incr = ninterval;
	trace_itimer_state(clock_id == CPUCLOCK_VIRT ?
			   ITIMER_VIRTUAL : ITIMER_PROF, value, nval);

	spin_unlock_irq(&tsk->sighand->siglock);

	if (ovalue) {
		ovalue->it_value = ns_to_timespec64(oval);
		ovalue->it_interval = ns_to_timespec64(ointerval);
	}
}

/*
 * Returns true if the timeval is in canonical form
 */
#define timeval_valid(t) \
	(((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC))

static int do_setitimer(int which, struct itimerspec64 *value,
			struct itimerspec64 *ovalue)
{
	struct task_struct *tsk = current;
	struct hrtimer *timer;
	ktime_t expires;

	switch (which) {
	case ITIMER_REAL:
again:
		spin_lock_irq(&tsk->sighand->siglock);
		timer = &tsk->signal->real_timer;
		if (ovalue) {
			ovalue->it_value = itimer_get_remtime(timer);
			ovalue->it_interval
				= ktime_to_timespec64(tsk->signal->it_real_incr);
		}
		/* We are sharing ->siglock with it_real_fn() */
		if (hrtimer_try_to_cancel(timer) < 0) {
			spin_unlock_irq(&tsk->sighand->siglock);
			hrtimer_cancel_wait_running(timer);
			goto again;
		}
		expires = timespec64_to_ktime(value->it_value);
		if (expires != 0) {
			tsk->signal->it_real_incr =
				timespec64_to_ktime(value->it_interval);
			hrtimer_start(timer, expires, HRTIMER_MODE_REL);
		} else
			tsk->signal->it_real_incr = 0;

		trace_itimer_state(ITIMER_REAL, value, 0);
		spin_unlock_irq(&tsk->sighand->siglock);
		break;
	case ITIMER_VIRTUAL:
		set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue);
		break;
	case ITIMER_PROF:
		set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue);
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

#ifdef CONFIG_SECURITY_SELINUX
void clear_itimer(void)
{
	struct itimerspec64 v = {};
	int i;

	for (i = 0; i < 3; i++)
		do_setitimer(i, &v, NULL);
}
#endif

#ifdef __ARCH_WANT_SYS_ALARM

/**
 * alarm_setitimer - set alarm in seconds
 *
 * @seconds:	number of seconds until alarm
 *		0 disables the alarm
 *
 * Returns the remaining time in seconds of a pending timer or 0 when
 * the timer is not active.
 *
 * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid
 * negative timeval settings which would cause immediate expiry.
 */
static unsigned int alarm_setitimer(unsigned int seconds)
{
	struct itimerspec64 it_new, it_old;

#if BITS_PER_LONG < 64
	if (seconds > INT_MAX)
		seconds = INT_MAX;
#endif
	it_new.it_value.tv_sec = seconds;
	it_new.it_value.tv_nsec = 0;
	it_new.it_interval.tv_sec = it_new.it_interval.tv_nsec = 0;

	do_setitimer(ITIMER_REAL, &it_new, &it_old);

	/*
	 * We can't return 0 if we have an alarm pending ...  And we'd
	 * better return too much than too little anyway
	 */
	if ((!it_old.it_value.tv_sec && it_old.it_value.tv_nsec) ||
	      it_old.it_value.tv_nsec >= (NSEC_PER_SEC / 2))
		it_old.it_value.tv_sec++;

	return it_old.it_value.tv_sec;
}

/*
 * For backwards compatibility?  This can be done in libc so Alpha
 * and all newer ports shouldn't need it.
 */
SYSCALL_DEFINE1(alarm, unsigned int, seconds)
{
	return alarm_setitimer(seconds);
}

#endif

static int get_itimerval(struct itimerspec64 *o, const struct __kernel_old_itimerval __user *i)
{
	struct __kernel_old_itimerval v;

	if (copy_from_user(&v, i, sizeof(struct __kernel_old_itimerval)))
		return -EFAULT;

	/* Validate the timevals in value. */
	if (!timeval_valid(&v.it_value) ||
	    !timeval_valid(&v.it_interval))
		return -EINVAL;

	o->it_interval.tv_sec = v.it_interval.tv_sec;
	o->it_interval.tv_nsec = v.it_interval.tv_usec * NSEC_PER_USEC;
	o->it_value.tv_sec = v.it_value.tv_sec;
	o->it_value.tv_nsec = v.it_value.tv_usec * NSEC_PER_USEC;
	return 0;
}

SYSCALL_DEFINE3(setitimer, int, which, struct __kernel_old_itimerval __user *, value,
		struct __kernel_old_itimerval __user *, ovalue)
{
	struct itimerspec64 set_buffer, get_buffer;
	int error;

	if (value) {
		error = get_itimerval(&set_buffer, value);
		if (error)
			return error;
	} else {
		memset(&set_buffer, 0, sizeof(set_buffer));
		printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer."
			    " Misfeature support will be removed\n",
			    current->comm);
	}

	error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
	if (error || !ovalue)
		return error;

	if (put_itimerval(ovalue, &get_buffer))
		return -EFAULT;
	return 0;
}

#if defined(CONFIG_COMPAT) || defined(CONFIG_ALPHA)
static int get_old_itimerval32(struct itimerspec64 *o, const struct old_itimerval32 __user *i)
{
	struct old_itimerval32 v32;

	if (copy_from_user(&v32, i, sizeof(struct old_itimerval32)))
		return -EFAULT;

	/* Validate the timevals in value.  */
	if (!timeval_valid(&v32.it_value) ||
	    !timeval_valid(&v32.it_interval))
		return -EINVAL;

	o->it_interval.tv_sec = v32.it_interval.tv_sec;
	o->it_interval.tv_nsec = v32.it_interval.tv_usec * NSEC_PER_USEC;
	o->it_value.tv_sec = v32.it_value.tv_sec;
	o->it_value.tv_nsec = v32.it_value.tv_usec * NSEC_PER_USEC;
	return 0;
}

COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
		       struct old_itimerval32 __user *, value,
		       struct old_itimerval32 __user *, ovalue)
{
	struct itimerspec64 set_buffer, get_buffer;
	int error;

	if (value) {
		error = get_old_itimerval32(&set_buffer, value);
		if (error)
			return error;
	} else {
		memset(&set_buffer, 0, sizeof(set_buffer));
		printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer."
			    " Misfeature support will be removed\n",
			    current->comm);
	}

	error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
	if (error || !ovalue)
		return error;
	if (put_old_itimerval32(ovalue, &get_buffer))
		return -EFAULT;
	return 0;
}
#endif
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
1da177e4 LT	3	* Copyright (C) 1992 Darren Senn
	4	*/
	5
	6	/* These are all the functions necessary to implement itimers */
	7
	8	#include <linux/mm.h>
1da177e4 LT	9	#include <linux/interrupt.h>
	10	#include <linux/syscalls.h>
	11	#include <linux/time.h>
3f07c014	12	#include <linux/sched/signal.h>
32ef5517	13	#include <linux/sched/cputime.h>
1da177e4	14	#include <linux/posix-timers.h>
2ff678b8	15	#include <linux/hrtimer.h>
3f0a525e	16	#include <trace/events/timer.h>
54ad9c46	17	#include <linux/compat.h>
1da177e4	18
7c0f6ba6	19	#include <linux/uaccess.h>
1da177e4	20
2ff678b8 TG	21	/**
	22	* itimer_get_remtime - get remaining time for the timer
	23	*
	24	* @timer: the timer to read
	25	*
	26	* Returns the delta between the expiry time and now, which can be
	27	* less than zero or 1usec for an pending expired timer
	28	*/
bd40a175	29	static struct timespec64 itimer_get_remtime(struct hrtimer *timer)
1da177e4	30	{
51cbb524	31	ktime_t rem = __hrtimer_get_remaining(timer, true);
1da177e4	32
2ff678b8 TG	33	/*
	34	* Racy but safe: if the itimer expires after the above
	35	* hrtimer_get_remtime() call but before this condition
	36	* then we return 0 - which is correct.
	37	*/
	38	if (hrtimer_active(timer)) {
2456e855 TG	39	if (rem <= 0)
2456e855 TG	40	rem = NSEC_PER_USEC;
2ff678b8	41	} else
2456e855	42	rem = 0;
2ff678b8	43
bd40a175	44	return ktime_to_timespec64(rem);
1da177e4 LT	45	}
1da177e4 LT	46
42c4ab41	47	static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
bd40a175	48	struct itimerspec64 *const value)
42c4ab41	49	{
858cf3a8	50	u64 val, interval;
42c4ab41 SG	51	struct cpu_itimer *it = &tsk->signal->it[clock_id];
	52
	53	spin_lock_irq(&tsk->sighand->siglock);
	54
858cf3a8 FW	55	val = it->expires;
	56	interval = it->incr;
	57	if (val) {
b7be4ef1	58	u64 t, samples[CPUCLOCK_MAX];
42c4ab41	59
b7be4ef1 TG	60	thread_group_sample_cputime(tsk, samples);
b7be4ef1 TG	61	t = samples[clock_id];
42c4ab41	62
858cf3a8	63	if (val < t)
42c4ab41	64	/* about to fire */
858cf3a8	65	val = TICK_NSEC;
42c4ab41	66	else
858cf3a8	67	val -= t;
42c4ab41 SG	68	}
	69
	70	spin_unlock_irq(&tsk->sighand->siglock);
	71
bd40a175 AB	72	value->it_value = ns_to_timespec64(val);
bd40a175 AB	73	value->it_interval = ns_to_timespec64(interval);
42c4ab41 SG	74	}
42c4ab41 SG	75
bd40a175	76	static int do_getitimer(int which, struct itimerspec64 *value)
1da177e4 LT	77	{
1da177e4 LT	78	struct task_struct *tsk = current;
1da177e4 LT	79
	80	switch (which) {
	81	case ITIMER_REAL:
bc1978d4	82	spin_lock_irq(&tsk->sighand->siglock);
2ff678b8 TG	83	value->it_value = itimer_get_remtime(&tsk->signal->real_timer);
2ff678b8 TG	84	value->it_interval =
bd40a175	85	ktime_to_timespec64(tsk->signal->it_real_incr);
bc1978d4	86	spin_unlock_irq(&tsk->sighand->siglock);
1da177e4 LT	87	break;
1da177e4 LT	88	case ITIMER_VIRTUAL:
42c4ab41	89	get_cpu_itimer(tsk, CPUCLOCK_VIRT, value);
1da177e4 LT	90	break;
1da177e4 LT	91	case ITIMER_PROF:
42c4ab41	92	get_cpu_itimer(tsk, CPUCLOCK_PROF, value);
1da177e4 LT	93	break;
	94	default:
	95	return(-EINVAL);
	96	}
	97	return 0;
	98	}
	99
4f9fbd89	100	static int put_itimerval(struct __kernel_old_itimerval __user *o,
bd40a175 AB	101	const struct itimerspec64 *i)
bd40a175 AB	102	{
4f9fbd89	103	struct __kernel_old_itimerval v;
bd40a175 AB	104
	105	v.it_interval.tv_sec = i->it_interval.tv_sec;
	106	v.it_interval.tv_usec = i->it_interval.tv_nsec / NSEC_PER_USEC;
	107	v.it_value.tv_sec = i->it_value.tv_sec;
	108	v.it_value.tv_usec = i->it_value.tv_nsec / NSEC_PER_USEC;
4f9fbd89	109	return copy_to_user(o, &v, sizeof(struct __kernel_old_itimerval)) ? -EFAULT : 0;
bd40a175 AB	110	}
	111
	112
4f9fbd89	113	SYSCALL_DEFINE2(getitimer, int, which, struct __kernel_old_itimerval __user *, value)
1da177e4	114	{
bd40a175 AB	115	struct itimerspec64 get_buffer;
bd40a175 AB	116	int error = do_getitimer(which, &get_buffer);
1da177e4	117
bd40a175 AB	118	if (!error && put_itimerval(value, &get_buffer))
bd40a175 AB	119	error = -EFAULT;
1da177e4 LT	120	return error;
	121	}
	122
4c22ea2b	123	#if defined(CONFIG_COMPAT) \|\| defined(CONFIG_ALPHA)
c1745f84 AB	124	struct old_itimerval32 {
	125	struct old_timeval32 it_interval;
	126	struct old_timeval32 it_value;
	127	};
	128
bd40a175 AB	129	static int put_old_itimerval32(struct old_itimerval32 __user *o,
bd40a175 AB	130	const struct itimerspec64 *i)
c1745f84 AB	131	{
	132	struct old_itimerval32 v32;
	133
	134	v32.it_interval.tv_sec = i->it_interval.tv_sec;
bd40a175	135	v32.it_interval.tv_usec = i->it_interval.tv_nsec / NSEC_PER_USEC;
c1745f84	136	v32.it_value.tv_sec = i->it_value.tv_sec;
bd40a175	137	v32.it_value.tv_usec = i->it_value.tv_nsec / NSEC_PER_USEC;
c1745f84 AB	138	return copy_to_user(o, &v32, sizeof(struct old_itimerval32)) ? -EFAULT : 0;
	139	}
	140
54ad9c46	141	COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
bd40a175	142	struct old_itimerval32 __user *, value)
54ad9c46	143	{
bd40a175 AB	144	struct itimerspec64 get_buffer;
bd40a175 AB	145	int error = do_getitimer(which, &get_buffer);
54ad9c46	146
bd40a175	147	if (!error && put_old_itimerval32(value, &get_buffer))
54ad9c46 AV	148	error = -EFAULT;
	149	return error;
	150	}
	151	#endif
	152
2ff678b8 TG	153	/*
	154	* The timer is automagically restarted, when interval != 0
	155	*/
c9cb2e3d	156	enum hrtimer_restart it_real_fn(struct hrtimer *timer)
1da177e4	157	{
05cfb614	158	struct signal_struct *sig =
0719e370	159	container_of(timer, struct signal_struct, real_timer);
6883f81a	160	struct pid *leader_pid = sig->pids[PIDTYPE_TGID];
1da177e4	161
6883f81a EB	162	trace_itimer_expire(ITIMER_REAL, leader_pid, 0);
6883f81a EB	163	kill_pid_info(SIGALRM, SEND_SIG_PRIV, leader_pid);
2ff678b8	164
2ff678b8	165	return HRTIMER_NORESTART;
1da177e4 LT	166	}
1da177e4 LT	167
42c4ab41	168	static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
bd40a175 AB	169	const struct itimerspec64 *const value,
bd40a175 AB	170	struct itimerspec64 *const ovalue)
42c4ab41	171	{
858cf3a8	172	u64 oval, nval, ointerval, ninterval;
42c4ab41 SG	173	struct cpu_itimer *it = &tsk->signal->it[clock_id];
42c4ab41 SG	174
bd40a175 AB	175	nval = timespec64_to_ns(&value->it_value);
bd40a175 AB	176	ninterval = timespec64_to_ns(&value->it_interval);
42c4ab41 SG	177
	178	spin_lock_irq(&tsk->sighand->siglock);
	179
858cf3a8 FW	180	oval = it->expires;
	181	ointerval = it->incr;
	182	if (oval \|\| nval) {
64861634	183	if (nval > 0)
858cf3a8 FW	184	nval += TICK_NSEC;
858cf3a8 FW	185	set_process_cpu_timer(tsk, clock_id, &nval, &oval);
42c4ab41 SG	186	}
	187	it->expires = nval;
	188	it->incr = ninterval;
3f0a525e XG	189	trace_itimer_state(clock_id == CPUCLOCK_VIRT ?
3f0a525e XG	190	ITIMER_VIRTUAL : ITIMER_PROF, value, nval);
42c4ab41 SG	191
	192	spin_unlock_irq(&tsk->sighand->siglock);
	193
	194	if (ovalue) {
bd40a175 AB	195	ovalue->it_value = ns_to_timespec64(oval);
bd40a175 AB	196	ovalue->it_interval = ns_to_timespec64(ointerval);
42c4ab41 SG	197	}
	198	}
	199
7d99b7d6 TG	200	/*
	201	* Returns true if the timeval is in canonical form
	202	*/
	203	#define timeval_valid(t) \
	204	(((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC))
	205
bd40a175 AB	206	static int do_setitimer(int which, struct itimerspec64 *value,
bd40a175 AB	207	struct itimerspec64 *ovalue)
1da177e4 LT	208	{
1da177e4 LT	209	struct task_struct *tsk = current;
2ff678b8 TG	210	struct hrtimer *timer;
2ff678b8 TG	211	ktime_t expires;
1da177e4 LT	212
	213	switch (which) {
	214	case ITIMER_REAL:
bc1978d4 TG	215	again:
bc1978d4 TG	216	spin_lock_irq(&tsk->sighand->siglock);
2ff678b8	217	timer = &tsk->signal->real_timer;
1da177e4	218	if (ovalue) {
2ff678b8 TG	219	ovalue->it_value = itimer_get_remtime(timer);
2ff678b8 TG	220	ovalue->it_interval
bd40a175	221	= ktime_to_timespec64(tsk->signal->it_real_incr);
1da177e4	222	}
a16a1c09 TG	223	/* We are sharing ->siglock with it_real_fn() */
	224	if (hrtimer_try_to_cancel(timer) < 0) {
	225	spin_unlock_irq(&tsk->sighand->siglock);
c7e6d704	226	hrtimer_cancel_wait_running(timer);
a16a1c09 TG	227	goto again;
a16a1c09 TG	228	}
bd40a175	229	expires = timespec64_to_ktime(value->it_value);
2456e855	230	if (expires != 0) {
8bfd9a7a	231	tsk->signal->it_real_incr =
bd40a175	232	timespec64_to_ktime(value->it_interval);
c9cb2e3d	233	hrtimer_start(timer, expires, HRTIMER_MODE_REL);
8bfd9a7a	234	} else
2456e855	235	tsk->signal->it_real_incr = 0;
8bfd9a7a	236
3f0a525e	237	trace_itimer_state(ITIMER_REAL, value, 0);
bc1978d4	238	spin_unlock_irq(&tsk->sighand->siglock);
1da177e4 LT	239	break;
1da177e4 LT	240	case ITIMER_VIRTUAL:
42c4ab41	241	set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue);
1da177e4 LT	242	break;
1da177e4 LT	243	case ITIMER_PROF:
42c4ab41	244	set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue);
1da177e4 LT	245	break;
	246	default:
	247	return -EINVAL;
	248	}
	249	return 0;
	250	}
	251
ddbc7d06 AB	252	#ifdef CONFIG_SECURITY_SELINUX
	253	void clear_itimer(void)
	254	{
bd40a175	255	struct itimerspec64 v = {};
ddbc7d06 AB	256	int i;
	257
	258	for (i = 0; i < 3; i++)
	259	do_setitimer(i, &v, NULL);
	260	}
	261	#endif
	262
74ba181e NP	263	#ifdef __ARCH_WANT_SYS_ALARM
74ba181e NP	264
c08b8a49 TG	265	/**
	266	* alarm_setitimer - set alarm in seconds
	267	*
	268	* @seconds: number of seconds until alarm
	269	* 0 disables the alarm
	270	*
	271	* Returns the remaining time in seconds of a pending timer or 0 when
	272	* the timer is not active.
	273	*
	274	* On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid
	275	* negative timeval settings which would cause immediate expiry.
	276	*/
74ba181e	277	static unsigned int alarm_setitimer(unsigned int seconds)
c08b8a49	278	{
bd40a175	279	struct itimerspec64 it_new, it_old;
c08b8a49 TG	280
	281	#if BITS_PER_LONG < 64
	282	if (seconds > INT_MAX)
	283	seconds = INT_MAX;
	284	#endif
	285	it_new.it_value.tv_sec = seconds;
bd40a175 AB	286	it_new.it_value.tv_nsec = 0;
bd40a175 AB	287	it_new.it_interval.tv_sec = it_new.it_interval.tv_nsec = 0;
c08b8a49 TG	288
	289	do_setitimer(ITIMER_REAL, &it_new, &it_old);
	290
	291	/*
	292	* We can't return 0 if we have an alarm pending ... And we'd
	293	* better return too much than too little anyway
	294	*/
bd40a175	295	if ((!it_old.it_value.tv_sec && it_old.it_value.tv_nsec) \|\|
b111df84	296	it_old.it_value.tv_nsec >= (NSEC_PER_SEC / 2))
c08b8a49 TG	297	it_old.it_value.tv_sec++;
	298
	299	return it_old.it_value.tv_sec;
	300	}
	301
74ba181e NP	302	/*
	303	* For backwards compatibility? This can be done in libc so Alpha
	304	* and all newer ports shouldn't need it.
	305	*/
	306	SYSCALL_DEFINE1(alarm, unsigned int, seconds)
	307	{
	308	return alarm_setitimer(seconds);
	309	}
	310
	311	#endif
	312
4f9fbd89	313	static int get_itimerval(struct itimerspec64 o, const struct __kernel_old_itimerval __user i)
bd40a175	314	{
4f9fbd89	315	struct __kernel_old_itimerval v;
bd40a175	316
4f9fbd89	317	if (copy_from_user(&v, i, sizeof(struct __kernel_old_itimerval)))
bd40a175 AB	318	return -EFAULT;
	319
	320	/* Validate the timevals in value. */
	321	if (!timeval_valid(&v.it_value) \|\|
	322	!timeval_valid(&v.it_interval))
	323	return -EINVAL;
	324
	325	o->it_interval.tv_sec = v.it_interval.tv_sec;
	326	o->it_interval.tv_nsec = v.it_interval.tv_usec * NSEC_PER_USEC;
	327	o->it_value.tv_sec = v.it_value.tv_sec;
	328	o->it_value.tv_nsec = v.it_value.tv_usec * NSEC_PER_USEC;
	329	return 0;
	330	}
	331
4f9fbd89 AB	332	SYSCALL_DEFINE3(setitimer, int, which, struct __kernel_old_itimerval __user *, value,
4f9fbd89 AB	333	struct __kernel_old_itimerval __user *, ovalue)
1da177e4	334	{
bd40a175	335	struct itimerspec64 set_buffer, get_buffer;
1da177e4 LT	336	int error;
	337
	338	if (value) {
bd40a175 AB	339	error = get_itimerval(&set_buffer, value);
	340	if (error)
	341	return error;
aa2bf9bc	342	} else {
9886f444 TG	343	memset(&set_buffer, 0, sizeof(set_buffer));
	344	printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer."
	345	" Misfeature support will be removed\n",
	346	current->comm);
aa2bf9bc	347	}
1da177e4 LT	348
	349	error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
	350	if (error \|\| !ovalue)
	351	return error;
	352
bd40a175	353	if (put_itimerval(ovalue, &get_buffer))
0719e370	354	return -EFAULT;
1da177e4 LT	355	return 0;
1da177e4 LT	356	}
54ad9c46	357
4c22ea2b	358	#if defined(CONFIG_COMPAT) \|\| defined(CONFIG_ALPHA)
bd40a175	359	static int get_old_itimerval32(struct itimerspec64 o, const struct old_itimerval32 __user i)
c1745f84 AB	360	{
	361	struct old_itimerval32 v32;
	362
	363	if (copy_from_user(&v32, i, sizeof(struct old_itimerval32)))
	364	return -EFAULT;
bd40a175 AB	365
	366	/* Validate the timevals in value. */
	367	if (!timeval_valid(&v32.it_value) \|\|
	368	!timeval_valid(&v32.it_interval))
	369	return -EINVAL;
	370
c1745f84	371	o->it_interval.tv_sec = v32.it_interval.tv_sec;
bd40a175	372	o->it_interval.tv_nsec = v32.it_interval.tv_usec * NSEC_PER_USEC;
c1745f84	373	o->it_value.tv_sec = v32.it_value.tv_sec;
bd40a175	374	o->it_value.tv_nsec = v32.it_value.tv_usec * NSEC_PER_USEC;
c1745f84 AB	375	return 0;
	376	}
	377
54ad9c46	378	COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
bd40a175 AB	379	struct old_itimerval32 __user *, value,
bd40a175 AB	380	struct old_itimerval32 __user *, ovalue)
54ad9c46	381	{
bd40a175	382	struct itimerspec64 set_buffer, get_buffer;
54ad9c46 AV	383	int error;
54ad9c46 AV	384
bd40a175 AB	385	if (value) {
	386	error = get_old_itimerval32(&set_buffer, value);
	387	if (error)
	388	return error;
54ad9c46	389	} else {
bd40a175 AB	390	memset(&set_buffer, 0, sizeof(set_buffer));
	391	printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer."
	392	" Misfeature support will be removed\n",
	393	current->comm);
54ad9c46 AV	394	}
54ad9c46 AV	395
bd40a175 AB	396	error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
bd40a175 AB	397	if (error \|\| !ovalue)
54ad9c46	398	return error;
bd40a175	399	if (put_old_itimerval32(ovalue, &get_buffer))
54ad9c46 AV	400	return -EFAULT;
	401	return 0;
	402	}
	403	#endif