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