Annotation of sys/kern/kern_time.c, Revision 1.1.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