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