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 <linux/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 */ 27 static struct timeval itimer_get_remtime(struct hrtimer *timer) 28 { 29 ktime_t rem = __hrtimer_get_remaining(timer, true); 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 <= 0) 38 rem = NSEC_PER_USEC; 39 } else 40 rem = 0; 41 42 return ktime_to_timeval(rem); 43 } 44 45 static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, 46 struct itimerval *const value) 47 { 48 u64 val, interval; 49 struct cpu_itimer *it = &tsk->signal->it[clock_id]; 50 51 spin_lock_irq(&tsk->sighand->siglock); 52 53 val = it->expires; 54 interval = it->incr; 55 if (val) { 56 struct task_cputime cputime; 57 u64 t; 58 59 thread_group_cputimer(tsk, &cputime); 60 if (clock_id == CPUCLOCK_PROF) 61 t = cputime.utime + cputime.stime; 62 else 63 /* CPUCLOCK_VIRT */ 64 t = cputime.utime; 65 66 if (val < t) 67 /* about to fire */ 68 val = TICK_NSEC; 69 else 70 val -= t; 71 } 72 73 spin_unlock_irq(&tsk->sighand->siglock); 74 75 value->it_value = ns_to_timeval(val); 76 value->it_interval = ns_to_timeval(interval); 77 } 78 79 int 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 103 SYSCALL_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 */ 121 enum 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 132 static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, 133 const struct itimerval *const value, 134 struct itimerval *const ovalue) 135 { 136 u64 oval, nval, ointerval, ninterval; 137 struct cpu_itimer *it = &tsk->signal->it[clock_id]; 138 139 nval = timeval_to_ns(&value->it_value); 140 ninterval = timeval_to_ns(&value->it_interval); 141 142 spin_lock_irq(&tsk->sighand->siglock); 143 144 oval = it->expires; 145 ointerval = it->incr; 146 if (oval || nval) { 147 if (nval > 0) 148 nval += TICK_NSEC; 149 set_process_cpu_timer(tsk, clock_id, &nval, &oval); 150 } 151 it->expires = nval; 152 it->incr = ninterval; 153 trace_itimer_state(clock_id == CPUCLOCK_VIRT ? 154 ITIMER_VIRTUAL : ITIMER_PROF, value, nval); 155 156 spin_unlock_irq(&tsk->sighand->siglock); 157 158 if (ovalue) { 159 ovalue->it_value = ns_to_timeval(oval); 160 ovalue->it_interval = ns_to_timeval(ointerval); 161 } 162 } 163 164 /* 165 * Returns true if the timeval is in canonical form 166 */ 167 #define timeval_valid(t) \ 168 (((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC)) 169 170 int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue) 171 { 172 struct task_struct *tsk = current; 173 struct hrtimer *timer; 174 ktime_t expires; 175 176 /* 177 * Validate the timevals in value. 178 */ 179 if (!timeval_valid(&value->it_value) || 180 !timeval_valid(&value->it_interval)) 181 return -EINVAL; 182 183 switch (which) { 184 case ITIMER_REAL: 185 again: 186 spin_lock_irq(&tsk->sighand->siglock); 187 timer = &tsk->signal->real_timer; 188 if (ovalue) { 189 ovalue->it_value = itimer_get_remtime(timer); 190 ovalue->it_interval 191 = ktime_to_timeval(tsk->signal->it_real_incr); 192 } 193 /* We are sharing ->siglock with it_real_fn() */ 194 if (hrtimer_try_to_cancel(timer) < 0) { 195 spin_unlock_irq(&tsk->sighand->siglock); 196 goto again; 197 } 198 expires = timeval_to_ktime(value->it_value); 199 if (expires != 0) { 200 tsk->signal->it_real_incr = 201 timeval_to_ktime(value->it_interval); 202 hrtimer_start(timer, expires, HRTIMER_MODE_REL); 203 } else 204 tsk->signal->it_real_incr = 0; 205 206 trace_itimer_state(ITIMER_REAL, value, 0); 207 spin_unlock_irq(&tsk->sighand->siglock); 208 break; 209 case ITIMER_VIRTUAL: 210 set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue); 211 break; 212 case ITIMER_PROF: 213 set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue); 214 break; 215 default: 216 return -EINVAL; 217 } 218 return 0; 219 } 220 221 #ifdef __ARCH_WANT_SYS_ALARM 222 223 /** 224 * alarm_setitimer - set alarm in seconds 225 * 226 * @seconds: number of seconds until alarm 227 * 0 disables the alarm 228 * 229 * Returns the remaining time in seconds of a pending timer or 0 when 230 * the timer is not active. 231 * 232 * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid 233 * negative timeval settings which would cause immediate expiry. 234 */ 235 static unsigned int alarm_setitimer(unsigned int seconds) 236 { 237 struct itimerval it_new, it_old; 238 239 #if BITS_PER_LONG < 64 240 if (seconds > INT_MAX) 241 seconds = INT_MAX; 242 #endif 243 it_new.it_value.tv_sec = seconds; 244 it_new.it_value.tv_usec = 0; 245 it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0; 246 247 do_setitimer(ITIMER_REAL, &it_new, &it_old); 248 249 /* 250 * We can't return 0 if we have an alarm pending ... And we'd 251 * better return too much than too little anyway 252 */ 253 if ((!it_old.it_value.tv_sec && it_old.it_value.tv_usec) || 254 it_old.it_value.tv_usec >= 500000) 255 it_old.it_value.tv_sec++; 256 257 return it_old.it_value.tv_sec; 258 } 259 260 /* 261 * For backwards compatibility? This can be done in libc so Alpha 262 * and all newer ports shouldn't need it. 263 */ 264 SYSCALL_DEFINE1(alarm, unsigned int, seconds) 265 { 266 return alarm_setitimer(seconds); 267 } 268 269 #endif 270 271 SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value, 272 struct itimerval __user *, ovalue) 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(&set_buffer, 0, sizeof(set_buffer)); 282 printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer." 283 " Misfeature support will be removed\n", 284 current->comm); 285 } 286 287 error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL); 288 if (error || !ovalue) 289 return error; 290 291 if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer))) 292 return -EFAULT; 293 return 0; 294 } 295