1dcae39bdSmckusick /* 2*8f6f57faSbostic * Copyright (c) 1982, 1986, 1989, 1993 3*8f6f57faSbostic * The Regents of the University of California. All rights reserved. 4dcae39bdSmckusick * 5b383d302Sbostic * %sccs.include.redist.c% 6014695a9Smckusick * 7*8f6f57faSbostic * @(#)kern_time.c 8.1 (Berkeley) 06/10/93 8dcae39bdSmckusick */ 9db51853bSsam 106e23d7a0Sbostic #include <sys/param.h> 116e23d7a0Sbostic #include <sys/resourcevar.h> 126e23d7a0Sbostic #include <sys/kernel.h> 136e23d7a0Sbostic #include <sys/systm.h> 146e23d7a0Sbostic #include <sys/proc.h> 156e23d7a0Sbostic #include <sys/vnode.h> 16ef678427Sroot 176e23d7a0Sbostic #include <machine/cpu.h> 1867a72975Skarels 1972762883Sroot /* 2072762883Sroot * Time of day and interval timer support. 2134eef8ebSroot * 2234eef8ebSroot * These routines provide the kernel entry points to get and set 2334eef8ebSroot * the time-of-day and per-process interval timers. Subroutines 2434eef8ebSroot * here provide support for adding and subtracting timeval structures 2534eef8ebSroot * and decrementing interval timers, optionally reloading the interval 2634eef8ebSroot * timers when they expire. 2772762883Sroot */ 2872762883Sroot 29e5ed490aStorek struct gettimeofday_args { 30e5ed490aStorek struct timeval *tp; 31e5ed490aStorek struct timezone *tzp; 32e5ed490aStorek }; 33d1ec48c2Skarels /* ARGSUSED */ 34d1ec48c2Skarels gettimeofday(p, uap, retval) 35d1ec48c2Skarels struct proc *p; 36e5ed490aStorek register struct gettimeofday_args *uap; 37d1ec48c2Skarels int *retval; 38d1ec48c2Skarels { 39ef678427Sroot struct timeval atv; 40d1ec48c2Skarels int error = 0; 41ef678427Sroot 422da4521eSbostic if (uap->tp) { 4370dbe469Skarels microtime(&atv); 44d1ec48c2Skarels if (error = copyout((caddr_t)&atv, (caddr_t)uap->tp, 45d1ec48c2Skarels sizeof (atv))) 462c51c3e4Skarels return (error); 472da4521eSbostic } 482da4521eSbostic if (uap->tzp) 49d1ec48c2Skarels error = copyout((caddr_t)&tz, (caddr_t)uap->tzp, 502da4521eSbostic sizeof (tz)); 512c51c3e4Skarels return (error); 52ef678427Sroot } 53ef678427Sroot 54e5ed490aStorek struct settimeofday_args { 55e5ed490aStorek struct timeval *tv; 56e5ed490aStorek struct timezone *tzp; 57e5ed490aStorek }; 58187e1fb7Sbostic /* ARGSUSED */ 59d1ec48c2Skarels settimeofday(p, uap, retval) 60d1ec48c2Skarels struct proc *p; 61e5ed490aStorek struct settimeofday_args *uap; 62d1ec48c2Skarels int *retval; 63d1ec48c2Skarels { 64e4223d7eStorek struct timeval atv, delta; 65ef678427Sroot struct timezone atz; 66d1ec48c2Skarels int error, s; 67ef678427Sroot 680b0833e3Skarels if (error = suser(p->p_ucred, &p->p_acflag)) 692c51c3e4Skarels return (error); 70e4223d7eStorek /* Verify all parameters before changing time. */ 71e4223d7eStorek if (uap->tv && 72e4223d7eStorek (error = copyin((caddr_t)uap->tv, (caddr_t)&atv, sizeof(atv)))) 732c51c3e4Skarels return (error); 74e4223d7eStorek if (uap->tzp && 75e4223d7eStorek (error = copyin((caddr_t)uap->tzp, (caddr_t)&atz, sizeof(atz)))) 76e4223d7eStorek return (error); 77e4223d7eStorek if (uap->tv) { 78014695a9Smckusick /* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */ 79e4223d7eStorek s = splclock(); 80e4223d7eStorek /* nb. delta.tv_usec may be < 0, but this is OK here */ 81e4223d7eStorek delta.tv_sec = atv.tv_sec - time.tv_sec; 82e4223d7eStorek delta.tv_usec = atv.tv_usec - time.tv_usec; 83e4223d7eStorek time = atv; 84e4223d7eStorek (void) splsoftclock(); 85e4223d7eStorek timevaladd(&boottime, &delta); 86e4223d7eStorek timevalfix(&boottime); 87e4223d7eStorek timevaladd(&runtime, &delta); 88e4223d7eStorek timevalfix(&runtime); 89e4223d7eStorek LEASE_UPDATETIME(delta.tv_sec); 90e4223d7eStorek splx(s); 91014695a9Smckusick resettodr(); 922da4521eSbostic } 93e4223d7eStorek if (uap->tzp) 940228495eSsam tz = atz; 95e4223d7eStorek return (0); 96ef678427Sroot } 9772762883Sroot 98a690062aSkarels extern int tickadj; /* "standard" clock skew, us./tick */ 99a690062aSkarels int tickdelta; /* current clock skew, us. per tick */ 100a690062aSkarels long timedelta; /* unapplied time correction, us. */ 101a690062aSkarels long bigadj = 1000000; /* use 10x skew above bigadj us. */ 1025d3ec6cbSkarels 103e5ed490aStorek struct adjtime_args { 104e5ed490aStorek struct timeval *delta; 105e5ed490aStorek struct timeval *olddelta; 106e5ed490aStorek }; 107d1ec48c2Skarels /* ARGSUSED */ 108d1ec48c2Skarels adjtime(p, uap, retval) 109d1ec48c2Skarels struct proc *p; 110e5ed490aStorek register struct adjtime_args *uap; 111d1ec48c2Skarels int *retval; 112d1ec48c2Skarels { 113cbd24f66Storek struct timeval atv; 114cbd24f66Storek register long ndelta, ntickdelta, odelta; 115d1ec48c2Skarels int s, error; 1165d3ec6cbSkarels 1170b0833e3Skarels if (error = suser(p->p_ucred, &p->p_acflag)) 1182c51c3e4Skarels return (error); 119d1ec48c2Skarels if (error = 120d1ec48c2Skarels copyin((caddr_t)uap->delta, (caddr_t)&atv, sizeof(struct timeval))) 1212c51c3e4Skarels return (error); 122a690062aSkarels 123cbd24f66Storek /* 124cbd24f66Storek * Compute the total correction and the rate at which to apply it. 125cbd24f66Storek * Round the adjustment down to a whole multiple of the per-tick 126cbd24f66Storek * delta, so that after some number of incremental changes in 127cbd24f66Storek * hardclock(), tickdelta will become zero, lest the correction 128cbd24f66Storek * overshoot and start taking us away from the desired final time. 129cbd24f66Storek */ 130cbd24f66Storek ndelta = atv.tv_sec * 1000000 + atv.tv_usec; 131cbd24f66Storek if (ndelta > bigadj) 132cbd24f66Storek ntickdelta = 10 * tickadj; 133cbd24f66Storek else 134cbd24f66Storek ntickdelta = tickadj; 135cbd24f66Storek if (ndelta % ntickdelta) 136cbd24f66Storek ndelta = ndelta / ntickdelta * ntickdelta; 137cbd24f66Storek 138cbd24f66Storek /* 139cbd24f66Storek * To make hardclock()'s job easier, make the per-tick delta negative 140cbd24f66Storek * if we want time to run slower; then hardclock can simply compute 141cbd24f66Storek * tick + tickdelta, and subtract tickdelta from timedelta. 142cbd24f66Storek */ 143cbd24f66Storek if (ndelta < 0) 144cbd24f66Storek ntickdelta = -ntickdelta; 145e782b972Skarels s = splclock(); 146cbd24f66Storek odelta = timedelta; 147a690062aSkarels timedelta = ndelta; 148cbd24f66Storek tickdelta = ntickdelta; 149a690062aSkarels splx(s); 150a690062aSkarels 151cbd24f66Storek if (uap->olddelta) { 152cbd24f66Storek atv.tv_sec = odelta / 1000000; 153cbd24f66Storek atv.tv_usec = odelta % 1000000; 154cbd24f66Storek (void) copyout((caddr_t)&atv, (caddr_t)uap->olddelta, 1555d3ec6cbSkarels sizeof(struct timeval)); 156cbd24f66Storek } 1572c51c3e4Skarels return (0); 1585d3ec6cbSkarels } 1595d3ec6cbSkarels 16034eef8ebSroot /* 16134eef8ebSroot * Get value of an interval timer. The process virtual and 1620b0833e3Skarels * profiling virtual time timers are kept in the p_stats area, since 16334eef8ebSroot * they can be swapped out. These are kept internally in the 16434eef8ebSroot * way they are specified externally: in time until they expire. 16534eef8ebSroot * 16634eef8ebSroot * The real time interval timer is kept in the process table slot 16734eef8ebSroot * for the process, and its value (it_value) is kept as an 16834eef8ebSroot * absolute time rather than as a delta, so that it is easy to keep 16934eef8ebSroot * periodic real-time signals from drifting. 17034eef8ebSroot * 17134eef8ebSroot * Virtual time timers are processed in the hardclock() routine of 17234eef8ebSroot * kern_clock.c. The real time timer is processed by a timeout 17334eef8ebSroot * routine, called from the softclock() routine. Since a callout 17434eef8ebSroot * may be delayed in real time due to interrupt processing in the system, 17534eef8ebSroot * it is possible for the real time timeout routine (realitexpire, given below), 17634eef8ebSroot * to be delayed in real time past when it is supposed to occur. It 17734eef8ebSroot * does not suffice, therefore, to reload the real timer .it_value from the 17834eef8ebSroot * real time timers .it_interval. Rather, we compute the next time in 17934eef8ebSroot * absolute time the timer should go off. 18034eef8ebSroot */ 181e5ed490aStorek struct getitimer_args { 182e5ed490aStorek u_int which; 183e5ed490aStorek struct itimerval *itv; 184e5ed490aStorek }; 185d1ec48c2Skarels /* ARGSUSED */ 186d1ec48c2Skarels getitimer(p, uap, retval) 187d1ec48c2Skarels struct proc *p; 188e5ed490aStorek register struct getitimer_args *uap; 189d1ec48c2Skarels int *retval; 190d1ec48c2Skarels { 1910ed3b3c8Sroot struct itimerval aitv; 192ef678427Sroot int s; 193ef678427Sroot 194d1ec48c2Skarels if (uap->which > ITIMER_PROF) 1952c51c3e4Skarels return (EINVAL); 19670dbe469Skarels s = splclock(); 1970ed3b3c8Sroot if (uap->which == ITIMER_REAL) { 19834eef8ebSroot /* 19934eef8ebSroot * Convert from absoulte to relative time in .it_value 20034eef8ebSroot * part of real time timer. If time for real time timer 20134eef8ebSroot * has passed return 0, else return difference between 20234eef8ebSroot * current time and time for the timer to go off. 20334eef8ebSroot */ 204d1ec48c2Skarels aitv = p->p_realtimer; 2050ed3b3c8Sroot if (timerisset(&aitv.it_value)) 2060ed3b3c8Sroot if (timercmp(&aitv.it_value, &time, <)) 2070ed3b3c8Sroot timerclear(&aitv.it_value); 2080ed3b3c8Sroot else 209e4223d7eStorek timevalsub(&aitv.it_value, 210e4223d7eStorek (struct timeval *)&time); 2110ed3b3c8Sroot } else 2120b0833e3Skarels aitv = p->p_stats->p_timer[uap->which]; 2130ed3b3c8Sroot splx(s); 2142c51c3e4Skarels return (copyout((caddr_t)&aitv, (caddr_t)uap->itv, 215d1ec48c2Skarels sizeof (struct itimerval))); 216ef678427Sroot } 217ef678427Sroot 218e5ed490aStorek struct setitimer_args { 219e5ed490aStorek u_int which; 220e5ed490aStorek struct itimerval *itv, *oitv; 221e5ed490aStorek }; 222d1ec48c2Skarels /* ARGSUSED */ 223d1ec48c2Skarels setitimer(p, uap, retval) 224d1ec48c2Skarels struct proc *p; 225e5ed490aStorek register struct setitimer_args *uap; 226d1ec48c2Skarels int *retval; 227d1ec48c2Skarels { 2283468c2f1Smckusick struct itimerval aitv; 2293468c2f1Smckusick register struct itimerval *itvp; 230d1ec48c2Skarels int s, error; 231ef678427Sroot 232d1ec48c2Skarels if (uap->which > ITIMER_PROF) 2332c51c3e4Skarels return (EINVAL); 2343468c2f1Smckusick itvp = uap->itv; 235d1ec48c2Skarels if (itvp && (error = copyin((caddr_t)itvp, (caddr_t)&aitv, 2363468c2f1Smckusick sizeof(struct itimerval)))) 2372c51c3e4Skarels return (error); 238d1ec48c2Skarels if ((uap->itv = uap->oitv) && (error = getitimer(p, uap, retval))) 2392c51c3e4Skarels return (error); 2403468c2f1Smckusick if (itvp == 0) 241d1ec48c2Skarels return (0); 242d1ec48c2Skarels if (itimerfix(&aitv.it_value) || itimerfix(&aitv.it_interval)) 2432c51c3e4Skarels return (EINVAL); 24470dbe469Skarels s = splclock(); 2450ed3b3c8Sroot if (uap->which == ITIMER_REAL) { 246a11faa3dSroot untimeout(realitexpire, (caddr_t)p); 2470ed3b3c8Sroot if (timerisset(&aitv.it_value)) { 248e4223d7eStorek timevaladd(&aitv.it_value, (struct timeval *)&time); 249a11faa3dSroot timeout(realitexpire, (caddr_t)p, hzto(&aitv.it_value)); 2500ed3b3c8Sroot } 2510ed3b3c8Sroot p->p_realtimer = aitv; 2520ed3b3c8Sroot } else 2530b0833e3Skarels p->p_stats->p_timer[uap->which] = aitv; 254ef678427Sroot splx(s); 2552c51c3e4Skarels return (0); 256ef678427Sroot } 257ef678427Sroot 25834eef8ebSroot /* 25934eef8ebSroot * Real interval timer expired: 26034eef8ebSroot * send process whose timer expired an alarm signal. 26134eef8ebSroot * If time is not set up to reload, then just return. 26234eef8ebSroot * Else compute next time timer should go off which is > current time. 26334eef8ebSroot * This is where delay in processing this timeout causes multiple 26434eef8ebSroot * SIGALRM calls to be compressed into one. 26534eef8ebSroot */ 266e4223d7eStorek void 267e4223d7eStorek realitexpire(arg) 268e4223d7eStorek void *arg; 2690ed3b3c8Sroot { 270e4223d7eStorek register struct proc *p; 2710ed3b3c8Sroot int s; 2720ed3b3c8Sroot 273e4223d7eStorek p = (struct proc *)arg; 2740ed3b3c8Sroot psignal(p, SIGALRM); 2750ed3b3c8Sroot if (!timerisset(&p->p_realtimer.it_interval)) { 2760ed3b3c8Sroot timerclear(&p->p_realtimer.it_value); 2770ed3b3c8Sroot return; 2780ed3b3c8Sroot } 2790ed3b3c8Sroot for (;;) { 28070dbe469Skarels s = splclock(); 2810ed3b3c8Sroot timevaladd(&p->p_realtimer.it_value, 2820ed3b3c8Sroot &p->p_realtimer.it_interval); 2830ed3b3c8Sroot if (timercmp(&p->p_realtimer.it_value, &time, >)) { 284a11faa3dSroot timeout(realitexpire, (caddr_t)p, 285a11faa3dSroot hzto(&p->p_realtimer.it_value)); 2860ed3b3c8Sroot splx(s); 2870ed3b3c8Sroot return; 2880ed3b3c8Sroot } 2890ed3b3c8Sroot splx(s); 2900ed3b3c8Sroot } 2910ed3b3c8Sroot } 2920ed3b3c8Sroot 29334eef8ebSroot /* 29434eef8ebSroot * Check that a proposed value to load into the .it_value or 29534eef8ebSroot * .it_interval part of an interval timer is acceptable, and 29634eef8ebSroot * fix it to have at least minimal value (i.e. if it is less 29734eef8ebSroot * than the resolution of the clock, round it up.) 29834eef8ebSroot */ 29972762883Sroot itimerfix(tv) 30072762883Sroot struct timeval *tv; 30172762883Sroot { 30272762883Sroot 3030ed3b3c8Sroot if (tv->tv_sec < 0 || tv->tv_sec > 100000000 || 3040ed3b3c8Sroot tv->tv_usec < 0 || tv->tv_usec >= 1000000) 30572762883Sroot return (EINVAL); 30642312cf9Ssam if (tv->tv_sec == 0 && tv->tv_usec != 0 && tv->tv_usec < tick) 30772762883Sroot tv->tv_usec = tick; 30872762883Sroot return (0); 30972762883Sroot } 31072762883Sroot 31134eef8ebSroot /* 31234eef8ebSroot * Decrement an interval timer by a specified number 31334eef8ebSroot * of microseconds, which must be less than a second, 31434eef8ebSroot * i.e. < 1000000. If the timer expires, then reload 31534eef8ebSroot * it. In this case, carry over (usec - old value) to 316e4223d7eStorek * reduce the value reloaded into the timer so that 31734eef8ebSroot * the timer does not drift. This routine assumes 31834eef8ebSroot * that it is called in a context where the timers 31934eef8ebSroot * on which it is operating cannot change in value. 32034eef8ebSroot */ 321ef678427Sroot itimerdecr(itp, usec) 322ef678427Sroot register struct itimerval *itp; 323ef678427Sroot int usec; 324ef678427Sroot { 325ef678427Sroot 32672762883Sroot if (itp->it_value.tv_usec < usec) { 32772762883Sroot if (itp->it_value.tv_sec == 0) { 32834eef8ebSroot /* expired, and already in next interval */ 32972762883Sroot usec -= itp->it_value.tv_usec; 330ef678427Sroot goto expire; 331ef678427Sroot } 33272762883Sroot itp->it_value.tv_usec += 1000000; 33372762883Sroot itp->it_value.tv_sec--; 33472762883Sroot } 33572762883Sroot itp->it_value.tv_usec -= usec; 33672762883Sroot usec = 0; 33772762883Sroot if (timerisset(&itp->it_value)) 338ef678427Sroot return (1); 33934eef8ebSroot /* expired, exactly at end of interval */ 340ef678427Sroot expire: 34172762883Sroot if (timerisset(&itp->it_interval)) { 34272762883Sroot itp->it_value = itp->it_interval; 34372762883Sroot itp->it_value.tv_usec -= usec; 34472762883Sroot if (itp->it_value.tv_usec < 0) { 34572762883Sroot itp->it_value.tv_usec += 1000000; 34672762883Sroot itp->it_value.tv_sec--; 34772762883Sroot } 34872762883Sroot } else 34934eef8ebSroot itp->it_value.tv_usec = 0; /* sec is already 0 */ 350ef678427Sroot return (0); 351ef678427Sroot } 352ef678427Sroot 35334eef8ebSroot /* 35434eef8ebSroot * Add and subtract routines for timevals. 35534eef8ebSroot * N.B.: subtract routine doesn't deal with 35634eef8ebSroot * results which are before the beginning, 35734eef8ebSroot * it just gets very confused in this case. 35834eef8ebSroot * Caveat emptor. 35934eef8ebSroot */ 36034eef8ebSroot timevaladd(t1, t2) 36134eef8ebSroot struct timeval *t1, *t2; 36234eef8ebSroot { 36334eef8ebSroot 36434eef8ebSroot t1->tv_sec += t2->tv_sec; 36534eef8ebSroot t1->tv_usec += t2->tv_usec; 36634eef8ebSroot timevalfix(t1); 36734eef8ebSroot } 36834eef8ebSroot 36934eef8ebSroot timevalsub(t1, t2) 37034eef8ebSroot struct timeval *t1, *t2; 37134eef8ebSroot { 37234eef8ebSroot 37334eef8ebSroot t1->tv_sec -= t2->tv_sec; 37434eef8ebSroot t1->tv_usec -= t2->tv_usec; 37534eef8ebSroot timevalfix(t1); 37634eef8ebSroot } 37734eef8ebSroot 37834eef8ebSroot timevalfix(t1) 37934eef8ebSroot struct timeval *t1; 38034eef8ebSroot { 38134eef8ebSroot 38234eef8ebSroot if (t1->tv_usec < 0) { 38334eef8ebSroot t1->tv_sec--; 38434eef8ebSroot t1->tv_usec += 1000000; 38534eef8ebSroot } 38634eef8ebSroot if (t1->tv_usec >= 1000000) { 38734eef8ebSroot t1->tv_sec++; 38834eef8ebSroot t1->tv_usec -= 1000000; 38934eef8ebSroot } 39034eef8ebSroot } 391