Annotation of sys/kern/kern_time.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: kern_time.c,v 1.62 2007/04/04 17:32:20 art Exp $ */
! 2: /* $NetBSD: kern_time.c,v 1.20 1996/02/18 11:57:06 fvdl Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 1989, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)kern_time.c 8.4 (Berkeley) 5/26/95
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/resourcevar.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/systm.h>
! 39: #include <sys/proc.h>
! 40: #include <sys/vnode.h>
! 41: #include <sys/signalvar.h>
! 42: #ifdef __HAVE_TIMECOUNTER
! 43: #include <sys/timetc.h>
! 44: #endif
! 45:
! 46: #include <sys/mount.h>
! 47: #include <sys/syscallargs.h>
! 48:
! 49: #include <machine/cpu.h>
! 50:
! 51: void itimerround(struct timeval *);
! 52:
! 53: /*
! 54: * Time of day and interval timer support.
! 55: *
! 56: * These routines provide the kernel entry points to get and set
! 57: * the time-of-day and per-process interval timers. Subroutines
! 58: * here provide support for adding and subtracting timeval structures
! 59: * and decrementing interval timers, optionally reloading the interval
! 60: * timers when they expire.
! 61: */
! 62:
! 63: /* This function is used by clock_settime and settimeofday */
! 64: #ifdef __HAVE_TIMECOUNTER
! 65: int
! 66: settime(struct timespec *ts)
! 67: {
! 68: struct timespec now;
! 69:
! 70:
! 71: /*
! 72: * Don't allow the time to be set forward so far it will wrap
! 73: * and become negative, thus allowing an attacker to bypass
! 74: * the next check below. The cutoff is 1 year before rollover
! 75: * occurs, so even if the attacker uses adjtime(2) to move
! 76: * the time past the cutoff, it will take a very long time
! 77: * to get to the wrap point.
! 78: *
! 79: * XXX: we check against INT_MAX since on 64-bit
! 80: * platforms, sizeof(int) != sizeof(long) and
! 81: * time_t is 32 bits even when atv.tv_sec is 64 bits.
! 82: */
! 83: if (ts->tv_sec > INT_MAX - 365*24*60*60) {
! 84: printf("denied attempt to set clock forward to %ld\n",
! 85: ts->tv_sec);
! 86: return (EPERM);
! 87: }
! 88: /*
! 89: * If the system is secure, we do not allow the time to be
! 90: * set to an earlier value (it may be slowed using adjtime,
! 91: * but not set back). This feature prevent interlopers from
! 92: * setting arbitrary time stamps on files.
! 93: */
! 94: nanotime(&now);
! 95: if (securelevel > 1 && timespeccmp(ts, &now, <)) {
! 96: printf("denied attempt to set clock back %ld seconds\n",
! 97: now.tv_sec - ts->tv_sec);
! 98: return (EPERM);
! 99: }
! 100:
! 101: tc_setclock(ts);
! 102: resettodr();
! 103:
! 104: return (0);
! 105: }
! 106: #else
! 107: int
! 108: settime(struct timespec *ts)
! 109: {
! 110: struct timeval delta, tvv, *tv;
! 111: int s;
! 112:
! 113: /* XXX - Ugh. */
! 114: tv = &tvv;
! 115: tvv.tv_sec = ts->tv_sec;
! 116: tvv.tv_usec = ts->tv_nsec / 1000;
! 117:
! 118: /*
! 119: * Don't allow the time to be set forward so far it will wrap
! 120: * and become negative, thus allowing an attacker to bypass
! 121: * the next check below. The cutoff is 1 year before rollover
! 122: * occurs, so even if the attacker uses adjtime(2) to move
! 123: * the time past the cutoff, it will take a very long time
! 124: * to get to the wrap point.
! 125: *
! 126: * XXX: we check against INT_MAX since on 64-bit
! 127: * platforms, sizeof(int) != sizeof(long) and
! 128: * time_t is 32 bits even when atv.tv_sec is 64 bits.
! 129: */
! 130: if (tv->tv_sec > INT_MAX - 365*24*60*60) {
! 131: printf("denied attempt to set clock forward to %ld\n",
! 132: tv->tv_sec);
! 133: return (EPERM);
! 134: }
! 135: /*
! 136: * If the system is secure, we do not allow the time to be
! 137: * set to an earlier value (it may be slowed using adjtime,
! 138: * but not set back). This feature prevent interlopers from
! 139: * setting arbitrary time stamps on files.
! 140: */
! 141: if (securelevel > 1 && timercmp(tv, &time, <)) {
! 142: printf("denied attempt to set clock back %ld seconds\n",
! 143: time_second - tv->tv_sec);
! 144: return (EPERM);
! 145: }
! 146:
! 147: /* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */
! 148: s = splclock();
! 149: timersub(tv, &time, &delta);
! 150: time = *tv;
! 151: timeradd(&boottime, &delta, &boottime);
! 152: splx(s);
! 153: resettodr();
! 154:
! 155: return (0);
! 156: }
! 157: #endif
! 158:
! 159: /* ARGSUSED */
! 160: int
! 161: sys_clock_gettime(struct proc *p, void *v, register_t *retval)
! 162: {
! 163: struct sys_clock_gettime_args /* {
! 164: syscallarg(clockid_t) clock_id;
! 165: syscallarg(struct timespec *) tp;
! 166: } */ *uap = v;
! 167: clockid_t clock_id;
! 168: struct timespec ats;
! 169:
! 170: clock_id = SCARG(uap, clock_id);
! 171: switch (clock_id) {
! 172: case CLOCK_REALTIME:
! 173: nanotime(&ats);
! 174: break;
! 175: case CLOCK_MONOTONIC:
! 176: nanouptime(&ats);
! 177: break;
! 178: case CLOCK_PROF:
! 179: ats.tv_sec = p->p_rtime.tv_sec;
! 180: ats.tv_nsec = p->p_rtime.tv_usec * 1000;
! 181: break;
! 182: default:
! 183: return (EINVAL);
! 184: }
! 185:
! 186: return copyout(&ats, SCARG(uap, tp), sizeof(ats));
! 187: }
! 188:
! 189: /* ARGSUSED */
! 190: int
! 191: sys_clock_settime(struct proc *p, void *v, register_t *retval)
! 192: {
! 193: struct sys_clock_settime_args /* {
! 194: syscallarg(clockid_t) clock_id;
! 195: syscallarg(const struct timespec *) tp;
! 196: } */ *uap = v;
! 197: struct timespec ats;
! 198: clockid_t clock_id;
! 199: int error;
! 200:
! 201: if ((error = suser(p, 0)) != 0)
! 202: return (error);
! 203:
! 204: if ((error = copyin(SCARG(uap, tp), &ats, sizeof(ats))) != 0)
! 205: return (error);
! 206:
! 207: clock_id = SCARG(uap, clock_id);
! 208: switch (clock_id) {
! 209: case CLOCK_REALTIME:
! 210: if ((error = settime(&ats)) != 0)
! 211: return (error);
! 212: break;
! 213: default: /* Other clocks are read-only */
! 214: return (EINVAL);
! 215: }
! 216:
! 217: return (0);
! 218: }
! 219:
! 220: int
! 221: sys_clock_getres(struct proc *p, void *v, register_t *retval)
! 222: {
! 223: struct sys_clock_getres_args /* {
! 224: syscallarg(clockid_t) clock_id;
! 225: syscallarg(struct timespec *) tp;
! 226: } */ *uap = v;
! 227: clockid_t clock_id;
! 228: struct timespec ts;
! 229: int error = 0;
! 230:
! 231: clock_id = SCARG(uap, clock_id);
! 232: switch (clock_id) {
! 233: case CLOCK_REALTIME:
! 234: case CLOCK_MONOTONIC:
! 235: ts.tv_sec = 0;
! 236: ts.tv_nsec = 1000000000 / hz;
! 237: break;
! 238: default:
! 239: return (EINVAL);
! 240: }
! 241:
! 242: if (SCARG(uap, tp))
! 243: error = copyout(&ts, SCARG(uap, tp), sizeof (ts));
! 244:
! 245: return error;
! 246: }
! 247:
! 248: /* ARGSUSED */
! 249: int
! 250: sys_nanosleep(struct proc *p, void *v, register_t *retval)
! 251: {
! 252: static int nanowait;
! 253: struct sys_nanosleep_args/* {
! 254: syscallarg(const struct timespec *) rqtp;
! 255: syscallarg(struct timespec *) rmtp;
! 256: } */ *uap = v;
! 257: struct timespec rqt, rmt;
! 258: struct timespec sts, ets;
! 259: struct timeval tv;
! 260: int error;
! 261:
! 262: error = copyin((const void *)SCARG(uap, rqtp), (void *)&rqt,
! 263: sizeof(struct timespec));
! 264: if (error)
! 265: return (error);
! 266:
! 267: TIMESPEC_TO_TIMEVAL(&tv, &rqt);
! 268: if (itimerfix(&tv))
! 269: return (EINVAL);
! 270:
! 271: if (SCARG(uap, rmtp))
! 272: getnanouptime(&sts);
! 273:
! 274: error = tsleep(&nanowait, PWAIT | PCATCH, "nanosleep",
! 275: MAX(1, tvtohz(&tv)));
! 276: if (error == ERESTART)
! 277: error = EINTR;
! 278: if (error == EWOULDBLOCK)
! 279: error = 0;
! 280:
! 281: if (SCARG(uap, rmtp)) {
! 282: getnanouptime(&ets);
! 283:
! 284: timespecsub(&ets, &sts, &sts);
! 285: timespecsub(&rqt, &sts, &rmt);
! 286:
! 287: if (rmt.tv_sec < 0)
! 288: timespecclear(&rmt);
! 289:
! 290: error = copyout((void *)&rmt, (void *)SCARG(uap,rmtp),
! 291: sizeof(rmt));
! 292: }
! 293:
! 294: return error;
! 295: }
! 296:
! 297: /* ARGSUSED */
! 298: int
! 299: sys_gettimeofday(struct proc *p, void *v, register_t *retval)
! 300: {
! 301: struct sys_gettimeofday_args /* {
! 302: syscallarg(struct timeval *) tp;
! 303: syscallarg(struct timezone *) tzp;
! 304: } */ *uap = v;
! 305: struct timeval atv;
! 306: int error = 0;
! 307:
! 308: if (SCARG(uap, tp)) {
! 309: microtime(&atv);
! 310: if ((error = copyout((void *)&atv, (void *)SCARG(uap, tp),
! 311: sizeof (atv))))
! 312: return (error);
! 313: }
! 314: if (SCARG(uap, tzp))
! 315: error = copyout((void *)&tz, (void *)SCARG(uap, tzp),
! 316: sizeof (tz));
! 317: return (error);
! 318: }
! 319:
! 320: /* ARGSUSED */
! 321: int
! 322: sys_settimeofday(struct proc *p, void *v, register_t *retval)
! 323: {
! 324: struct sys_settimeofday_args /* {
! 325: syscallarg(const struct timeval *) tv;
! 326: syscallarg(const struct timezone *) tzp;
! 327: } */ *uap = v;
! 328: struct timezone atz;
! 329: struct timeval atv;
! 330: int error;
! 331:
! 332: if ((error = suser(p, 0)))
! 333: return (error);
! 334: /* Verify all parameters before changing time. */
! 335: if (SCARG(uap, tv) && (error = copyin((void *)SCARG(uap, tv),
! 336: (void *)&atv, sizeof(atv))))
! 337: return (error);
! 338: if (SCARG(uap, tzp) && (error = copyin((void *)SCARG(uap, tzp),
! 339: (void *)&atz, sizeof(atz))))
! 340: return (error);
! 341: if (SCARG(uap, tv)) {
! 342: struct timespec ts;
! 343:
! 344: TIMEVAL_TO_TIMESPEC(&atv, &ts);
! 345: if ((error = settime(&ts)) != 0)
! 346: return (error);
! 347: }
! 348: if (SCARG(uap, tzp))
! 349: tz = atz;
! 350: return (0);
! 351: }
! 352:
! 353: #ifdef __HAVE_TIMECOUNTER
! 354: struct timeval adjtimedelta; /* unapplied time correction */
! 355: #else
! 356: int tickdelta; /* current clock skew, us. per tick */
! 357: long timedelta; /* unapplied time correction, us. */
! 358: long bigadj = 1000000; /* use 10x skew above bigadj us. */
! 359: int64_t ntp_tick_permanent;
! 360: int64_t ntp_tick_acc;
! 361: #endif
! 362:
! 363: /* ARGSUSED */
! 364: int
! 365: sys_adjfreq(struct proc *p, void *v, register_t *retval)
! 366: {
! 367: struct sys_adjfreq_args /* {
! 368: syscallarg(const int64_t *) freq;
! 369: syscallarg(int64_t *) oldfreq;
! 370: } */ *uap = v;
! 371: int error;
! 372: int64_t f;
! 373: #ifndef __HAVE_TIMECOUNTER
! 374: int s;
! 375:
! 376: if (SCARG(uap, oldfreq)) {
! 377: f = ntp_tick_permanent * hz;
! 378: if ((error = copyout((void *)&f, (void *)SCARG(uap, oldfreq),
! 379: sizeof(int64_t))))
! 380: return (error);
! 381: }
! 382: if (SCARG(uap, freq)) {
! 383: if ((error = suser(p, 0)))
! 384: return (error);
! 385: if ((error = copyin((void *)SCARG(uap, freq), (void *)&f,
! 386: sizeof(int64_t))))
! 387: return (error);
! 388: s = splclock();
! 389: ntp_tick_permanent = f / hz;
! 390: splx(s);
! 391: }
! 392: #else
! 393: if (SCARG(uap, oldfreq)) {
! 394: if ((error = tc_adjfreq(&f, NULL)) != 0)
! 395: return (error);
! 396: if ((error = copyout(&f, SCARG(uap, oldfreq), sizeof(f))) != 0)
! 397: return (error);
! 398: }
! 399: if (SCARG(uap, freq)) {
! 400: if ((error = suser(p, 0)))
! 401: return (error);
! 402: if ((error = copyin(SCARG(uap, freq), &f, sizeof(f))) != 0)
! 403: return (error);
! 404: if ((error = tc_adjfreq(NULL, &f)) != 0)
! 405: return (error);
! 406: }
! 407: #endif
! 408: return (0);
! 409: }
! 410:
! 411: /* ARGSUSED */
! 412: int
! 413: sys_adjtime(struct proc *p, void *v, register_t *retval)
! 414: {
! 415: struct sys_adjtime_args /* {
! 416: syscallarg(const struct timeval *) delta;
! 417: syscallarg(struct timeval *) olddelta;
! 418: } */ *uap = v;
! 419: #ifdef __HAVE_TIMECOUNTER
! 420: int error;
! 421:
! 422: if (SCARG(uap, olddelta))
! 423: if ((error = copyout((void *)&adjtimedelta,
! 424: (void *)SCARG(uap, olddelta), sizeof(struct timeval))))
! 425: return (error);
! 426:
! 427: if (SCARG(uap, delta)) {
! 428: if ((error = suser(p, 0)))
! 429: return (error);
! 430:
! 431: if ((error = copyin((void *)SCARG(uap, delta),
! 432: (void *)&adjtimedelta, sizeof(struct timeval))))
! 433: return (error);
! 434: }
! 435:
! 436: /* Normalize the correction. */
! 437: while (adjtimedelta.tv_usec >= 1000000) {
! 438: adjtimedelta.tv_usec -= 1000000;
! 439: adjtimedelta.tv_sec += 1;
! 440: }
! 441: while (adjtimedelta.tv_usec < 0) {
! 442: adjtimedelta.tv_usec += 1000000;
! 443: adjtimedelta.tv_sec -= 1;
! 444: }
! 445: return (0);
! 446: #else
! 447: struct timeval atv;
! 448: long ndelta, ntickdelta, odelta;
! 449: int s, error;
! 450:
! 451: if (!SCARG(uap, delta)) {
! 452: s = splclock();
! 453: odelta = timedelta;
! 454: splx(s);
! 455: goto out;
! 456: }
! 457: if ((error = suser(p, 0)))
! 458: return (error);
! 459: if ((error = copyin((void *)SCARG(uap, delta), (void *)&atv,
! 460: sizeof(struct timeval))))
! 461: return (error);
! 462:
! 463: /*
! 464: * Compute the total correction and the rate at which to apply it.
! 465: * Round the adjustment down to a whole multiple of the per-tick
! 466: * delta, so that after some number of incremental changes in
! 467: * hardclock(), tickdelta will become zero, lest the correction
! 468: * overshoot and start taking us away from the desired final time.
! 469: */
! 470: if (atv.tv_sec > LONG_MAX / 1000000L)
! 471: ndelta = LONG_MAX;
! 472: else if (atv.tv_sec < LONG_MIN / 1000000L)
! 473: ndelta = LONG_MIN;
! 474: else {
! 475: ndelta = atv.tv_sec * 1000000L;
! 476: odelta = ndelta;
! 477: ndelta += atv.tv_usec;
! 478: if (atv.tv_usec > 0 && ndelta <= odelta)
! 479: ndelta = LONG_MAX;
! 480: else if (atv.tv_usec < 0 && ndelta >= odelta)
! 481: ndelta = LONG_MIN;
! 482: }
! 483:
! 484: if (ndelta > bigadj || ndelta < -bigadj)
! 485: ntickdelta = 10 * tickadj;
! 486: else
! 487: ntickdelta = tickadj;
! 488: if (ndelta % ntickdelta)
! 489: ndelta = ndelta / ntickdelta * ntickdelta;
! 490:
! 491: /*
! 492: * To make hardclock()'s job easier, make the per-tick delta negative
! 493: * if we want time to run slower; then hardclock can simply compute
! 494: * tick + tickdelta, and subtract tickdelta from timedelta.
! 495: */
! 496: if (ndelta < 0)
! 497: ntickdelta = -ntickdelta;
! 498: s = splclock();
! 499: odelta = timedelta;
! 500: timedelta = ndelta;
! 501: tickdelta = ntickdelta;
! 502: splx(s);
! 503:
! 504: out:
! 505: if (SCARG(uap, olddelta)) {
! 506: atv.tv_sec = odelta / 1000000;
! 507: atv.tv_usec = odelta % 1000000;
! 508: if ((error = copyout((void *)&atv, (void *)SCARG(uap, olddelta),
! 509: sizeof(struct timeval))))
! 510: return (error);
! 511: }
! 512: return (0);
! 513: #endif
! 514: }
! 515:
! 516:
! 517: /*
! 518: * Get value of an interval timer. The process virtual and
! 519: * profiling virtual time timers are kept in the p_stats area, since
! 520: * they can be swapped out. These are kept internally in the
! 521: * way they are specified externally: in time until they expire.
! 522: *
! 523: * The real time interval timer is kept in the process table slot
! 524: * for the process, and its value (it_value) is kept as an
! 525: * absolute time rather than as a delta, so that it is easy to keep
! 526: * periodic real-time signals from drifting.
! 527: *
! 528: * Virtual time timers are processed in the hardclock() routine of
! 529: * kern_clock.c. The real time timer is processed by a timeout
! 530: * routine, called from the softclock() routine. Since a callout
! 531: * may be delayed in real time due to interrupt processing in the system,
! 532: * it is possible for the real time timeout routine (realitexpire, given below),
! 533: * to be delayed in real time past when it is supposed to occur. It
! 534: * does not suffice, therefore, to reload the real timer .it_value from the
! 535: * real time timers .it_interval. Rather, we compute the next time in
! 536: * absolute time the timer should go off.
! 537: */
! 538: /* ARGSUSED */
! 539: int
! 540: sys_getitimer(struct proc *p, void *v, register_t *retval)
! 541: {
! 542: struct sys_getitimer_args /* {
! 543: syscallarg(int) which;
! 544: syscallarg(struct itimerval *) itv;
! 545: } */ *uap = v;
! 546: struct itimerval aitv;
! 547: int s;
! 548:
! 549: if (SCARG(uap, which) < ITIMER_REAL || SCARG(uap, which) > ITIMER_PROF)
! 550: return (EINVAL);
! 551: s = splclock();
! 552: if (SCARG(uap, which) == ITIMER_REAL) {
! 553: struct timeval now;
! 554:
! 555: getmicrouptime(&now);
! 556: /*
! 557: * Convert from absolute to relative time in .it_value
! 558: * part of real time timer. If time for real time timer
! 559: * has passed return 0, else return difference between
! 560: * current time and time for the timer to go off.
! 561: */
! 562: aitv = p->p_realtimer;
! 563: if (timerisset(&aitv.it_value)) {
! 564: if (timercmp(&aitv.it_value, &now, <))
! 565: timerclear(&aitv.it_value);
! 566: else
! 567: timersub(&aitv.it_value, &now,
! 568: &aitv.it_value);
! 569: }
! 570: } else
! 571: aitv = p->p_stats->p_timer[SCARG(uap, which)];
! 572: splx(s);
! 573: return (copyout((void *)&aitv, (void *)SCARG(uap, itv),
! 574: sizeof (struct itimerval)));
! 575: }
! 576:
! 577: /* ARGSUSED */
! 578: int
! 579: sys_setitimer(struct proc *p, void *v, register_t *retval)
! 580: {
! 581: struct sys_setitimer_args /* {
! 582: syscallarg(int) which;
! 583: syscallarg(const struct itimerval *) itv;
! 584: syscallarg(struct itimerval *) oitv;
! 585: } */ *uap = v;
! 586: struct sys_getitimer_args getargs;
! 587: struct itimerval aitv;
! 588: const struct itimerval *itvp;
! 589: int error;
! 590: int timo;
! 591:
! 592: if (SCARG(uap, which) < ITIMER_REAL || SCARG(uap, which) > ITIMER_PROF)
! 593: return (EINVAL);
! 594: itvp = SCARG(uap, itv);
! 595: if (itvp && (error = copyin((void *)itvp, (void *)&aitv,
! 596: sizeof(struct itimerval))))
! 597: return (error);
! 598: if (SCARG(uap, oitv) != NULL) {
! 599: SCARG(&getargs, which) = SCARG(uap, which);
! 600: SCARG(&getargs, itv) = SCARG(uap, oitv);
! 601: if ((error = sys_getitimer(p, &getargs, retval)))
! 602: return (error);
! 603: }
! 604: if (itvp == 0)
! 605: return (0);
! 606: if (itimerfix(&aitv.it_value) || itimerfix(&aitv.it_interval))
! 607: return (EINVAL);
! 608: if (SCARG(uap, which) == ITIMER_REAL) {
! 609: struct timeval ctv;
! 610:
! 611: timeout_del(&p->p_realit_to);
! 612: getmicrouptime(&ctv);
! 613: if (timerisset(&aitv.it_value)) {
! 614: timo = tvtohz(&aitv.it_value);
! 615: timeout_add(&p->p_realit_to, timo);
! 616: timeradd(&aitv.it_value, &ctv, &aitv.it_value);
! 617: }
! 618: p->p_realtimer = aitv;
! 619: } else {
! 620: int s;
! 621:
! 622: itimerround(&aitv.it_interval);
! 623: s = splclock();
! 624: p->p_stats->p_timer[SCARG(uap, which)] = aitv;
! 625: splx(s);
! 626: }
! 627:
! 628: return (0);
! 629: }
! 630:
! 631: /*
! 632: * Real interval timer expired:
! 633: * send process whose timer expired an alarm signal.
! 634: * If time is not set up to reload, then just return.
! 635: * Else compute next time timer should go off which is > current time.
! 636: * This is where delay in processing this timeout causes multiple
! 637: * SIGALRM calls to be compressed into one.
! 638: */
! 639: void
! 640: realitexpire(void *arg)
! 641: {
! 642: struct proc *p;
! 643:
! 644: p = (struct proc *)arg;
! 645: psignal(p, SIGALRM);
! 646: if (!timerisset(&p->p_realtimer.it_interval)) {
! 647: timerclear(&p->p_realtimer.it_value);
! 648: return;
! 649: }
! 650: for (;;) {
! 651: struct timeval ctv, ntv;
! 652: int timo;
! 653:
! 654: timeradd(&p->p_realtimer.it_value,
! 655: &p->p_realtimer.it_interval, &p->p_realtimer.it_value);
! 656: getmicrouptime(&ctv);
! 657: if (timercmp(&p->p_realtimer.it_value, &ctv, >)) {
! 658: ntv = p->p_realtimer.it_value;
! 659: timersub(&ntv, &ctv, &ntv);
! 660: timo = tvtohz(&ntv) - 1;
! 661: if (timo <= 0)
! 662: timo = 1;
! 663: if ((p->p_flag & P_WEXIT) == 0)
! 664: timeout_add(&p->p_realit_to, timo);
! 665: return;
! 666: }
! 667: }
! 668: }
! 669:
! 670: /*
! 671: * Check that a proposed value to load into the .it_value or
! 672: * .it_interval part of an interval timer is acceptable.
! 673: */
! 674: int
! 675: itimerfix(struct timeval *tv)
! 676: {
! 677:
! 678: if (tv->tv_sec < 0 || tv->tv_sec > 100000000 ||
! 679: tv->tv_usec < 0 || tv->tv_usec >= 1000000)
! 680: return (EINVAL);
! 681:
! 682: if (tv->tv_sec == 0 && tv->tv_usec != 0 && tv->tv_usec < tick)
! 683: tv->tv_usec = tick;
! 684:
! 685: return (0);
! 686: }
! 687:
! 688: /*
! 689: * Timer interval smaller than the resolution of the system clock are
! 690: * rounded up.
! 691: */
! 692: void
! 693: itimerround(struct timeval *tv)
! 694: {
! 695: if (tv->tv_sec == 0 && tv->tv_usec < tick)
! 696: tv->tv_usec = tick;
! 697: }
! 698:
! 699: /*
! 700: * Decrement an interval timer by a specified number
! 701: * of microseconds, which must be less than a second,
! 702: * i.e. < 1000000. If the timer expires, then reload
! 703: * it. In this case, carry over (usec - old value) to
! 704: * reduce the value reloaded into the timer so that
! 705: * the timer does not drift. This routine assumes
! 706: * that it is called in a context where the timers
! 707: * on which it is operating cannot change in value.
! 708: */
! 709: int
! 710: itimerdecr(struct itimerval *itp, int usec)
! 711: {
! 712:
! 713: if (itp->it_value.tv_usec < usec) {
! 714: if (itp->it_value.tv_sec == 0) {
! 715: /* expired, and already in next interval */
! 716: usec -= itp->it_value.tv_usec;
! 717: goto expire;
! 718: }
! 719: itp->it_value.tv_usec += 1000000;
! 720: itp->it_value.tv_sec--;
! 721: }
! 722: itp->it_value.tv_usec -= usec;
! 723: usec = 0;
! 724: if (timerisset(&itp->it_value))
! 725: return (1);
! 726: /* expired, exactly at end of interval */
! 727: expire:
! 728: if (timerisset(&itp->it_interval)) {
! 729: itp->it_value = itp->it_interval;
! 730: itp->it_value.tv_usec -= usec;
! 731: if (itp->it_value.tv_usec < 0) {
! 732: itp->it_value.tv_usec += 1000000;
! 733: itp->it_value.tv_sec--;
! 734: }
! 735: } else
! 736: itp->it_value.tv_usec = 0; /* sec is already 0 */
! 737: return (0);
! 738: }
! 739:
! 740: /*
! 741: * ratecheck(): simple time-based rate-limit checking. see ratecheck(9)
! 742: * for usage and rationale.
! 743: */
! 744: int
! 745: ratecheck(struct timeval *lasttime, const struct timeval *mininterval)
! 746: {
! 747: struct timeval tv, delta;
! 748: int rv = 0;
! 749:
! 750: microuptime(&tv);
! 751:
! 752: timersub(&tv, lasttime, &delta);
! 753:
! 754: /*
! 755: * check for 0,0 is so that the message will be seen at least once,
! 756: * even if interval is huge.
! 757: */
! 758: if (timercmp(&delta, mininterval, >=) ||
! 759: (lasttime->tv_sec == 0 && lasttime->tv_usec == 0)) {
! 760: *lasttime = tv;
! 761: rv = 1;
! 762: }
! 763:
! 764: return (rv);
! 765: }
! 766:
! 767: /*
! 768: * ppsratecheck(): packets (or events) per second limitation.
! 769: */
! 770: int
! 771: ppsratecheck(struct timeval *lasttime, int *curpps, int maxpps)
! 772: {
! 773: struct timeval tv, delta;
! 774: int rv;
! 775:
! 776: microuptime(&tv);
! 777:
! 778: timersub(&tv, lasttime, &delta);
! 779:
! 780: /*
! 781: * check for 0,0 is so that the message will be seen at least once.
! 782: * if more than one second have passed since the last update of
! 783: * lasttime, reset the counter.
! 784: *
! 785: * we do increment *curpps even in *curpps < maxpps case, as some may
! 786: * try to use *curpps for stat purposes as well.
! 787: */
! 788: if (maxpps == 0)
! 789: rv = 0;
! 790: else if ((lasttime->tv_sec == 0 && lasttime->tv_usec == 0) ||
! 791: delta.tv_sec >= 1) {
! 792: *lasttime = tv;
! 793: *curpps = 0;
! 794: rv = 1;
! 795: } else if (maxpps < 0)
! 796: rv = 1;
! 797: else if (*curpps < maxpps)
! 798: rv = 1;
! 799: else
! 800: rv = 0;
! 801:
! 802: #if 1 /*DIAGNOSTIC?*/
! 803: /* be careful about wrap-around */
! 804: if (*curpps + 1 > *curpps)
! 805: *curpps = *curpps + 1;
! 806: #else
! 807: /*
! 808: * assume that there's not too many calls to this function.
! 809: * not sure if the assumption holds, as it depends on *caller's*
! 810: * behavior, not the behavior of this function.
! 811: * IMHO it is wrong to make assumption on the caller's behavior,
! 812: * so the above #if is #if 1, not #ifdef DIAGNOSTIC.
! 813: */
! 814: *curpps = *curpps + 1;
! 815: #endif
! 816:
! 817: return (rv);
! 818: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_time.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern