1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 1992 Darren Senn
6 /* These are all the functions necessary to implement itimers */
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>
19 #include <linux/uaccess.h>
22 * itimer_get_remtime - get remaining time for the timer
24 * @timer: the timer to read
26 * Returns the delta between the expiry time and now, which can be
27 * less than zero or 1usec for an pending expired timer
29 static struct timespec64 itimer_get_remtime(struct hrtimer *timer)
31 ktime_t rem = __hrtimer_get_remaining(timer, true);
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.
38 if (hrtimer_active(timer)) {
44 return ktime_to_timespec64(rem);
47 static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
48 struct itimerspec64 *const value)
51 struct cpu_itimer *it = &tsk->signal->it[clock_id];
53 spin_lock_irq(&tsk->sighand->siglock);
58 u64 t, samples[CPUCLOCK_MAX];
60 thread_group_sample_cputime(tsk, samples);
61 t = samples[clock_id];
70 spin_unlock_irq(&tsk->sighand->siglock);
72 value->it_value = ns_to_timespec64(val);
73 value->it_interval = ns_to_timespec64(interval);
76 static int do_getitimer(int which, struct itimerspec64 *value)
78 struct task_struct *tsk = current;
82 spin_lock_irq(&tsk->sighand->siglock);
83 value->it_value = itimer_get_remtime(&tsk->signal->real_timer);
85 ktime_to_timespec64(tsk->signal->it_real_incr);
86 spin_unlock_irq(&tsk->sighand->siglock);
89 get_cpu_itimer(tsk, CPUCLOCK_VIRT, value);
92 get_cpu_itimer(tsk, CPUCLOCK_PROF, value);
100 static int put_itimerval(struct __kernel_old_itimerval __user *o,
101 const struct itimerspec64 *i)
103 struct __kernel_old_itimerval v;
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;
113 SYSCALL_DEFINE2(getitimer, int, which, struct __kernel_old_itimerval __user *, value)
115 struct itimerspec64 get_buffer;
116 int error = do_getitimer(which, &get_buffer);
118 if (!error && put_itimerval(value, &get_buffer))
123 #if defined(CONFIG_COMPAT) || defined(CONFIG_ALPHA)
124 struct old_itimerval32 {
125 struct old_timeval32 it_interval;
126 struct old_timeval32 it_value;
129 static int put_old_itimerval32(struct old_itimerval32 __user *o,
130 const struct itimerspec64 *i)
132 struct old_itimerval32 v32;
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;
141 COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
142 struct old_itimerval32 __user *, value)
144 struct itimerspec64 get_buffer;
145 int error = do_getitimer(which, &get_buffer);
147 if (!error && put_old_itimerval32(value, &get_buffer))
154 * The timer is automagically restarted, when interval != 0
156 enum hrtimer_restart it_real_fn(struct hrtimer *timer)
158 struct signal_struct *sig =
159 container_of(timer, struct signal_struct, real_timer);
160 struct pid *leader_pid = sig->pids[PIDTYPE_TGID];
162 trace_itimer_expire(ITIMER_REAL, leader_pid, 0);
163 kill_pid_info(SIGALRM, SEND_SIG_PRIV, leader_pid);
165 return HRTIMER_NORESTART;
168 static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
169 const struct itimerspec64 *const value,
170 struct itimerspec64 *const ovalue)
172 u64 oval, nval, ointerval, ninterval;
173 struct cpu_itimer *it = &tsk->signal->it[clock_id];
176 * Use the to_ktime conversion because that clamps the maximum
177 * value to KTIME_MAX and avoid multiplication overflows.
179 nval = timespec64_to_ns(&value->it_value);
180 ninterval = timespec64_to_ns(&value->it_interval);
182 spin_lock_irq(&tsk->sighand->siglock);
185 ointerval = it->incr;
189 set_process_cpu_timer(tsk, clock_id, &nval, &oval);
192 it->incr = ninterval;
193 trace_itimer_state(clock_id == CPUCLOCK_VIRT ?
194 ITIMER_VIRTUAL : ITIMER_PROF, value, nval);
196 spin_unlock_irq(&tsk->sighand->siglock);
199 ovalue->it_value = ns_to_timespec64(oval);
200 ovalue->it_interval = ns_to_timespec64(ointerval);
205 * Returns true if the timeval is in canonical form
207 #define timeval_valid(t) \
208 (((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC))
210 static int do_setitimer(int which, struct itimerspec64 *value,
211 struct itimerspec64 *ovalue)
213 struct task_struct *tsk = current;
214 struct hrtimer *timer;
220 spin_lock_irq(&tsk->sighand->siglock);
221 timer = &tsk->signal->real_timer;
223 ovalue->it_value = itimer_get_remtime(timer);
225 = ktime_to_timespec64(tsk->signal->it_real_incr);
227 /* We are sharing ->siglock with it_real_fn() */
228 if (hrtimer_try_to_cancel(timer) < 0) {
229 spin_unlock_irq(&tsk->sighand->siglock);
230 hrtimer_cancel_wait_running(timer);
233 expires = timespec64_to_ktime(value->it_value);
235 tsk->signal->it_real_incr =
236 timespec64_to_ktime(value->it_interval);
237 hrtimer_start(timer, expires, HRTIMER_MODE_REL);
239 tsk->signal->it_real_incr = 0;
241 trace_itimer_state(ITIMER_REAL, value, 0);
242 spin_unlock_irq(&tsk->sighand->siglock);
245 set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue);
248 set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue);
256 #ifdef CONFIG_SECURITY_SELINUX
257 void clear_itimer(void)
259 struct itimerspec64 v = {};
262 for (i = 0; i < 3; i++)
263 do_setitimer(i, &v, NULL);
267 #ifdef __ARCH_WANT_SYS_ALARM
270 * alarm_setitimer - set alarm in seconds
272 * @seconds: number of seconds until alarm
273 * 0 disables the alarm
275 * Returns the remaining time in seconds of a pending timer or 0 when
276 * the timer is not active.
278 * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid
279 * negative timeval settings which would cause immediate expiry.
281 static unsigned int alarm_setitimer(unsigned int seconds)
283 struct itimerspec64 it_new, it_old;
285 #if BITS_PER_LONG < 64
286 if (seconds > INT_MAX)
289 it_new.it_value.tv_sec = seconds;
290 it_new.it_value.tv_nsec = 0;
291 it_new.it_interval.tv_sec = it_new.it_interval.tv_nsec = 0;
293 do_setitimer(ITIMER_REAL, &it_new, &it_old);
296 * We can't return 0 if we have an alarm pending ... And we'd
297 * better return too much than too little anyway
299 if ((!it_old.it_value.tv_sec && it_old.it_value.tv_nsec) ||
300 it_old.it_value.tv_nsec >= (NSEC_PER_SEC / 2))
301 it_old.it_value.tv_sec++;
303 return it_old.it_value.tv_sec;
307 * For backwards compatibility? This can be done in libc so Alpha
308 * and all newer ports shouldn't need it.
310 SYSCALL_DEFINE1(alarm, unsigned int, seconds)
312 return alarm_setitimer(seconds);
317 static int get_itimerval(struct itimerspec64 *o, const struct __kernel_old_itimerval __user *i)
319 struct __kernel_old_itimerval v;
321 if (copy_from_user(&v, i, sizeof(struct __kernel_old_itimerval)))
324 /* Validate the timevals in value. */
325 if (!timeval_valid(&v.it_value) ||
326 !timeval_valid(&v.it_interval))
329 o->it_interval.tv_sec = v.it_interval.tv_sec;
330 o->it_interval.tv_nsec = v.it_interval.tv_usec * NSEC_PER_USEC;
331 o->it_value.tv_sec = v.it_value.tv_sec;
332 o->it_value.tv_nsec = v.it_value.tv_usec * NSEC_PER_USEC;
336 SYSCALL_DEFINE3(setitimer, int, which, struct __kernel_old_itimerval __user *, value,
337 struct __kernel_old_itimerval __user *, ovalue)
339 struct itimerspec64 set_buffer, get_buffer;
343 error = get_itimerval(&set_buffer, value);
347 memset(&set_buffer, 0, sizeof(set_buffer));
348 printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer."
349 " Misfeature support will be removed\n",
353 error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
354 if (error || !ovalue)
357 if (put_itimerval(ovalue, &get_buffer))
362 #if defined(CONFIG_COMPAT) || defined(CONFIG_ALPHA)
363 static int get_old_itimerval32(struct itimerspec64 *o, const struct old_itimerval32 __user *i)
365 struct old_itimerval32 v32;
367 if (copy_from_user(&v32, i, sizeof(struct old_itimerval32)))
370 /* Validate the timevals in value. */
371 if (!timeval_valid(&v32.it_value) ||
372 !timeval_valid(&v32.it_interval))
375 o->it_interval.tv_sec = v32.it_interval.tv_sec;
376 o->it_interval.tv_nsec = v32.it_interval.tv_usec * NSEC_PER_USEC;
377 o->it_value.tv_sec = v32.it_value.tv_sec;
378 o->it_value.tv_nsec = v32.it_value.tv_usec * NSEC_PER_USEC;
382 COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
383 struct old_itimerval32 __user *, value,
384 struct old_itimerval32 __user *, ovalue)
386 struct itimerspec64 set_buffer, get_buffer;
390 error = get_old_itimerval32(&set_buffer, value);
394 memset(&set_buffer, 0, sizeof(set_buffer));
395 printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer."
396 " Misfeature support will be removed\n",
400 error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
401 if (error || !ovalue)
403 if (put_old_itimerval32(ovalue, &get_buffer))