Annotation of sys/kern/kern_clock.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: kern_clock.c,v 1.64 2007/05/16 17:27:30 art Exp $ */
! 2: /* $NetBSD: kern_clock.c,v 1.34 1996/06/09 04:51:03 briggs Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1982, 1986, 1991, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: * (c) UNIX System Laboratories, Inc.
! 8: * All or some portions of this file are derived from material licensed
! 9: * to the University of California by American Telephone and Telegraph
! 10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
! 11: * the permission of UNIX System Laboratories, Inc.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * @(#)kern_clock.c 8.5 (Berkeley) 1/21/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/dkstat.h>
! 43: #include <sys/timeout.h>
! 44: #include <sys/kernel.h>
! 45: #include <sys/limits.h>
! 46: #include <sys/proc.h>
! 47: #include <sys/user.h>
! 48: #include <sys/resourcevar.h>
! 49: #include <sys/signalvar.h>
! 50: #include <uvm/uvm_extern.h>
! 51: #include <sys/sysctl.h>
! 52: #include <sys/sched.h>
! 53: #ifdef __HAVE_TIMECOUNTER
! 54: #include <sys/timetc.h>
! 55: #endif
! 56:
! 57: #include <machine/cpu.h>
! 58:
! 59: #ifdef GPROF
! 60: #include <sys/gmon.h>
! 61: #endif
! 62:
! 63: /*
! 64: * Clock handling routines.
! 65: *
! 66: * This code is written to operate with two timers that run independently of
! 67: * each other. The main clock, running hz times per second, is used to keep
! 68: * track of real time. The second timer handles kernel and user profiling,
! 69: * and does resource use estimation. If the second timer is programmable,
! 70: * it is randomized to avoid aliasing between the two clocks. For example,
! 71: * the randomization prevents an adversary from always giving up the cpu
! 72: * just before its quantum expires. Otherwise, it would never accumulate
! 73: * cpu ticks. The mean frequency of the second timer is stathz.
! 74: *
! 75: * If no second timer exists, stathz will be zero; in this case we drive
! 76: * profiling and statistics off the main clock. This WILL NOT be accurate;
! 77: * do not do it unless absolutely necessary.
! 78: *
! 79: * The statistics clock may (or may not) be run at a higher rate while
! 80: * profiling. This profile clock runs at profhz. We require that profhz
! 81: * be an integral multiple of stathz.
! 82: *
! 83: * If the statistics clock is running fast, it must be divided by the ratio
! 84: * profhz/stathz for statistics. (For profiling, every tick counts.)
! 85: */
! 86:
! 87: /*
! 88: * Bump a timeval by a small number of usec's.
! 89: */
! 90: #define BUMPTIME(t, usec) { \
! 91: volatile struct timeval *tp = (t); \
! 92: long us; \
! 93: \
! 94: tp->tv_usec = us = tp->tv_usec + (usec); \
! 95: if (us >= 1000000) { \
! 96: tp->tv_usec = us - 1000000; \
! 97: tp->tv_sec++; \
! 98: } \
! 99: }
! 100:
! 101: int stathz;
! 102: int schedhz;
! 103: int profhz;
! 104: int profprocs;
! 105: int ticks;
! 106: static int psdiv, pscnt; /* prof => stat divider */
! 107: int psratio; /* ratio: prof / stat */
! 108:
! 109: long cp_time[CPUSTATES];
! 110:
! 111: #ifndef __HAVE_TIMECOUNTER
! 112: int tickfix, tickfixinterval; /* used if tick not really integral */
! 113: static int tickfixcnt; /* accumulated fractional error */
! 114:
! 115: volatile time_t time_second;
! 116: volatile time_t time_uptime;
! 117:
! 118: volatile struct timeval time
! 119: __attribute__((__aligned__(__alignof__(quad_t))));
! 120: volatile struct timeval mono_time;
! 121: #endif
! 122:
! 123: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 124: void *softclock_si;
! 125: void generic_softclock(void *);
! 126:
! 127: void
! 128: generic_softclock(void *ignore)
! 129: {
! 130: /*
! 131: * XXX - don't commit, just a dummy wrapper until we learn everyone
! 132: * deal with a changed proto for softclock().
! 133: */
! 134: softclock();
! 135: }
! 136: #endif
! 137:
! 138: /*
! 139: * Initialize clock frequencies and start both clocks running.
! 140: */
! 141: void
! 142: initclocks(void)
! 143: {
! 144: int i;
! 145: #ifdef __HAVE_TIMECOUNTER
! 146: extern void inittimecounter(void);
! 147: #endif
! 148:
! 149: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 150: softclock_si = softintr_establish(IPL_SOFTCLOCK, generic_softclock, NULL);
! 151: if (softclock_si == NULL)
! 152: panic("initclocks: unable to register softclock intr");
! 153: #endif
! 154:
! 155: /*
! 156: * Set divisors to 1 (normal case) and let the machine-specific
! 157: * code do its bit.
! 158: */
! 159: psdiv = pscnt = 1;
! 160: cpu_initclocks();
! 161:
! 162: /*
! 163: * Compute profhz/stathz, and fix profhz if needed.
! 164: */
! 165: i = stathz ? stathz : hz;
! 166: if (profhz == 0)
! 167: profhz = i;
! 168: psratio = profhz / i;
! 169: #ifdef __HAVE_TIMECOUNTER
! 170: inittimecounter();
! 171: #endif
! 172: }
! 173:
! 174: /*
! 175: * hardclock does the accounting needed for ITIMER_PROF and ITIMER_VIRTUAL.
! 176: * We don't want to send signals with psignal from hardclock because it makes
! 177: * MULTIPROCESSOR locking very complicated. Instead we use a small trick
! 178: * to send the signals safely and without blocking too many interrupts
! 179: * while doing that (signal handling can be heavy).
! 180: *
! 181: * hardclock detects that the itimer has expired, and schedules a timeout
! 182: * to deliver the signal. This works because of the following reasons:
! 183: * - The timeout structures can be in struct pstats because the timers
! 184: * can be only activated on curproc (never swapped). Swapout can
! 185: * only happen from a kernel thread and softclock runs before threads
! 186: * are scheduled.
! 187: * - The timeout can be scheduled with a 1 tick time because we're
! 188: * doing it before the timeout processing in hardclock. So it will
! 189: * be scheduled to run as soon as possible.
! 190: * - The timeout will be run in softclock which will run before we
! 191: * return to userland and process pending signals.
! 192: * - If the system is so busy that several VIRTUAL/PROF ticks are
! 193: * sent before softclock processing, we'll send only one signal.
! 194: * But if we'd send the signal from hardclock only one signal would
! 195: * be delivered to the user process. So userland will only see one
! 196: * signal anyway.
! 197: */
! 198:
! 199: void
! 200: virttimer_trampoline(void *v)
! 201: {
! 202: struct proc *p = v;
! 203:
! 204: psignal(p, SIGVTALRM);
! 205: }
! 206:
! 207: void
! 208: proftimer_trampoline(void *v)
! 209: {
! 210: struct proc *p = v;
! 211:
! 212: psignal(p, SIGPROF);
! 213: }
! 214:
! 215: /*
! 216: * The real-time timer, interrupting hz times per second.
! 217: */
! 218: void
! 219: hardclock(struct clockframe *frame)
! 220: {
! 221: struct proc *p;
! 222: #ifndef __HAVE_TIMECOUNTER
! 223: int delta;
! 224: extern int tickdelta;
! 225: extern long timedelta;
! 226: extern int64_t ntp_tick_permanent;
! 227: extern int64_t ntp_tick_acc;
! 228: #endif
! 229: struct cpu_info *ci = curcpu();
! 230:
! 231: p = curproc;
! 232: if (p && ((p->p_flag & (P_SYSTEM | P_WEXIT)) == 0)) {
! 233: struct pstats *pstats;
! 234:
! 235: /*
! 236: * Run current process's virtual and profile time, as needed.
! 237: */
! 238: pstats = p->p_stats;
! 239: if (CLKF_USERMODE(frame) &&
! 240: timerisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value) &&
! 241: itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0)
! 242: timeout_add(&pstats->p_virt_to, 1);
! 243: if (timerisset(&pstats->p_timer[ITIMER_PROF].it_value) &&
! 244: itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0)
! 245: timeout_add(&pstats->p_prof_to, 1);
! 246: }
! 247:
! 248: /*
! 249: * If no separate statistics clock is available, run it from here.
! 250: */
! 251: if (stathz == 0)
! 252: statclock(frame);
! 253:
! 254: if (--ci->ci_schedstate.spc_rrticks <= 0)
! 255: roundrobin(ci);
! 256:
! 257: /*
! 258: * If we are not the primary CPU, we're not allowed to do
! 259: * any more work.
! 260: */
! 261: if (CPU_IS_PRIMARY(ci) == 0)
! 262: return;
! 263:
! 264: #ifndef __HAVE_TIMECOUNTER
! 265: /*
! 266: * Increment the time-of-day. The increment is normally just
! 267: * ``tick''. If the machine is one which has a clock frequency
! 268: * such that ``hz'' would not divide the second evenly into
! 269: * milliseconds, a periodic adjustment must be applied. Finally,
! 270: * if we are still adjusting the time (see adjtime()),
! 271: * ``tickdelta'' may also be added in.
! 272: */
! 273:
! 274: delta = tick;
! 275:
! 276: if (tickfix) {
! 277: tickfixcnt += tickfix;
! 278: if (tickfixcnt >= tickfixinterval) {
! 279: delta++;
! 280: tickfixcnt -= tickfixinterval;
! 281: }
! 282: }
! 283: /* Imprecise 4bsd adjtime() handling */
! 284: if (timedelta != 0) {
! 285: delta += tickdelta;
! 286: timedelta -= tickdelta;
! 287: }
! 288:
! 289: /*
! 290: * ntp_tick_permanent accumulates the clock correction each
! 291: * tick. The unit is ns per tick shifted left 32 bits. If we have
! 292: * accumulated more than 1us, we bump delta in the right
! 293: * direction. Use a loop to avoid long long div; typicallly
! 294: * the loops will be executed 0 or 1 iteration.
! 295: */
! 296: if (ntp_tick_permanent != 0) {
! 297: ntp_tick_acc += ntp_tick_permanent;
! 298: while (ntp_tick_acc >= (1000LL << 32)) {
! 299: delta++;
! 300: ntp_tick_acc -= (1000LL << 32);
! 301: }
! 302: while (ntp_tick_acc <= -(1000LL << 32)) {
! 303: delta--;
! 304: ntp_tick_acc += (1000LL << 32);
! 305: }
! 306: }
! 307:
! 308: BUMPTIME(&time, delta);
! 309: BUMPTIME(&mono_time, delta);
! 310: time_second = time.tv_sec;
! 311: time_uptime = mono_time.tv_sec;
! 312: #else
! 313: tc_ticktock();
! 314: #endif
! 315:
! 316: /*
! 317: * Update real-time timeout queue.
! 318: * Process callouts at a very low cpu priority, so we don't keep the
! 319: * relatively high clock interrupt priority any longer than necessary.
! 320: */
! 321: if (timeout_hardclock_update()) {
! 322: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 323: softintr_schedule(softclock_si);
! 324: #else
! 325: setsoftclock();
! 326: #endif
! 327: }
! 328: }
! 329:
! 330: /*
! 331: * Compute number of hz until specified time. Used to
! 332: * compute the second argument to timeout_add() from an absolute time.
! 333: */
! 334: int
! 335: hzto(struct timeval *tv)
! 336: {
! 337: struct timeval now;
! 338: unsigned long ticks;
! 339: long sec, usec;
! 340:
! 341: /*
! 342: * If the number of usecs in the whole seconds part of the time
! 343: * difference fits in a long, then the total number of usecs will
! 344: * fit in an unsigned long. Compute the total and convert it to
! 345: * ticks, rounding up and adding 1 to allow for the current tick
! 346: * to expire. Rounding also depends on unsigned long arithmetic
! 347: * to avoid overflow.
! 348: *
! 349: * Otherwise, if the number of ticks in the whole seconds part of
! 350: * the time difference fits in a long, then convert the parts to
! 351: * ticks separately and add, using similar rounding methods and
! 352: * overflow avoidance. This method would work in the previous
! 353: * case but it is slightly slower and assumes that hz is integral.
! 354: *
! 355: * Otherwise, round the time difference down to the maximum
! 356: * representable value.
! 357: *
! 358: * If ints have 32 bits, then the maximum value for any timeout in
! 359: * 10ms ticks is 248 days.
! 360: */
! 361: getmicrotime(&now);
! 362: sec = tv->tv_sec - now.tv_sec;
! 363: usec = tv->tv_usec - now.tv_usec;
! 364: if (usec < 0) {
! 365: sec--;
! 366: usec += 1000000;
! 367: }
! 368: if (sec < 0 || (sec == 0 && usec <= 0)) {
! 369: ticks = 0;
! 370: } else if (sec <= LONG_MAX / 1000000)
! 371: ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1))
! 372: / tick + 1;
! 373: else if (sec <= LONG_MAX / hz)
! 374: ticks = sec * hz
! 375: + ((unsigned long)usec + (tick - 1)) / tick + 1;
! 376: else
! 377: ticks = LONG_MAX;
! 378: if (ticks > INT_MAX)
! 379: ticks = INT_MAX;
! 380: return ((int)ticks);
! 381: }
! 382:
! 383: /*
! 384: * Compute number of hz in the specified amount of time.
! 385: */
! 386: int
! 387: tvtohz(struct timeval *tv)
! 388: {
! 389: unsigned long ticks;
! 390: long sec, usec;
! 391:
! 392: /*
! 393: * If the number of usecs in the whole seconds part of the time
! 394: * fits in a long, then the total number of usecs will
! 395: * fit in an unsigned long. Compute the total and convert it to
! 396: * ticks, rounding up and adding 1 to allow for the current tick
! 397: * to expire. Rounding also depends on unsigned long arithmetic
! 398: * to avoid overflow.
! 399: *
! 400: * Otherwise, if the number of ticks in the whole seconds part of
! 401: * the time fits in a long, then convert the parts to
! 402: * ticks separately and add, using similar rounding methods and
! 403: * overflow avoidance. This method would work in the previous
! 404: * case but it is slightly slower and assumes that hz is integral.
! 405: *
! 406: * Otherwise, round the time down to the maximum
! 407: * representable value.
! 408: *
! 409: * If ints have 32 bits, then the maximum value for any timeout in
! 410: * 10ms ticks is 248 days.
! 411: */
! 412: sec = tv->tv_sec;
! 413: usec = tv->tv_usec;
! 414: if (sec < 0 || (sec == 0 && usec <= 0))
! 415: ticks = 0;
! 416: else if (sec <= LONG_MAX / 1000000)
! 417: ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1))
! 418: / tick + 1;
! 419: else if (sec <= LONG_MAX / hz)
! 420: ticks = sec * hz
! 421: + ((unsigned long)usec + (tick - 1)) / tick + 1;
! 422: else
! 423: ticks = LONG_MAX;
! 424: if (ticks > INT_MAX)
! 425: ticks = INT_MAX;
! 426: return ((int)ticks);
! 427: }
! 428:
! 429: /*
! 430: * Start profiling on a process.
! 431: *
! 432: * Kernel profiling passes proc0 which never exits and hence
! 433: * keeps the profile clock running constantly.
! 434: */
! 435: void
! 436: startprofclock(struct proc *p)
! 437: {
! 438: int s;
! 439:
! 440: if ((p->p_flag & P_PROFIL) == 0) {
! 441: atomic_setbits_int(&p->p_flag, P_PROFIL);
! 442: if (++profprocs == 1 && stathz != 0) {
! 443: s = splstatclock();
! 444: psdiv = pscnt = psratio;
! 445: setstatclockrate(profhz);
! 446: splx(s);
! 447: }
! 448: }
! 449: }
! 450:
! 451: /*
! 452: * Stop profiling on a process.
! 453: */
! 454: void
! 455: stopprofclock(struct proc *p)
! 456: {
! 457: int s;
! 458:
! 459: if (p->p_flag & P_PROFIL) {
! 460: atomic_clearbits_int(&p->p_flag, P_PROFIL);
! 461: if (--profprocs == 0 && stathz != 0) {
! 462: s = splstatclock();
! 463: psdiv = pscnt = 1;
! 464: setstatclockrate(stathz);
! 465: splx(s);
! 466: }
! 467: }
! 468: }
! 469:
! 470: /*
! 471: * Statistics clock. Grab profile sample, and if divider reaches 0,
! 472: * do process and kernel statistics.
! 473: */
! 474: void
! 475: statclock(struct clockframe *frame)
! 476: {
! 477: #ifdef GPROF
! 478: struct gmonparam *g;
! 479: int i;
! 480: #endif
! 481: struct cpu_info *ci = curcpu();
! 482: struct schedstate_percpu *spc = &ci->ci_schedstate;
! 483: struct proc *p = curproc;
! 484:
! 485: /*
! 486: * Notice changes in divisor frequency, and adjust clock
! 487: * frequency accordingly.
! 488: */
! 489: if (spc->spc_psdiv != psdiv) {
! 490: spc->spc_psdiv = psdiv;
! 491: spc->spc_pscnt = psdiv;
! 492: if (psdiv == 1) {
! 493: setstatclockrate(stathz);
! 494: } else {
! 495: setstatclockrate(profhz);
! 496: }
! 497: }
! 498:
! 499: if (CLKF_USERMODE(frame)) {
! 500: if (p->p_flag & P_PROFIL)
! 501: addupc_intr(p, CLKF_PC(frame));
! 502: if (--spc->spc_pscnt > 0)
! 503: return;
! 504: /*
! 505: * Came from user mode; CPU was in user state.
! 506: * If this process is being profiled record the tick.
! 507: */
! 508: p->p_uticks++;
! 509: if (p->p_nice > NZERO)
! 510: spc->spc_cp_time[CP_NICE]++;
! 511: else
! 512: spc->spc_cp_time[CP_USER]++;
! 513: } else {
! 514: #ifdef GPROF
! 515: /*
! 516: * Kernel statistics are just like addupc_intr, only easier.
! 517: */
! 518: g = &_gmonparam;
! 519: if (g->state == GMON_PROF_ON) {
! 520: i = CLKF_PC(frame) - g->lowpc;
! 521: if (i < g->textsize) {
! 522: i /= HISTFRACTION * sizeof(*g->kcount);
! 523: g->kcount[i]++;
! 524: }
! 525: }
! 526: #endif
! 527: #if defined(PROC_PC)
! 528: if (p != NULL && p->p_flag & P_PROFIL)
! 529: addupc_intr(p, PROC_PC(p));
! 530: #endif
! 531: if (--spc->spc_pscnt > 0)
! 532: return;
! 533: /*
! 534: * Came from kernel mode, so we were:
! 535: * - handling an interrupt,
! 536: * - doing syscall or trap work on behalf of the current
! 537: * user process, or
! 538: * - spinning in the idle loop.
! 539: * Whichever it is, charge the time as appropriate.
! 540: * Note that we charge interrupts to the current process,
! 541: * regardless of whether they are ``for'' that process,
! 542: * so that we know how much of its real time was spent
! 543: * in ``non-process'' (i.e., interrupt) work.
! 544: */
! 545: if (CLKF_INTR(frame)) {
! 546: if (p != NULL)
! 547: p->p_iticks++;
! 548: spc->spc_cp_time[CP_INTR]++;
! 549: } else if (p != NULL) {
! 550: p->p_sticks++;
! 551: spc->spc_cp_time[CP_SYS]++;
! 552: } else
! 553: spc->spc_cp_time[CP_IDLE]++;
! 554: }
! 555: spc->spc_pscnt = psdiv;
! 556:
! 557: if (p != NULL) {
! 558: p->p_cpticks++;
! 559: /*
! 560: * If no schedclock is provided, call it here at ~~12-25 Hz;
! 561: * ~~16 Hz is best
! 562: */
! 563: if (schedhz == 0) {
! 564: if ((++curcpu()->ci_schedstate.spc_schedticks & 3) ==
! 565: 0)
! 566: schedclock(p);
! 567: }
! 568: }
! 569: }
! 570:
! 571: /*
! 572: * Return information about system clocks.
! 573: */
! 574: int
! 575: sysctl_clockrate(char *where, size_t *sizep)
! 576: {
! 577: struct clockinfo clkinfo;
! 578:
! 579: /*
! 580: * Construct clockinfo structure.
! 581: */
! 582: clkinfo.tick = tick;
! 583: clkinfo.tickadj = tickadj;
! 584: clkinfo.hz = hz;
! 585: clkinfo.profhz = profhz;
! 586: clkinfo.stathz = stathz ? stathz : hz;
! 587: return (sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo)));
! 588: }
! 589:
! 590: #ifndef __HAVE_TIMECOUNTER
! 591: /*
! 592: * Placeholders until everyone uses the timecounters code.
! 593: * Won't improve anything except maybe removing a bunch of bugs in fixed code.
! 594: */
! 595:
! 596: void
! 597: getmicrotime(struct timeval *tvp)
! 598: {
! 599: int s;
! 600:
! 601: s = splhigh();
! 602: *tvp = time;
! 603: splx(s);
! 604: }
! 605:
! 606: void
! 607: nanotime(struct timespec *tsp)
! 608: {
! 609: struct timeval tv;
! 610:
! 611: microtime(&tv);
! 612: TIMEVAL_TO_TIMESPEC(&tv, tsp);
! 613: }
! 614:
! 615: void
! 616: getnanotime(struct timespec *tsp)
! 617: {
! 618: struct timeval tv;
! 619:
! 620: getmicrotime(&tv);
! 621: TIMEVAL_TO_TIMESPEC(&tv, tsp);
! 622: }
! 623:
! 624: void
! 625: nanouptime(struct timespec *tsp)
! 626: {
! 627: struct timeval tv;
! 628:
! 629: microuptime(&tv);
! 630: TIMEVAL_TO_TIMESPEC(&tv, tsp);
! 631: }
! 632:
! 633:
! 634: void
! 635: getnanouptime(struct timespec *tsp)
! 636: {
! 637: struct timeval tv;
! 638:
! 639: getmicrouptime(&tv);
! 640: TIMEVAL_TO_TIMESPEC(&tv, tsp);
! 641: }
! 642:
! 643: void
! 644: microuptime(struct timeval *tvp)
! 645: {
! 646: struct timeval tv;
! 647:
! 648: microtime(&tv);
! 649: timersub(&tv, &boottime, tvp);
! 650: }
! 651:
! 652: void
! 653: getmicrouptime(struct timeval *tvp)
! 654: {
! 655: int s;
! 656:
! 657: s = splhigh();
! 658: *tvp = mono_time;
! 659: splx(s);
! 660: }
! 661: #endif /* __HAVE_TIMECOUNTER */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_clock.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern