itimer.c

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