Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/kernel/itimer.c | |
3 | * | |
4 | * Copyright (C) 1992 Darren Senn | |
5 | */ | |
6 | ||
7 | /* These are all the functions necessary to implement itimers */ | |
8 | ||
9 | #include <linux/mm.h> | |
1da177e4 LT |
10 | #include <linux/interrupt.h> |
11 | #include <linux/syscalls.h> | |
12 | #include <linux/time.h> | |
13 | #include <linux/posix-timers.h> | |
2ff678b8 | 14 | #include <linux/hrtimer.h> |
1da177e4 LT |
15 | |
16 | #include <asm/uaccess.h> | |
17 | ||
2ff678b8 TG |
18 | /** |
19 | * itimer_get_remtime - get remaining time for the timer | |
20 | * | |
21 | * @timer: the timer to read | |
22 | * | |
23 | * Returns the delta between the expiry time and now, which can be | |
24 | * less than zero or 1usec for an pending expired timer | |
25 | */ | |
26 | static struct timeval itimer_get_remtime(struct hrtimer *timer) | |
1da177e4 | 27 | { |
2ff678b8 | 28 | ktime_t rem = hrtimer_get_remaining(timer); |
1da177e4 | 29 | |
2ff678b8 TG |
30 | /* |
31 | * Racy but safe: if the itimer expires after the above | |
32 | * hrtimer_get_remtime() call but before this condition | |
33 | * then we return 0 - which is correct. | |
34 | */ | |
35 | if (hrtimer_active(timer)) { | |
36 | if (rem.tv64 <= 0) | |
37 | rem.tv64 = NSEC_PER_USEC; | |
38 | } else | |
39 | rem.tv64 = 0; | |
40 | ||
41 | return ktime_to_timeval(rem); | |
1da177e4 LT |
42 | } |
43 | ||
42c4ab41 | 44 | static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, |
8356b5f9 | 45 | struct itimerval *const value) |
42c4ab41 SG |
46 | { |
47 | cputime_t cval, cinterval; | |
48 | struct cpu_itimer *it = &tsk->signal->it[clock_id]; | |
49 | ||
50 | spin_lock_irq(&tsk->sighand->siglock); | |
51 | ||
52 | cval = it->expires; | |
53 | cinterval = it->incr; | |
54 | if (!cputime_eq(cval, cputime_zero)) { | |
55 | struct task_cputime cputime; | |
56 | cputime_t t; | |
57 | ||
58 | thread_group_cputimer(tsk, &cputime); | |
59 | if (clock_id == CPUCLOCK_PROF) | |
60 | t = cputime_add(cputime.utime, cputime.stime); | |
61 | else | |
62 | /* CPUCLOCK_VIRT */ | |
63 | t = cputime.utime; | |
64 | ||
65 | if (cputime_le(cval, t)) | |
66 | /* about to fire */ | |
a42548a1 | 67 | cval = cputime_one_jiffy; |
42c4ab41 SG |
68 | else |
69 | cval = cputime_sub(cval, t); | |
70 | } | |
71 | ||
72 | spin_unlock_irq(&tsk->sighand->siglock); | |
73 | ||
74 | cputime_to_timeval(cval, &value->it_value); | |
75 | cputime_to_timeval(cinterval, &value->it_interval); | |
76 | } | |
77 | ||
1da177e4 LT |
78 | int do_getitimer(int which, struct itimerval *value) |
79 | { | |
80 | struct task_struct *tsk = current; | |
1da177e4 LT |
81 | |
82 | switch (which) { | |
83 | case ITIMER_REAL: | |
bc1978d4 | 84 | spin_lock_irq(&tsk->sighand->siglock); |
2ff678b8 TG |
85 | value->it_value = itimer_get_remtime(&tsk->signal->real_timer); |
86 | value->it_interval = | |
87 | ktime_to_timeval(tsk->signal->it_real_incr); | |
bc1978d4 | 88 | spin_unlock_irq(&tsk->sighand->siglock); |
1da177e4 LT |
89 | break; |
90 | case ITIMER_VIRTUAL: | |
42c4ab41 | 91 | get_cpu_itimer(tsk, CPUCLOCK_VIRT, value); |
1da177e4 LT |
92 | break; |
93 | case ITIMER_PROF: | |
42c4ab41 | 94 | get_cpu_itimer(tsk, CPUCLOCK_PROF, value); |
1da177e4 LT |
95 | break; |
96 | default: | |
97 | return(-EINVAL); | |
98 | } | |
99 | return 0; | |
100 | } | |
101 | ||
b290ebe2 | 102 | SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value) |
1da177e4 LT |
103 | { |
104 | int error = -EFAULT; | |
105 | struct itimerval get_buffer; | |
106 | ||
107 | if (value) { | |
108 | error = do_getitimer(which, &get_buffer); | |
109 | if (!error && | |
110 | copy_to_user(value, &get_buffer, sizeof(get_buffer))) | |
111 | error = -EFAULT; | |
112 | } | |
113 | return error; | |
114 | } | |
115 | ||
1da177e4 | 116 | |
2ff678b8 TG |
117 | /* |
118 | * The timer is automagically restarted, when interval != 0 | |
119 | */ | |
c9cb2e3d | 120 | enum hrtimer_restart it_real_fn(struct hrtimer *timer) |
1da177e4 | 121 | { |
05cfb614 | 122 | struct signal_struct *sig = |
0719e370 | 123 | container_of(timer, struct signal_struct, real_timer); |
1da177e4 | 124 | |
fea9d175 | 125 | kill_pid_info(SIGALRM, SEND_SIG_PRIV, sig->leader_pid); |
2ff678b8 | 126 | |
2ff678b8 | 127 | return HRTIMER_NORESTART; |
1da177e4 LT |
128 | } |
129 | ||
8356b5f9 SG |
130 | static inline u32 cputime_sub_ns(cputime_t ct, s64 real_ns) |
131 | { | |
132 | struct timespec ts; | |
133 | s64 cpu_ns; | |
134 | ||
135 | cputime_to_timespec(ct, &ts); | |
136 | cpu_ns = timespec_to_ns(&ts); | |
137 | ||
138 | return (cpu_ns <= real_ns) ? 0 : cpu_ns - real_ns; | |
139 | } | |
140 | ||
42c4ab41 | 141 | static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, |
8356b5f9 SG |
142 | const struct itimerval *const value, |
143 | struct itimerval *const ovalue) | |
42c4ab41 | 144 | { |
8356b5f9 SG |
145 | cputime_t cval, nval, cinterval, ninterval; |
146 | s64 ns_ninterval, ns_nval; | |
42c4ab41 SG |
147 | struct cpu_itimer *it = &tsk->signal->it[clock_id]; |
148 | ||
149 | nval = timeval_to_cputime(&value->it_value); | |
8356b5f9 | 150 | ns_nval = timeval_to_ns(&value->it_value); |
42c4ab41 | 151 | ninterval = timeval_to_cputime(&value->it_interval); |
8356b5f9 SG |
152 | ns_ninterval = timeval_to_ns(&value->it_interval); |
153 | ||
154 | it->incr_error = cputime_sub_ns(ninterval, ns_ninterval); | |
155 | it->error = cputime_sub_ns(nval, ns_nval); | |
42c4ab41 SG |
156 | |
157 | spin_lock_irq(&tsk->sighand->siglock); | |
158 | ||
159 | cval = it->expires; | |
160 | cinterval = it->incr; | |
161 | if (!cputime_eq(cval, cputime_zero) || | |
162 | !cputime_eq(nval, cputime_zero)) { | |
163 | if (cputime_gt(nval, cputime_zero)) | |
a42548a1 | 164 | nval = cputime_add(nval, cputime_one_jiffy); |
42c4ab41 SG |
165 | set_process_cpu_timer(tsk, clock_id, &nval, &cval); |
166 | } | |
167 | it->expires = nval; | |
168 | it->incr = ninterval; | |
169 | ||
170 | spin_unlock_irq(&tsk->sighand->siglock); | |
171 | ||
172 | if (ovalue) { | |
173 | cputime_to_timeval(cval, &ovalue->it_value); | |
174 | cputime_to_timeval(cinterval, &ovalue->it_interval); | |
175 | } | |
176 | } | |
177 | ||
7d99b7d6 TG |
178 | /* |
179 | * Returns true if the timeval is in canonical form | |
180 | */ | |
181 | #define timeval_valid(t) \ | |
182 | (((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC)) | |
183 | ||
1da177e4 LT |
184 | int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue) |
185 | { | |
186 | struct task_struct *tsk = current; | |
2ff678b8 TG |
187 | struct hrtimer *timer; |
188 | ktime_t expires; | |
1da177e4 | 189 | |
7d99b7d6 TG |
190 | /* |
191 | * Validate the timevals in value. | |
7d99b7d6 | 192 | */ |
35bab756 AB |
193 | if (!timeval_valid(&value->it_value) || |
194 | !timeval_valid(&value->it_interval)) | |
195 | return -EINVAL; | |
7d99b7d6 | 196 | |
1da177e4 LT |
197 | switch (which) { |
198 | case ITIMER_REAL: | |
bc1978d4 TG |
199 | again: |
200 | spin_lock_irq(&tsk->sighand->siglock); | |
2ff678b8 | 201 | timer = &tsk->signal->real_timer; |
1da177e4 | 202 | if (ovalue) { |
2ff678b8 TG |
203 | ovalue->it_value = itimer_get_remtime(timer); |
204 | ovalue->it_interval | |
205 | = ktime_to_timeval(tsk->signal->it_real_incr); | |
1da177e4 | 206 | } |
a16a1c09 TG |
207 | /* We are sharing ->siglock with it_real_fn() */ |
208 | if (hrtimer_try_to_cancel(timer) < 0) { | |
209 | spin_unlock_irq(&tsk->sighand->siglock); | |
210 | goto again; | |
211 | } | |
2ff678b8 | 212 | expires = timeval_to_ktime(value->it_value); |
8bfd9a7a TG |
213 | if (expires.tv64 != 0) { |
214 | tsk->signal->it_real_incr = | |
215 | timeval_to_ktime(value->it_interval); | |
c9cb2e3d | 216 | hrtimer_start(timer, expires, HRTIMER_MODE_REL); |
8bfd9a7a TG |
217 | } else |
218 | tsk->signal->it_real_incr.tv64 = 0; | |
219 | ||
bc1978d4 | 220 | spin_unlock_irq(&tsk->sighand->siglock); |
1da177e4 LT |
221 | break; |
222 | case ITIMER_VIRTUAL: | |
42c4ab41 | 223 | set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue); |
1da177e4 LT |
224 | break; |
225 | case ITIMER_PROF: | |
42c4ab41 | 226 | set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue); |
1da177e4 LT |
227 | break; |
228 | default: | |
229 | return -EINVAL; | |
230 | } | |
231 | return 0; | |
232 | } | |
233 | ||
c08b8a49 TG |
234 | /** |
235 | * alarm_setitimer - set alarm in seconds | |
236 | * | |
237 | * @seconds: number of seconds until alarm | |
238 | * 0 disables the alarm | |
239 | * | |
240 | * Returns the remaining time in seconds of a pending timer or 0 when | |
241 | * the timer is not active. | |
242 | * | |
243 | * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid | |
244 | * negative timeval settings which would cause immediate expiry. | |
245 | */ | |
246 | unsigned int alarm_setitimer(unsigned int seconds) | |
247 | { | |
248 | struct itimerval it_new, it_old; | |
249 | ||
250 | #if BITS_PER_LONG < 64 | |
251 | if (seconds > INT_MAX) | |
252 | seconds = INT_MAX; | |
253 | #endif | |
254 | it_new.it_value.tv_sec = seconds; | |
255 | it_new.it_value.tv_usec = 0; | |
256 | it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0; | |
257 | ||
258 | do_setitimer(ITIMER_REAL, &it_new, &it_old); | |
259 | ||
260 | /* | |
261 | * We can't return 0 if we have an alarm pending ... And we'd | |
262 | * better return too much than too little anyway | |
263 | */ | |
264 | if ((!it_old.it_value.tv_sec && it_old.it_value.tv_usec) || | |
265 | it_old.it_value.tv_usec >= 500000) | |
266 | it_old.it_value.tv_sec++; | |
267 | ||
268 | return it_old.it_value.tv_sec; | |
269 | } | |
270 | ||
362e9c07 HC |
271 | SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value, |
272 | struct itimerval __user *, ovalue) | |
1da177e4 LT |
273 | { |
274 | struct itimerval set_buffer, get_buffer; | |
275 | int error; | |
276 | ||
277 | if (value) { | |
278 | if(copy_from_user(&set_buffer, value, sizeof(set_buffer))) | |
279 | return -EFAULT; | |
280 | } else | |
281 | memset((char *) &set_buffer, 0, sizeof(set_buffer)); | |
282 | ||
283 | error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL); | |
284 | if (error || !ovalue) | |
285 | return error; | |
286 | ||
287 | if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer))) | |
0719e370 | 288 | return -EFAULT; |
1da177e4 LT |
289 | return 0; |
290 | } |