servers/pm/alarm.c

   1 /* This file deals with the alarm clock related system calls, eventually
   2  * passing off the work to the functions in timers.c and check_sig() in
   3  * signal.c to pass an alarm signal to a process.
   4  *
   5  * The entry points into this file are:
   6  *   do_itimer: perform the ITIMER system call
   7  *   do_alarm: perform the ALARM system call
   8  *   set_alarm: tell the timer interface to start or stop a process timer
   9  *   check_vtimer: check if one of the virtual timers needs to be restarted
  10  */
  11
  12 #include "pm.h"
  13 #include <signal.h>
  14 #include <sys/time.h>
  15 #include <string.h>
  16 #include <minix/com.h>
  17 #include "mproc.h"
  18 #include "param.h"
  19
  20 #define US 1000000      /* shortcut for microseconds per second */
  21
  22 static clock_t ticks_from_timeval(struct timeval *tv);
  23 static void timeval_from_ticks(struct timeval *tv, clock_t ticks);
  24 static int is_sane_timeval(struct timeval *tv);
  25 static void getset_vtimer(struct mproc *mp, int nwhich, struct
  26         itimerval *value, struct itimerval *ovalue);
  27 static void get_realtimer(struct mproc *mp, struct itimerval *value);
  28 static void set_realtimer(struct mproc *mp, struct itimerval *value);
  29 static void cause_sigalrm(struct timer *tp);
  30
  31 /*===========================================================================*
  32  *                              ticks_from_timeval                           *
  33  *===========================================================================*/
  34 static clock_t ticks_from_timeval(tv)
  35 struct timeval *tv;
  36 {
  37   clock_t ticks;
  38
  39   /* Large delays cause a lot of problems.  First, the alarm system call
  40    * takes an unsigned seconds count and the library has cast it to an int.
  41    * That probably works, but on return the library will convert "negative"
  42    * unsigneds to errors.  Presumably no one checks for these errors, so
  43    * force this call through.  Second, If unsigned and long have the same
  44    * size, converting from seconds to ticks can easily overflow.  Finally,
  45    * the kernel has similar overflow bugs adding ticks.
  46    *
  47    * Fixing this requires a lot of ugly casts to fit the wrong interface
  48    * types and to avoid overflow traps.  ALRM_EXP_TIME has the right type
  49    * (clock_t) although it is declared as long.  How can variables like
  50    * this be declared properly without combinatorial explosion of message
  51    * types?
  52    */
  53
  54   /* In any case, the following conversion must always round up. */
  55
  56   ticks = (clock_t) (system_hz * (unsigned long) tv->tv_sec);
  57   if ( (unsigned long) ticks / system_hz != (unsigned long) tv->tv_sec) {
  58         ticks = LONG_MAX;
  59   } else {
  60         ticks += (clock_t)
  61                 ((system_hz * (unsigned long) tv->tv_usec + (US-1)) / US);
  62   }
  63
  64   if (ticks < 0) ticks = LONG_MAX;
  65
  66   return(ticks);
  67 }
  68
  69 /*===========================================================================*
  70  *                              timeval_from_ticks                           *
  71  *===========================================================================*/
  72 static void timeval_from_ticks(tv, ticks)
  73 struct timeval *tv;
  74 clock_t ticks;
  75 {
  76   tv->tv_sec = (long) (ticks / system_hz);
  77   tv->tv_usec = (long) ((ticks % system_hz) * US / system_hz);
  78 }
  79
  80 /*===========================================================================*
  81  *                              is_sane_timeval                              *
  82  *===========================================================================*/
  83 static int is_sane_timeval(tv)
  84 struct timeval *tv;
  85 {
  86   /* This imposes a reasonable time value range for setitimer. */
  87   return (tv->tv_sec >= 0 && tv->tv_sec <= MAX_SECS &&
  88           tv->tv_usec >= 0 && tv->tv_usec < US);
  89 }
  90
  91 /*===========================================================================*
  92  *                              do_itimer                                    *
  93  *===========================================================================*/
  94 int do_itimer()
  95 {
  96   struct itimerval ovalue, value;       /* old and new interval timers */
  97   int setval, getval;                   /* set and/or retrieve the values? */
  98   int r;
  99
 100   /* Make sure 'which' is one of the defined timers. */
 101   if (m_in.which_timer < 0 || m_in.which_timer >= NR_ITIMERS)
 102         return(EINVAL);
 103
 104   /* Determine whether to set and/or return the given timer value, based on
 105    * which of the new_val and old_val parameters are nonzero. At least one of
 106    * them must be nonzero.
 107    */
 108   setval = (m_in.new_val != NULL);
 109   getval = (m_in.old_val != NULL);
 110
 111   if (!setval && !getval) return(EINVAL);
 112
 113   /* If we're setting a new value, copy the new timer from user space.
 114    * Also, make sure its fields have sane values.
 115    */
 116   if (setval) {
 117         r = sys_datacopy(who_e, (vir_bytes) m_in.new_val,
 118                 PM_PROC_NR, (vir_bytes) &value, (phys_bytes) sizeof(value));
 119         if (r != OK) return(r);
 120
 121         if (!is_sane_timeval(&value.it_value) ||
 122             !is_sane_timeval(&value.it_interval))
 123                 return(EINVAL);
 124   }
 125
 126   switch (m_in.which_timer) {
 127         case ITIMER_REAL :
 128                 if (getval) get_realtimer(mp, &ovalue);
 129
 130                 if (setval) set_realtimer(mp, &value);
 131
 132                 r = OK;
 133                 break;
 134
 135         case ITIMER_VIRTUAL :
 136         case ITIMER_PROF :
 137                 getset_vtimer(mp, m_in.which_timer,
 138                                 (setval) ? &value : NULL,
 139                                 (getval) ? &ovalue : NULL);
 140
 141                 r = OK;
 142                 break;
 143
 144         default:
 145                 panic("invalid timer type: %d", m_in.which_timer);
 146   }
 147
 148   /* If requested, copy the old interval timer to user space. */
 149   if (r == OK && getval) {
 150         r = sys_datacopy(PM_PROC_NR, (vir_bytes) &ovalue,
 151                 who_e, (vir_bytes) m_in.old_val, (phys_bytes) sizeof(ovalue));
 152   }
 153
 154   return(r);
 155 }
 156
 157 /*===========================================================================*
 158  *                              do_alarm                                     *
 159  *===========================================================================*/
 160 int do_alarm()
 161 {
 162   struct itimerval value, ovalue;
 163   int remaining;                /* previous time left in seconds */
 164
 165   /* retrieve the old timer value, in seconds (rounded up) */
 166   get_realtimer(mp, &ovalue);
 167
 168   remaining = ovalue.it_value.tv_sec;
 169   if (ovalue.it_value.tv_usec > 0) remaining++;
 170
 171   /* set the new timer value */
 172   memset(&value, 0, sizeof(value));
 173   value.it_value.tv_sec = m_in.seconds;
 174
 175   set_realtimer(mp, &value);
 176
 177   /* and return the old timer value */
 178   return(remaining);
 179 }
 180
 181 /*===========================================================================*
 182  *                              getset_vtimer                                *
 183  *===========================================================================*/
 184 static void getset_vtimer(rmp, which, value, ovalue)
 185 struct mproc *rmp;
 186 int which;
 187 struct itimerval *value;
 188 struct itimerval *ovalue;
 189 {
 190   clock_t newticks, *nptr;              /* the new timer value, in ticks */
 191   clock_t oldticks, *optr;              /* the old ticks value, in ticks */
 192   int r, num;
 193
 194   /* The default is to provide sys_vtimer with two null pointers, i.e. to do
 195    * nothing at all.
 196    */
 197   optr = nptr = NULL;
 198
 199   /* If the old timer value is to be retrieved, have 'optr' point to the
 200    * location where the old value is to be stored, and copy the interval.
 201    */
 202   if (ovalue != NULL) {
 203         optr = &oldticks;
 204
 205         timeval_from_ticks(&ovalue->it_interval, rmp->mp_interval[which]);
 206   }
 207
 208   /* If a new timer value is to be set, store the new timer value and have
 209    * 'nptr' point to it. Also, store the new interval.
 210    */
 211   if (value != NULL) {
 212         newticks = ticks_from_timeval(&value->it_value);
 213         nptr = &newticks;
 214
 215         /* If no timer is set, the interval must be zero. */
 216         if (newticks <= 0)
 217                 rmp->mp_interval[which] = 0;
 218         else
 219                 rmp->mp_interval[which] =
 220                         ticks_from_timeval(&value->it_interval);
 221   }
 222
 223   /* Find out which kernel timer number to use. */
 224   switch (which) {
 225   case ITIMER_VIRTUAL: num = VT_VIRTUAL; break;
 226   case ITIMER_PROF:    num = VT_PROF;    break;
 227   default:             panic("invalid vtimer type: %d", which);
 228   }
 229
 230   /* Make the kernel call. If requested, also retrieve and store
 231    * the old timer value.
 232    */
 233   if ((r = sys_vtimer(rmp->mp_endpoint, num, nptr, optr)) != OK)
 234         panic("sys_vtimer failed: %d", r);
 235
 236   if (ovalue != NULL) {
 237         /* If the alarm expired already, we should take into account the
 238          * interval. Return zero only if the interval is zero as well.
 239          */
 240         if (oldticks <= 0) oldticks = rmp->mp_interval[which];
 241
 242         timeval_from_ticks(&ovalue->it_value, oldticks);
 243   }
 244 }
 245
 246 /*===========================================================================*
 247  *                              check_vtimer                                 *
 248  *===========================================================================*/
 249 void check_vtimer(proc_nr, sig)
 250 int proc_nr;
 251 int sig;
 252 {
 253   register struct mproc *rmp;
 254   int which, num;
 255
 256   rmp = &mproc[proc_nr];
 257
 258   /* Translate back the given signal to a timer type and kernel number. */
 259   switch (sig) {
 260   case SIGVTALRM: which = ITIMER_VIRTUAL; num = VT_VIRTUAL; break;
 261   case SIGPROF:   which = ITIMER_PROF;    num = VT_PROF;    break;
 262   default: panic("invalid vtimer signal: %d", sig);
 263   }
 264
 265   /* If a repetition interval was set for this virtual timer, tell the
 266    * kernel to set a new timeout for the virtual timer.
 267    */
 268   if (rmp->mp_interval[which] > 0)
 269         sys_vtimer(rmp->mp_endpoint, num, &rmp->mp_interval[which], NULL);
 270 }
 271
 272 /*===========================================================================*
 273  *                              get_realtimer                                *
 274  *===========================================================================*/
 275 static void get_realtimer(rmp, value)
 276 struct mproc *rmp;
 277 struct itimerval *value;
 278 {
 279   clock_t exptime;      /* time at which alarm will expire */
 280   clock_t uptime;       /* current system time */
 281   clock_t remaining;    /* time left on alarm */
 282   int s;
 283
 284   /* First determine remaining time, in ticks, of previous alarm, if set. */
 285   if (rmp->mp_flags & ALARM_ON) {
 286         if ( (s = getuptime(&uptime)) != OK)
 287                 panic("get_realtimer couldn't get uptime: %d", s);
 288         exptime = *tmr_exp_time(&rmp->mp_timer);
 289
 290         remaining = exptime - uptime;
 291
 292         /* If the alarm expired already, we should take into account the
 293          * interval. Return zero only if the interval is zero as well.
 294          */
 295         if (remaining <= 0) remaining = rmp->mp_interval[ITIMER_REAL];
 296   } else {
 297         remaining = 0;
 298   }
 299
 300   /* Convert the result to a timeval structure. */
 301   timeval_from_ticks(&value->it_value, remaining);
 302
 303   /* Similarly convert and store the interval of the timer. */
 304   timeval_from_ticks(&value->it_interval, rmp->mp_interval[ITIMER_REAL]);
 305 }
 306
 307 /*===========================================================================*
 308  *                              set_realtimer                                *
 309  *===========================================================================*/
 310 static void set_realtimer(rmp, value)
 311 struct mproc *rmp;
 312 struct itimerval *value;
 313 {
 314   clock_t ticks;        /* New amount of ticks to the next alarm. */
 315   clock_t interval;     /* New amount of ticks for the alarm's interval. */
 316
 317   /* Convert the timeval structures in the 'value' structure to ticks. */
 318   ticks = ticks_from_timeval(&value->it_value);
 319   interval = ticks_from_timeval(&value->it_interval);
 320
 321   /* If no timer is set, the interval must be zero. */
 322   if (ticks <= 0) interval = 0;
 323
 324   /* Apply these values. */
 325   set_alarm(rmp, ticks);
 326   rmp->mp_interval[ITIMER_REAL] = interval;
 327 }
 328
 329 /*===========================================================================*
 330  *                              set_alarm                                    *
 331  *===========================================================================*/
 332 void set_alarm(rmp, ticks)
 333 struct mproc *rmp;              /* process that wants the alarm */
 334 clock_t ticks;                  /* how many ticks delay before the signal */
 335 {
 336   if (ticks > 0) {
 337         set_timer(&rmp->mp_timer, ticks, cause_sigalrm, rmp->mp_endpoint);
 338         rmp->mp_flags |=  ALARM_ON;
 339   } else if (rmp->mp_flags & ALARM_ON) {
 340         cancel_timer(&rmp->mp_timer);
 341         rmp->mp_flags &= ~ALARM_ON;
 342   }
 343 }
 344
 345 /*===========================================================================*
 346  *                              cause_sigalrm                                *
 347  *===========================================================================*/
 348 static void cause_sigalrm(tp)
 349 struct timer *tp;
 350 {
 351   int proc_nr_n;
 352   register struct mproc *rmp;
 353
 354   /* get process from timer */
 355   if(pm_isokendpt(tmr_arg(tp)->ta_int, &proc_nr_n) != OK) {
 356         printf("PM: ignoring timer for invalid endpoint %d\n",
 357                 tmr_arg(tp)->ta_int);
 358         return;
 359   }
 360
 361   rmp = &mproc[proc_nr_n];
 362
 363   if ((rmp->mp_flags & (IN_USE | EXITING)) != IN_USE) return;
 364   if ((rmp->mp_flags & ALARM_ON) == 0) return;
 365
 366   /* If an interval is set, set a new timer; otherwise clear the ALARM_ON flag.
 367    * The set_alarm call will be calling set_timer from within this callback
 368    * from the expire_timers function. This is safe, but we must not use the
 369    * "tp" structure below this point anymore.
 370    */
 371   if (rmp->mp_interval[ITIMER_REAL] > 0)
 372         set_alarm(rmp, rmp->mp_interval[ITIMER_REAL]);
 373   else rmp->mp_flags &= ~ALARM_ON;
 374
 375   check_sig(rmp->mp_pid, SIGALRM, FALSE /* ksig */);
 376 }