kernel/time/itimer.c

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