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> 10#include <linux/interrupt.h> 11#include <linux/syscalls.h> 12#include <linux/time.h> 13#include <linux/posix-timers.h> 14#include <linux/hrtimer.h> 15#include <trace/events/timer.h> 16 17#include <asm/uaccess.h> 18 19/** 20 * itimer_get_remtime - get remaining time for the timer 21 * 22 * @timer: the timer to read 23 * 24 * Returns the delta between the expiry time and now, which can be 25 * less than zero or 1usec for an pending expired timer 26 */ 27static struct timeval itimer_get_remtime(struct hrtimer *timer) 28{ 29 ktime_t rem = hrtimer_get_remaining(timer); 30 31 /* 32 * Racy but safe: if the itimer expires after the above 33 * hrtimer_get_remtime() call but before this condition 34 * then we return 0 - which is correct. 35 */ 36 if (hrtimer_active(timer)) { 37 if (rem.tv64 <= 0) 38 rem.tv64 = NSEC_PER_USEC; 39 } else 40 rem.tv64 = 0; 41 42 return ktime_to_timeval(rem); 43} 44 45static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, 46 struct itimerval *const value) 47{ 48 cputime_t cval, cinterval; 49 struct cpu_itimer *it = &tsk->signal->it[clock_id]; 50 51 spin_lock_irq(&tsk->sighand->siglock); 52 53 cval = it->expires; 54 cinterval = it->incr; 55 if (!cputime_eq(cval, cputime_zero)) { 56 struct task_cputime cputime; 57 cputime_t t; 58 59 thread_group_cputimer(tsk, &cputime); 60 if (clock_id == CPUCLOCK_PROF) 61 t = cputime_add(cputime.utime, cputime.stime); 62 else 63 /* CPUCLOCK_VIRT */ 64 t = cputime.utime; 65 66 if (cputime_le(cval, t)) 67 /* about to fire */ 68 cval = cputime_one_jiffy; 69 else 70 cval = cputime_sub(cval, t); 71 } 72 73 spin_unlock_irq(&tsk->sighand->siglock); 74 75 cputime_to_timeval(cval, &value->it_value); 76 cputime_to_timeval(cinterval, &value->it_interval); 77} 78 79int do_getitimer(int which, struct itimerval *value) 80{ 81 struct task_struct *tsk = current; 82 83 switch (which) { 84 case ITIMER_REAL: 85 spin_lock_irq(&tsk->sighand->siglock); 86 value->it_value = itimer_get_remtime(&tsk->signal->real_timer); 87 value->it_interval = 88 ktime_to_timeval(tsk->signal->it_real_incr); 89 spin_unlock_irq(&tsk->sighand->siglock); 90 break; 91 case ITIMER_VIRTUAL: 92 get_cpu_itimer(tsk, CPUCLOCK_VIRT, value); 93 break; 94 case ITIMER_PROF: 95 get_cpu_itimer(tsk, CPUCLOCK_PROF, value); 96 break; 97 default: 98 return(-EINVAL); 99 } 100 return 0; 101} 102 103SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value) 104{ 105 int error = -EFAULT; 106 struct itimerval get_buffer; 107 108 if (value) { 109 error = do_getitimer(which, &get_buffer); 110 if (!error && 111 copy_to_user(value, &get_buffer, sizeof(get_buffer))) 112 error = -EFAULT; 113 } 114 return error; 115} 116 117 118/* 119 * The timer is automagically restarted, when interval != 0 120 */ 121enum hrtimer_restart it_real_fn(struct hrtimer *timer) 122{ 123 struct signal_struct *sig = 124 container_of(timer, struct signal_struct, real_timer); 125 126 trace_itimer_expire(ITIMER_REAL, sig->leader_pid, 0); 127 kill_pid_info(SIGALRM, SEND_SIG_PRIV, sig->leader_pid); 128 129 return HRTIMER_NORESTART; 130} 131 132static inline u32 cputime_sub_ns(cputime_t ct, s64 real_ns) 133{ 134 struct timespec ts; 135 s64 cpu_ns; 136 137 cputime_to_timespec(ct, &ts); 138 cpu_ns = timespec_to_ns(&ts); 139 140 return (cpu_ns <= real_ns) ? 0 : cpu_ns - real_ns; 141} 142 143static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, 144 const struct itimerval *const value, 145 struct itimerval *const ovalue) 146{ 147 cputime_t cval, nval, cinterval, ninterval; 148 s64 ns_ninterval, ns_nval; 149 u32 error, incr_error; 150 struct cpu_itimer *it = &tsk->signal->it[clock_id]; 151 152 nval = timeval_to_cputime(&value->it_value); 153 ns_nval = timeval_to_ns(&value->it_value); 154 ninterval = timeval_to_cputime(&value->it_interval); 155 ns_ninterval = timeval_to_ns(&value->it_interval); 156 157 error = cputime_sub_ns(nval, ns_nval); 158 incr_error = cputime_sub_ns(ninterval, ns_ninterval); 159 160 spin_lock_irq(&tsk->sighand->siglock); 161 162 cval = it->expires; 163 cinterval = it->incr; 164 if (!cputime_eq(cval, cputime_zero) || 165 !cputime_eq(nval, cputime_zero)) { 166 if (cputime_gt(nval, cputime_zero)) 167 nval = cputime_add(nval, cputime_one_jiffy); 168 set_process_cpu_timer(tsk, clock_id, &nval, &cval); 169 } 170 it->expires = nval; 171 it->incr = ninterval; 172 it->error = error; 173 it->incr_error = incr_error; 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 cputime_to_timeval(cval, &ovalue->it_value); 181 cputime_to_timeval(cinterval, &ovalue->it_interval); 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 191int 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: 206again: 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.tv64 != 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.tv64 = 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/** 243 * alarm_setitimer - set alarm in seconds 244 * 245 * @seconds: number of seconds until alarm 246 * 0 disables the alarm 247 * 248 * Returns the remaining time in seconds of a pending timer or 0 when 249 * the timer is not active. 250 * 251 * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid 252 * negative timeval settings which would cause immediate expiry. 253 */ 254unsigned int alarm_setitimer(unsigned int seconds) 255{ 256 struct itimerval it_new, it_old; 257 258#if BITS_PER_LONG < 64 259 if (seconds > INT_MAX) 260 seconds = INT_MAX; 261#endif 262 it_new.it_value.tv_sec = seconds; 263 it_new.it_value.tv_usec = 0; 264 it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0; 265 266 do_setitimer(ITIMER_REAL, &it_new, &it_old); 267 268 /* 269 * We can't return 0 if we have an alarm pending ... And we'd 270 * better return too much than too little anyway 271 */ 272 if ((!it_old.it_value.tv_sec && it_old.it_value.tv_usec) || 273 it_old.it_value.tv_usec >= 500000) 274 it_old.it_value.tv_sec++; 275 276 return it_old.it_value.tv_sec; 277} 278 279SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value, 280 struct itimerval __user *, ovalue) 281{ 282 struct itimerval set_buffer, get_buffer; 283 int error; 284 285 if (value) { 286 if(copy_from_user(&set_buffer, value, sizeof(set_buffer))) 287 return -EFAULT; 288 } else 289 memset((char *) &set_buffer, 0, sizeof(set_buffer)); 290 291 error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL); 292 if (error || !ovalue) 293 return error; 294 295 if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer))) 296 return -EFAULT; 297 return 0; 298} 299