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