Annotation of sys/sys/time.h, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: time.h,v 1.25 2007/05/09 17:42:19 deraadt Exp $ */
! 2: /* $NetBSD: time.h,v 1.18 1996/04/23 10:29:33 mycroft Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 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: * @(#)time.h 8.2 (Berkeley) 7/10/94
! 33: */
! 34:
! 35: #ifndef _SYS_TIME_H_
! 36: #define _SYS_TIME_H_
! 37:
! 38: #include <sys/cdefs.h>
! 39: #include <sys/types.h>
! 40:
! 41: #if __XPG_VISIBLE >= 420 && __XPG_VISIBLE < 600
! 42: #include <sys/select.h>
! 43: #endif
! 44:
! 45: /*
! 46: * Structure returned by gettimeofday(2) system call,
! 47: * and used in other calls.
! 48: */
! 49: struct timeval {
! 50: long tv_sec; /* seconds */
! 51: long tv_usec; /* and microseconds */
! 52: };
! 53:
! 54: #ifndef _TIMESPEC_DECLARED
! 55: #define _TIMESPEC_DECLARED
! 56: /*
! 57: * Structure defined by POSIX.1b to be like a timeval.
! 58: */
! 59: struct timespec {
! 60: time_t tv_sec; /* seconds */
! 61: long tv_nsec; /* and nanoseconds */
! 62: };
! 63: #endif
! 64:
! 65: #define TIMEVAL_TO_TIMESPEC(tv, ts) { \
! 66: (ts)->tv_sec = (tv)->tv_sec; \
! 67: (ts)->tv_nsec = (tv)->tv_usec * 1000; \
! 68: }
! 69: #define TIMESPEC_TO_TIMEVAL(tv, ts) { \
! 70: (tv)->tv_sec = (ts)->tv_sec; \
! 71: (tv)->tv_usec = (ts)->tv_nsec / 1000; \
! 72: }
! 73:
! 74: struct timezone {
! 75: int tz_minuteswest; /* minutes west of Greenwich */
! 76: int tz_dsttime; /* type of dst correction */
! 77: };
! 78: #define DST_NONE 0 /* not on dst */
! 79: #define DST_USA 1 /* USA style dst */
! 80: #define DST_AUST 2 /* Australian style dst */
! 81: #define DST_WET 3 /* Western European dst */
! 82: #define DST_MET 4 /* Middle European dst */
! 83: #define DST_EET 5 /* Eastern European dst */
! 84: #define DST_CAN 6 /* Canada */
! 85:
! 86: /* Operations on timevals. */
! 87: #define timerclear(tvp) (tvp)->tv_sec = (tvp)->tv_usec = 0
! 88: #define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
! 89: #define timercmp(tvp, uvp, cmp) \
! 90: (((tvp)->tv_sec == (uvp)->tv_sec) ? \
! 91: ((tvp)->tv_usec cmp (uvp)->tv_usec) : \
! 92: ((tvp)->tv_sec cmp (uvp)->tv_sec))
! 93: #define timeradd(tvp, uvp, vvp) \
! 94: do { \
! 95: (vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec; \
! 96: (vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec; \
! 97: if ((vvp)->tv_usec >= 1000000) { \
! 98: (vvp)->tv_sec++; \
! 99: (vvp)->tv_usec -= 1000000; \
! 100: } \
! 101: } while (0)
! 102: #define timersub(tvp, uvp, vvp) \
! 103: do { \
! 104: (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; \
! 105: (vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; \
! 106: if ((vvp)->tv_usec < 0) { \
! 107: (vvp)->tv_sec--; \
! 108: (vvp)->tv_usec += 1000000; \
! 109: } \
! 110: } while (0)
! 111:
! 112: /* Operations on timespecs. */
! 113: #define timespecclear(tsp) (tsp)->tv_sec = (tsp)->tv_nsec = 0
! 114: #define timespecisset(tsp) ((tsp)->tv_sec || (tsp)->tv_nsec)
! 115: #define timespeccmp(tsp, usp, cmp) \
! 116: (((tsp)->tv_sec == (usp)->tv_sec) ? \
! 117: ((tsp)->tv_nsec cmp (usp)->tv_nsec) : \
! 118: ((tsp)->tv_sec cmp (usp)->tv_sec))
! 119: #define timespecadd(tsp, usp, vsp) \
! 120: do { \
! 121: (vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec; \
! 122: (vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec; \
! 123: if ((vsp)->tv_nsec >= 1000000000L) { \
! 124: (vsp)->tv_sec++; \
! 125: (vsp)->tv_nsec -= 1000000000L; \
! 126: } \
! 127: } while (0)
! 128: #define timespecsub(tsp, usp, vsp) \
! 129: do { \
! 130: (vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec; \
! 131: (vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec; \
! 132: if ((vsp)->tv_nsec < 0) { \
! 133: (vsp)->tv_sec--; \
! 134: (vsp)->tv_nsec += 1000000000L; \
! 135: } \
! 136: } while (0)
! 137:
! 138: /* Time expressed as seconds and fractions of a second + operations on it. */
! 139: struct bintime {
! 140: time_t sec;
! 141: uint64_t frac;
! 142: };
! 143:
! 144: static __inline void
! 145: bintime_addx(struct bintime *bt, uint64_t x)
! 146: {
! 147: uint64_t u;
! 148:
! 149: u = bt->frac;
! 150: bt->frac += x;
! 151: if (u > bt->frac)
! 152: bt->sec++;
! 153: }
! 154:
! 155: static __inline void
! 156: bintime_add(struct bintime *bt, struct bintime *bt2)
! 157: {
! 158: uint64_t u;
! 159:
! 160: u = bt->frac;
! 161: bt->frac += bt2->frac;
! 162: if (u > bt->frac)
! 163: bt->sec++;
! 164: bt->sec += bt2->sec;
! 165: }
! 166:
! 167: static __inline void
! 168: bintime_sub(struct bintime *bt, struct bintime *bt2)
! 169: {
! 170: uint64_t u;
! 171:
! 172: u = bt->frac;
! 173: bt->frac -= bt2->frac;
! 174: if (u < bt->frac)
! 175: bt->sec--;
! 176: bt->sec -= bt2->sec;
! 177: }
! 178:
! 179: /*-
! 180: * Background information:
! 181: *
! 182: * When converting between timestamps on parallel timescales of differing
! 183: * resolutions it is historical and scientific practice to round down rather
! 184: * than doing 4/5 rounding.
! 185: *
! 186: * The date changes at midnight, not at noon.
! 187: *
! 188: * Even at 15:59:59.999999999 it's not four'o'clock.
! 189: *
! 190: * time_second ticks after N.999999999 not after N.4999999999
! 191: */
! 192:
! 193: static __inline void
! 194: bintime2timespec(struct bintime *bt, struct timespec *ts)
! 195: {
! 196:
! 197: ts->tv_sec = bt->sec;
! 198: ts->tv_nsec = (long)(((uint64_t)1000000000 * (uint32_t)(bt->frac >> 32)) >> 32);
! 199: }
! 200:
! 201: static __inline void
! 202: timespec2bintime(struct timespec *ts, struct bintime *bt)
! 203: {
! 204:
! 205: bt->sec = ts->tv_sec;
! 206: /* 18446744073 = int(2^64 / 1000000000) */
! 207: bt->frac = (uint64_t)ts->tv_nsec * (uint64_t)18446744073ULL;
! 208: }
! 209:
! 210: static __inline void
! 211: bintime2timeval(struct bintime *bt, struct timeval *tv)
! 212: {
! 213:
! 214: tv->tv_sec = bt->sec;
! 215: tv->tv_usec = (long)(((uint64_t)1000000 * (uint32_t)(bt->frac >> 32)) >> 32);
! 216: }
! 217:
! 218: static __inline void
! 219: timeval2bintime(struct timeval *tv, struct bintime *bt)
! 220: {
! 221:
! 222: bt->sec = (time_t)tv->tv_sec;
! 223: /* 18446744073709 = int(2^64 / 1000000) */
! 224: bt->frac = (uint64_t)tv->tv_usec * (uint64_t)18446744073709ULL;
! 225: }
! 226:
! 227: /*
! 228: * Names of the interval timers, and structure
! 229: * defining a timer setting.
! 230: */
! 231: #define ITIMER_REAL 0
! 232: #define ITIMER_VIRTUAL 1
! 233: #define ITIMER_PROF 2
! 234:
! 235: struct itimerval {
! 236: struct timeval it_interval; /* timer interval */
! 237: struct timeval it_value; /* current value */
! 238: };
! 239:
! 240: /*
! 241: * Structure defined by POSIX 1003.1b to be like a itimerval,
! 242: * but with timespecs. Used in the timer_*() system calls.
! 243: */
! 244: struct itimerspec {
! 245: struct timespec it_interval; /* timer interval */
! 246: struct timespec it_value; /* timer expiration */
! 247: };
! 248:
! 249: /*
! 250: * Getkerninfo clock information structure
! 251: */
! 252: struct clockinfo {
! 253: int hz; /* clock frequency */
! 254: int tick; /* micro-seconds per hz tick */
! 255: int tickadj; /* clock skew rate for adjtime() */
! 256: int stathz; /* statistics clock frequency */
! 257: int profhz; /* profiling clock frequency */
! 258: };
! 259:
! 260: #define CLOCK_REALTIME 0
! 261: #define CLOCK_VIRTUAL 1
! 262: #define CLOCK_PROF 2
! 263: #define CLOCK_MONOTONIC 3
! 264:
! 265: #define TIMER_RELTIME 0x0 /* relative timer */
! 266: #define TIMER_ABSTIME 0x1 /* absolute timer */
! 267:
! 268: #if defined(_KERNEL) || defined(_STANDALONE)
! 269: extern volatile time_t time_second; /* Seconds since epoch, wall time. */
! 270: extern volatile time_t time_uptime; /* Seconds since reboot. */
! 271:
! 272: /*
! 273: * Functions for looking at our clock: [get]{bin,nano,micro}[up]time()
! 274: *
! 275: * Functions without the "get" prefix returns the best timestamp
! 276: * we can produce in the given format.
! 277: *
! 278: * "bin" == struct bintime == seconds + 64 bit fraction of seconds.
! 279: * "nano" == struct timespec == seconds + nanoseconds.
! 280: * "micro" == struct timeval == seconds + microseconds.
! 281: *
! 282: * Functions containing "up" returns time relative to boot and
! 283: * should be used for calculating time intervals.
! 284: *
! 285: * Functions without "up" returns GMT time.
! 286: *
! 287: * Functions with the "get" prefix returns a less precise result
! 288: * much faster than the functions without "get" prefix and should
! 289: * be used where a precision of 10 msec is acceptable or where
! 290: * performance is priority. (NB: "precision", _not_ "resolution" !)
! 291: */
! 292:
! 293: void bintime(struct bintime *);
! 294: void nanotime(struct timespec *);
! 295: void microtime(struct timeval *);
! 296:
! 297: void getnanotime(struct timespec *);
! 298: void getmicrotime(struct timeval *);
! 299:
! 300: void binuptime(struct bintime *);
! 301: void nanouptime(struct timespec *);
! 302: void microuptime(struct timeval *);
! 303:
! 304: void getnanouptime(struct timespec *);
! 305: void getmicrouptime(struct timeval *);
! 306:
! 307: int itimerfix(struct timeval *);
! 308: int itimerdecr(struct itimerval *itp, int usec);
! 309: int settime(struct timespec *);
! 310: int ratecheck(struct timeval *, const struct timeval *);
! 311: int ppsratecheck(struct timeval *, int *, int);
! 312:
! 313: /*
! 314: * "POSIX time" to/from "YY/MM/DD/hh/mm/ss"
! 315: */
! 316: struct clock_ymdhms {
! 317: u_short dt_year;
! 318: u_char dt_mon;
! 319: u_char dt_day;
! 320: u_char dt_wday; /* Day of week */
! 321: u_char dt_hour;
! 322: u_char dt_min;
! 323: u_char dt_sec;
! 324: };
! 325:
! 326: time_t clock_ymdhms_to_secs(struct clock_ymdhms *);
! 327: void clock_secs_to_ymdhms(time_t, struct clock_ymdhms *);
! 328: /*
! 329: * BCD to decimal and decimal to BCD.
! 330: */
! 331: #define FROMBCD(x) (((x) >> 4) * 10 + ((x) & 0xf))
! 332: #define TOBCD(x) (((x) / 10 * 16) + ((x) % 10))
! 333:
! 334: /* Some handy constants. */
! 335: #define SECDAY 86400L
! 336: #define SECYR (SECDAY * 365)
! 337:
! 338: /* Traditional POSIX base year */
! 339: #define POSIX_BASE_YEAR 1970
! 340:
! 341: #else /* !_KERNEL */
! 342: #include <time.h>
! 343:
! 344: #if __BSD_VISIBLE || __XPG_VISIBLE
! 345: __BEGIN_DECLS
! 346: #if __BSD_VISIBLE
! 347: int adjtime(const struct timeval *, struct timeval *);
! 348: int adjfreq(const int64_t *, int64_t *);
! 349: #endif
! 350: #if __XPG_VISIBLE
! 351: int clock_getres(clockid_t, struct timespec *);
! 352: int clock_gettime(clockid_t, struct timespec *);
! 353: int clock_settime(clockid_t, const struct timespec *);
! 354: int futimes(int, const struct timeval *);
! 355: int getitimer(int, struct itimerval *);
! 356: int gettimeofday(struct timeval *, struct timezone *);
! 357: int setitimer(int, const struct itimerval *, struct itimerval *);
! 358: int settimeofday(const struct timeval *, const struct timezone *);
! 359: int utimes(const char *, const struct timeval *);
! 360: #endif /* __XPG_VISIBLE */
! 361: __END_DECLS
! 362: #endif /* __BSD_VISIBLE || __XPG_VISIBLE */
! 363:
! 364: #endif /* !_KERNEL */
! 365:
! 366: #endif /* !_SYS_TIME_H_ */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to time.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / sys