Merge tag 'nds32-for-linus-4.18' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.git] / kernel / time / itimer.c
1 // SPDX-License-Identifier: GPL-2.0
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>
11 #include <linux/interrupt.h>
12 #include <linux/syscalls.h>
13 #include <linux/time.h>
14 #include <linux/sched/signal.h>
15 #include <linux/sched/cputime.h>
16 #include <linux/posix-timers.h>
17 #include <linux/hrtimer.h>
18 #include <trace/events/timer.h>
19 #include <linux/compat.h>
20
21 #include <linux/uaccess.h>
22
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)
32 {
33         ktime_t rem = __hrtimer_get_remaining(timer, true);
34
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)) {
41                 if (rem <= 0)
42                         rem = NSEC_PER_USEC;
43         } else
44                 rem = 0;
45
46         return ktime_to_timeval(rem);
47 }
48
49 static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
50                            struct itimerval *const value)
51 {
52         u64 val, interval;
53         struct cpu_itimer *it = &tsk->signal->it[clock_id];
54
55         spin_lock_irq(&tsk->sighand->siglock);
56
57         val = it->expires;
58         interval = it->incr;
59         if (val) {
60                 struct task_cputime cputime;
61                 u64 t;
62
63                 thread_group_cputimer(tsk, &cputime);
64                 if (clock_id == CPUCLOCK_PROF)
65                         t = cputime.utime + cputime.stime;
66                 else
67                         /* CPUCLOCK_VIRT */
68                         t = cputime.utime;
69
70                 if (val < t)
71                         /* about to fire */
72                         val = TICK_NSEC;
73                 else
74                         val -= t;
75         }
76
77         spin_unlock_irq(&tsk->sighand->siglock);
78
79         value->it_value = ns_to_timeval(val);
80         value->it_interval = ns_to_timeval(interval);
81 }
82
83 int do_getitimer(int which, struct itimerval *value)
84 {
85         struct task_struct *tsk = current;
86
87         switch (which) {
88         case ITIMER_REAL:
89                 spin_lock_irq(&tsk->sighand->siglock);
90                 value->it_value = itimer_get_remtime(&tsk->signal->real_timer);
91                 value->it_interval =
92                         ktime_to_timeval(tsk->signal->it_real_incr);
93                 spin_unlock_irq(&tsk->sighand->siglock);
94                 break;
95         case ITIMER_VIRTUAL:
96                 get_cpu_itimer(tsk, CPUCLOCK_VIRT, value);
97                 break;
98         case ITIMER_PROF:
99                 get_cpu_itimer(tsk, CPUCLOCK_PROF, value);
100                 break;
101         default:
102                 return(-EINVAL);
103         }
104         return 0;
105 }
106
107 SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value)
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
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
134
135 /*
136  * The timer is automagically restarted, when interval != 0
137  */
138 enum hrtimer_restart it_real_fn(struct hrtimer *timer)
139 {
140         struct signal_struct *sig =
141                 container_of(timer, struct signal_struct, real_timer);
142
143         trace_itimer_expire(ITIMER_REAL, sig->leader_pid, 0);
144         kill_pid_info(SIGALRM, SEND_SIG_PRIV, sig->leader_pid);
145
146         return HRTIMER_NORESTART;
147 }
148
149 static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
150                            const struct itimerval *const value,
151                            struct itimerval *const ovalue)
152 {
153         u64 oval, nval, ointerval, ninterval;
154         struct cpu_itimer *it = &tsk->signal->it[clock_id];
155
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));
162
163         spin_lock_irq(&tsk->sighand->siglock);
164
165         oval = it->expires;
166         ointerval = it->incr;
167         if (oval || nval) {
168                 if (nval > 0)
169                         nval += TICK_NSEC;
170                 set_process_cpu_timer(tsk, clock_id, &nval, &oval);
171         }
172         it->expires = nval;
173         it->incr = ninterval;
174         trace_itimer_state(clock_id == CPUCLOCK_VIRT ?
175                            ITIMER_VIRTUAL : ITIMER_PROF, value, nval);
176
177         spin_unlock_irq(&tsk->sighand->siglock);
178
179         if (ovalue) {
180                 ovalue->it_value = ns_to_timeval(oval);
181                 ovalue->it_interval = ns_to_timeval(ointerval);
182         }
183 }
184
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
191 int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
192 {
193         struct task_struct *tsk = current;
194         struct hrtimer *timer;
195         ktime_t expires;
196
197         /*
198          * Validate the timevals in value.
199          */
200         if (!timeval_valid(&value->it_value) ||
201             !timeval_valid(&value->it_interval))
202                 return -EINVAL;
203
204         switch (which) {
205         case ITIMER_REAL:
206 again:
207                 spin_lock_irq(&tsk->sighand->siglock);
208                 timer = &tsk->signal->real_timer;
209                 if (ovalue) {
210                         ovalue->it_value = itimer_get_remtime(timer);
211                         ovalue->it_interval
212                                 = ktime_to_timeval(tsk->signal->it_real_incr);
213                 }
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                 }
219                 expires = timeval_to_ktime(value->it_value);
220                 if (expires != 0) {
221                         tsk->signal->it_real_incr =
222                                 timeval_to_ktime(value->it_interval);
223                         hrtimer_start(timer, expires, HRTIMER_MODE_REL);
224                 } else
225                         tsk->signal->it_real_incr = 0;
226
227                 trace_itimer_state(ITIMER_REAL, value, 0);
228                 spin_unlock_irq(&tsk->sighand->siglock);
229                 break;
230         case ITIMER_VIRTUAL:
231                 set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue);
232                 break;
233         case ITIMER_PROF:
234                 set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue);
235                 break;
236         default:
237                 return -EINVAL;
238         }
239         return 0;
240 }
241
242 #ifdef __ARCH_WANT_SYS_ALARM
243
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  */
256 static unsigned int alarm_setitimer(unsigned int seconds)
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
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
292 SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value,
293                 struct itimerval __user *, ovalue)
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;
301         } else {
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);
306         }
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)))
313                 return -EFAULT;
314         return 0;
315 }
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