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/sched/signal.h> 14 #include <linux/sched/cputime.h> 15 #include <linux/posix-timers.h> 16 #include <linux/hrtimer.h> 17 #include <trace/events/timer.h> 18 19 #include <linux/uaccess.h> 20 21 /** 22 * itimer_get_remtime - get remaining time for the timer 23 * 24 * @timer: the timer to read 25 * 26 * Returns the delta between the expiry time and now, which can be 27 * less than zero or 1usec for an pending expired timer 28 */ 29 static struct timeval itimer_get_remtime(struct hrtimer *timer) 30 { 31 ktime_t rem = __hrtimer_get_remaining(timer, true); 32 33 /* 34 * Racy but safe: if the itimer expires after the above 35 * hrtimer_get_remtime() call but before this condition 36 * then we return 0 - which is correct. 37 */ 38 if (hrtimer_active(timer)) { 39 if (rem <= 0) 40 rem = NSEC_PER_USEC; 41 } else 42 rem = 0; 43 44 return ktime_to_timeval(rem); 45 } 46 47 static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, 48 struct itimerval *const value) 49 { 50 u64 val, interval; 51 struct cpu_itimer *it = &tsk->signal->it[clock_id]; 52 53 spin_lock_irq(&tsk->sighand->siglock); 54 55 val = it->expires; 56 interval = it->incr; 57 if (val) { 58 struct task_cputime cputime; 59 u64 t; 60 61 thread_group_cputimer(tsk, &cputime); 62 if (clock_id == CPUCLOCK_PROF) 63 t = cputime.utime + cputime.stime; 64 else 65 /* CPUCLOCK_VIRT */ 66 t = cputime.utime; 67 68 if (val < t) 69 /* about to fire */ 70 val = TICK_NSEC; 71 else 72 val -= t; 73 } 74 75 spin_unlock_irq(&tsk->sighand->siglock); 76 77 value->it_value = ns_to_timeval(val); 78 value->it_interval = ns_to_timeval(interval); 79 } 80 81 int do_getitimer(int which, struct itimerval *value) 82 { 83 struct task_struct *tsk = current; 84 85 switch (which) { 86 case ITIMER_REAL: 87 spin_lock_irq(&tsk->sighand->siglock); 88 value->it_value = itimer_get_remtime(&tsk->signal->real_timer); 89 value->it_interval = 90 ktime_to_timeval(tsk->signal->it_real_incr); 91 spin_unlock_irq(&tsk->sighand->siglock); 92 break; 93 case ITIMER_VIRTUAL: 94 get_cpu_itimer(tsk, CPUCLOCK_VIRT, value); 95 break; 96 case ITIMER_PROF: 97 get_cpu_itimer(tsk, CPUCLOCK_PROF, value); 98 break; 99 default: 100 return(-EINVAL); 101 } 102 return 0; 103 } 104 105 SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value) 106 { 107 int error = -EFAULT; 108 struct itimerval get_buffer; 109 110 if (value) { 111 error = do_getitimer(which, &get_buffer); 112 if (!error && 113 copy_to_user(value, &get_buffer, sizeof(get_buffer))) 114 error = -EFAULT; 115 } 116 return error; 117 } 118 119 120 /* 121 * The timer is automagically restarted, when interval != 0 122 */ 123 enum hrtimer_restart it_real_fn(struct hrtimer *timer) 124 { 125 struct signal_struct *sig = 126 container_of(timer, struct signal_struct, real_timer); 127 128 trace_itimer_expire(ITIMER_REAL, sig->leader_pid, 0); 129 kill_pid_info(SIGALRM, SEND_SIG_PRIV, sig->leader_pid); 130 131 return HRTIMER_NORESTART; 132 } 133 134 static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, 135 const struct itimerval *const value, 136 struct itimerval *const ovalue) 137 { 138 u64 oval, nval, ointerval, ninterval; 139 struct cpu_itimer *it = &tsk->signal->it[clock_id]; 140 141 nval = timeval_to_ns(&value->it_value); 142 ninterval = timeval_to_ns(&value->it_interval); 143 144 spin_lock_irq(&tsk->sighand->siglock); 145 146 oval = it->expires; 147 ointerval = it->incr; 148 if (oval || nval) { 149 if (nval > 0) 150 nval += TICK_NSEC; 151 set_process_cpu_timer(tsk, clock_id, &nval, &oval); 152 } 153 it->expires = nval; 154 it->incr = ninterval; 155 trace_itimer_state(clock_id == CPUCLOCK_VIRT ? 156 ITIMER_VIRTUAL : ITIMER_PROF, value, nval); 157 158 spin_unlock_irq(&tsk->sighand->siglock); 159 160 if (ovalue) { 161 ovalue->it_value = ns_to_timeval(oval); 162 ovalue->it_interval = ns_to_timeval(ointerval); 163 } 164 } 165 166 /* 167 * Returns true if the timeval is in canonical form 168 */ 169 #define timeval_valid(t) \ 170 (((t)->tv_sec >= 0) && (((unsigned long) (t)->tv_usec) < USEC_PER_SEC)) 171 172 int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue) 173 { 174 struct task_struct *tsk = current; 175 struct hrtimer *timer; 176 ktime_t expires; 177 178 /* 179 * Validate the timevals in value. 180 */ 181 if (!timeval_valid(&value->it_value) || 182 !timeval_valid(&value->it_interval)) 183 return -EINVAL; 184 185 switch (which) { 186 case ITIMER_REAL: 187 again: 188 spin_lock_irq(&tsk->sighand->siglock); 189 timer = &tsk->signal->real_timer; 190 if (ovalue) { 191 ovalue->it_value = itimer_get_remtime(timer); 192 ovalue->it_interval 193 = ktime_to_timeval(tsk->signal->it_real_incr); 194 } 195 /* We are sharing ->siglock with it_real_fn() */ 196 if (hrtimer_try_to_cancel(timer) < 0) { 197 spin_unlock_irq(&tsk->sighand->siglock); 198 goto again; 199 } 200 expires = timeval_to_ktime(value->it_value); 201 if (expires != 0) { 202 tsk->signal->it_real_incr = 203 timeval_to_ktime(value->it_interval); 204 hrtimer_start(timer, expires, HRTIMER_MODE_REL); 205 } else 206 tsk->signal->it_real_incr = 0; 207 208 trace_itimer_state(ITIMER_REAL, value, 0); 209 spin_unlock_irq(&tsk->sighand->siglock); 210 break; 211 case ITIMER_VIRTUAL: 212 set_cpu_itimer(tsk, CPUCLOCK_VIRT, value, ovalue); 213 break; 214 case ITIMER_PROF: 215 set_cpu_itimer(tsk, CPUCLOCK_PROF, value, ovalue); 216 break; 217 default: 218 return -EINVAL; 219 } 220 return 0; 221 } 222 223 #ifdef __ARCH_WANT_SYS_ALARM 224 225 /** 226 * alarm_setitimer - set alarm in seconds 227 * 228 * @seconds: number of seconds until alarm 229 * 0 disables the alarm 230 * 231 * Returns the remaining time in seconds of a pending timer or 0 when 232 * the timer is not active. 233 * 234 * On 32 bit machines the seconds value is limited to (INT_MAX/2) to avoid 235 * negative timeval settings which would cause immediate expiry. 236 */ 237 static unsigned int alarm_setitimer(unsigned int seconds) 238 { 239 struct itimerval it_new, it_old; 240 241 #if BITS_PER_LONG < 64 242 if (seconds > INT_MAX) 243 seconds = INT_MAX; 244 #endif 245 it_new.it_value.tv_sec = seconds; 246 it_new.it_value.tv_usec = 0; 247 it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0; 248 249 do_setitimer(ITIMER_REAL, &it_new, &it_old); 250 251 /* 252 * We can't return 0 if we have an alarm pending ... And we'd 253 * better return too much than too little anyway 254 */ 255 if ((!it_old.it_value.tv_sec && it_old.it_value.tv_usec) || 256 it_old.it_value.tv_usec >= 500000) 257 it_old.it_value.tv_sec++; 258 259 return it_old.it_value.tv_sec; 260 } 261 262 /* 263 * For backwards compatibility? This can be done in libc so Alpha 264 * and all newer ports shouldn't need it. 265 */ 266 SYSCALL_DEFINE1(alarm, unsigned int, seconds) 267 { 268 return alarm_setitimer(seconds); 269 } 270 271 #endif 272 273 SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value, 274 struct itimerval __user *, ovalue) 275 { 276 struct itimerval set_buffer, get_buffer; 277 int error; 278 279 if (value) { 280 if(copy_from_user(&set_buffer, value, sizeof(set_buffer))) 281 return -EFAULT; 282 } else { 283 memset(&set_buffer, 0, sizeof(set_buffer)); 284 printk_once(KERN_WARNING "%s calls setitimer() with new_value NULL pointer." 285 " Misfeature support will be removed\n", 286 current->comm); 287 } 288 289 error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL); 290 if (error || !ovalue) 291 return error; 292 293 if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer))) 294 return -EFAULT; 295 return 0; 296 } 297