2 * Copyright (c) 1982, 1986, 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * @(#)kern_time.c 8.1 (Berkeley) 6/10/93
34 * $FreeBSD: src/sys/kern/kern_time.c,v 1.68.2.1 2002/10/01 08:00:41 bde Exp $
35 * $DragonFly: src/sys/kern/kern_time.c,v 1.40 2008/04/02 14:16:16 sephe Exp $
38 #include <sys/param.h>
39 #include <sys/systm.h>
41 #include <sys/sysproto.h>
42 #include <sys/resourcevar.h>
43 #include <sys/signalvar.h>
44 #include <sys/kernel.h>
45 #include <sys/systm.h>
46 #include <sys/sysent.h>
47 #include <sys/sysunion.h>
51 #include <sys/vnode.h>
52 #include <sys/sysctl.h>
54 #include <vm/vm_extern.h>
55 #include <sys/msgport2.h>
56 #include <sys/thread2.h>
61 * Time of day and interval timer support.
63 * These routines provide the kernel entry points to get and set
64 * the time-of-day and per-process interval timers. Subroutines
65 * here provide support for adding and subtracting timeval structures
66 * and decrementing interval timers, optionally reloading the interval
67 * timers when they expire.
70 static int nanosleep1 (struct timespec
*rqt
,
71 struct timespec
*rmt
);
72 static int settime (struct timeval
*);
73 static void timevalfix (struct timeval
*);
75 static int sleep_hard_us
= 100;
76 SYSCTL_INT(_kern
, OID_AUTO
, sleep_hard_us
, CTLFLAG_RW
, &sleep_hard_us
, 0, "")
79 settime(struct timeval
*tv
)
81 struct timeval delta
, tv1
, tv2
;
82 static struct timeval maxtime
, laststep
;
86 if ((origcpu
= mycpu
->gd_cpuid
) != 0)
87 lwkt_setcpu_self(globaldata_find(0));
92 timevalsub(&delta
, &tv1
);
95 * If the system is secure, we do not allow the time to be
96 * set to a value earlier than 1 second less than the highest
97 * time we have yet seen. The worst a miscreant can do in
98 * this circumstance is "freeze" time. He couldn't go
101 * We similarly do not allow the clock to be stepped more
102 * than one second, nor more than once per second. This allows
103 * a miscreant to make the clock march double-time, but no worse.
105 if (securelevel
> 1) {
106 if (delta
.tv_sec
< 0 || delta
.tv_usec
< 0) {
108 * Update maxtime to latest time we've seen.
110 if (tv1
.tv_sec
> maxtime
.tv_sec
)
113 timevalsub(&tv2
, &maxtime
);
114 if (tv2
.tv_sec
< -1) {
115 tv
->tv_sec
= maxtime
.tv_sec
- 1;
116 kprintf("Time adjustment clamped to -1 second\n");
119 if (tv1
.tv_sec
== laststep
.tv_sec
) {
123 if (delta
.tv_sec
> 1) {
124 tv
->tv_sec
= tv1
.tv_sec
+ 1;
125 kprintf("Time adjustment clamped to +1 second\n");
131 ts
.tv_sec
= tv
->tv_sec
;
132 ts
.tv_nsec
= tv
->tv_usec
* 1000;
137 lwkt_setcpu_self(globaldata_find(origcpu
));
145 sys_clock_gettime(struct clock_gettime_args
*uap
)
149 switch(uap
->clock_id
) {
152 return (copyout(&ats
, uap
->tp
, sizeof(ats
)));
153 case CLOCK_MONOTONIC
:
155 return (copyout(&ats
, uap
->tp
, sizeof(ats
)));
163 sys_clock_settime(struct clock_settime_args
*uap
)
165 struct thread
*td
= curthread
;
170 if ((error
= priv_check(td
, PRIV_ROOT
)) != 0)
172 switch(uap
->clock_id
) {
174 if ((error
= copyin(uap
->tp
, &ats
, sizeof(ats
))) != 0)
176 if (ats
.tv_nsec
< 0 || ats
.tv_nsec
>= 1000000000)
178 /* XXX Don't convert nsec->usec and back */
179 TIMESPEC_TO_TIMEVAL(&atv
, &ats
);
180 error
= settime(&atv
);
188 sys_clock_getres(struct clock_getres_args
*uap
)
192 switch(uap
->clock_id
) {
194 case CLOCK_MONOTONIC
:
196 * Round up the result of the division cheaply
197 * by adding 1. Rounding up is especially important
198 * if rounding down would give 0. Perfect rounding
202 ts
.tv_nsec
= 1000000000 / sys_cputimer
->freq
+ 1;
203 return(copyout(&ts
, uap
->tp
, sizeof(ts
)));
212 * This is a general helper function for nanosleep() (aka sleep() aka
215 * If there is less then one tick's worth of time left and
216 * we haven't done a yield, or the remaining microseconds is
217 * ridiculously low, do a yield. This avoids having
218 * to deal with systimer overheads when the system is under
219 * heavy loads. If we have done a yield already then use
220 * a systimer and an uninterruptable thread wait.
222 * If there is more then a tick's worth of time left,
223 * calculate the baseline ticks and use an interruptable
224 * tsleep, then handle the fine-grained delay on the next
225 * loop. This usually results in two sleeps occuring, a long one
229 ns1_systimer(systimer_t info
)
231 lwkt_schedule(info
->data
);
235 nanosleep1(struct timespec
*rqt
, struct timespec
*rmt
)
238 struct timespec ts
, ts2
, ts3
;
243 if (rqt
->tv_nsec
< 0 || rqt
->tv_nsec
>= 1000000000)
245 if (rqt
->tv_sec
< 0 || (rqt
->tv_sec
== 0 && rqt
->tv_nsec
== 0))
248 timespecadd(&ts
, rqt
); /* ts = target timestamp compare */
249 TIMESPEC_TO_TIMEVAL(&tv
, rqt
); /* tv = sleep interval */
254 struct systimer info
;
256 ticks
= tv
.tv_usec
/ tick
; /* approximate */
258 if (tv
.tv_sec
== 0 && ticks
== 0) {
259 thread_t td
= curthread
;
260 if (tried_yield
|| tv
.tv_usec
< sleep_hard_us
) {
264 crit_enter_quick(td
);
265 systimer_init_oneshot(&info
, ns1_systimer
,
267 lwkt_deschedule_self(td
);
270 systimer_del(&info
); /* make sure it's gone */
272 error
= iscaught(td
->td_lwp
);
273 } else if (tv
.tv_sec
== 0) {
274 error
= tsleep(&nanowait
, PCATCH
, "nanslp", ticks
);
276 ticks
= tvtohz_low(&tv
); /* also handles overflow */
277 error
= tsleep(&nanowait
, PCATCH
, "nanslp", ticks
);
280 if (error
&& error
!= EWOULDBLOCK
) {
281 if (error
== ERESTART
)
284 timespecsub(&ts
, &ts2
);
291 if (timespeccmp(&ts2
, &ts
, >=))
294 timespecsub(&ts3
, &ts2
);
295 TIMESPEC_TO_TIMEVAL(&tv
, &ts3
);
301 sys_nanosleep(struct nanosleep_args
*uap
)
307 error
= copyin(uap
->rqtp
, &rqt
, sizeof(rqt
));
311 error
= nanosleep1(&rqt
, &rmt
);
314 * copyout the residual if nanosleep was interrupted.
316 if (error
&& uap
->rmtp
)
317 error
= copyout(&rmt
, uap
->rmtp
, sizeof(rmt
));
323 sys_gettimeofday(struct gettimeofday_args
*uap
)
330 if ((error
= copyout((caddr_t
)&atv
, (caddr_t
)uap
->tp
,
335 error
= copyout((caddr_t
)&tz
, (caddr_t
)uap
->tzp
,
342 sys_settimeofday(struct settimeofday_args
*uap
)
344 struct thread
*td
= curthread
;
349 if ((error
= priv_check(td
, PRIV_ROOT
)))
351 /* Verify all parameters before changing time. */
353 if ((error
= copyin((caddr_t
)uap
->tv
, (caddr_t
)&atv
,
356 if (atv
.tv_usec
< 0 || atv
.tv_usec
>= 1000000)
360 (error
= copyin((caddr_t
)uap
->tzp
, (caddr_t
)&atz
, sizeof(atz
))))
362 if (uap
->tv
&& (error
= settime(&atv
)))
370 kern_adjtime_common(void)
372 if ((ntp_delta
>= 0 && ntp_delta
< ntp_default_tick_delta
) ||
373 (ntp_delta
< 0 && ntp_delta
> -ntp_default_tick_delta
))
374 ntp_tick_delta
= ntp_delta
;
375 else if (ntp_delta
> ntp_big_delta
)
376 ntp_tick_delta
= 10 * ntp_default_tick_delta
;
377 else if (ntp_delta
< -ntp_big_delta
)
378 ntp_tick_delta
= -10 * ntp_default_tick_delta
;
379 else if (ntp_delta
> 0)
380 ntp_tick_delta
= ntp_default_tick_delta
;
382 ntp_tick_delta
= -ntp_default_tick_delta
;
386 kern_adjtime(int64_t delta
, int64_t *odelta
)
390 if ((origcpu
= mycpu
->gd_cpuid
) != 0)
391 lwkt_setcpu_self(globaldata_find(0));
396 kern_adjtime_common();
400 lwkt_setcpu_self(globaldata_find(origcpu
));
404 kern_get_ntp_delta(int64_t *delta
)
408 if ((origcpu
= mycpu
->gd_cpuid
) != 0)
409 lwkt_setcpu_self(globaldata_find(0));
416 lwkt_setcpu_self(globaldata_find(origcpu
));
420 kern_reladjtime(int64_t delta
)
424 if ((origcpu
= mycpu
->gd_cpuid
) != 0)
425 lwkt_setcpu_self(globaldata_find(0));
429 kern_adjtime_common();
433 lwkt_setcpu_self(globaldata_find(origcpu
));
437 kern_adjfreq(int64_t rate
)
441 if ((origcpu
= mycpu
->gd_cpuid
) != 0)
442 lwkt_setcpu_self(globaldata_find(0));
445 ntp_tick_permanent
= rate
;
449 lwkt_setcpu_self(globaldata_find(origcpu
));
454 sys_adjtime(struct adjtime_args
*uap
)
456 struct thread
*td
= curthread
;
458 int64_t ndelta
, odelta
;
461 if ((error
= priv_check(td
, PRIV_ROOT
)))
464 copyin((caddr_t
)uap
->delta
, (caddr_t
)&atv
, sizeof(struct timeval
))))
468 * Compute the total correction and the rate at which to apply it.
469 * Round the adjustment down to a whole multiple of the per-tick
470 * delta, so that after some number of incremental changes in
471 * hardclock(), tickdelta will become zero, lest the correction
472 * overshoot and start taking us away from the desired final time.
474 ndelta
= (int64_t)atv
.tv_sec
* 1000000000 + atv
.tv_usec
* 1000;
475 kern_adjtime(ndelta
, &odelta
);
478 atv
.tv_sec
= odelta
/ 1000000000;
479 atv
.tv_usec
= odelta
% 1000000000 / 1000;
480 (void) copyout((caddr_t
)&atv
, (caddr_t
)uap
->olddelta
,
481 sizeof(struct timeval
));
487 sysctl_adjtime(SYSCTL_HANDLER_ARGS
)
492 if (req
->newptr
!= NULL
) {
493 if (priv_check(curthread
, PRIV_ROOT
))
495 error
= SYSCTL_IN(req
, &delta
, sizeof(delta
));
498 kern_reladjtime(delta
);
502 kern_get_ntp_delta(&delta
);
503 error
= SYSCTL_OUT(req
, &delta
, sizeof(delta
));
508 * delta is in nanoseconds.
511 sysctl_delta(SYSCTL_HANDLER_ARGS
)
513 int64_t delta
, old_delta
;
516 if (req
->newptr
!= NULL
) {
517 if (priv_check(curthread
, PRIV_ROOT
))
519 error
= SYSCTL_IN(req
, &delta
, sizeof(delta
));
522 kern_adjtime(delta
, &old_delta
);
525 if (req
->oldptr
!= NULL
)
526 kern_get_ntp_delta(&old_delta
);
527 error
= SYSCTL_OUT(req
, &old_delta
, sizeof(old_delta
));
532 * frequency is in nanoseconds per second shifted left 32.
533 * kern_adjfreq() needs it in nanoseconds per tick shifted left 32.
536 sysctl_adjfreq(SYSCTL_HANDLER_ARGS
)
541 if (req
->newptr
!= NULL
) {
542 if (priv_check(curthread
, PRIV_ROOT
))
544 error
= SYSCTL_IN(req
, &freqdelta
, sizeof(freqdelta
));
549 kern_adjfreq(freqdelta
);
552 if (req
->oldptr
!= NULL
)
553 freqdelta
= ntp_tick_permanent
* hz
;
554 error
= SYSCTL_OUT(req
, &freqdelta
, sizeof(freqdelta
));
561 SYSCTL_NODE(_kern
, OID_AUTO
, ntp
, CTLFLAG_RW
, 0, "NTP related controls");
562 SYSCTL_PROC(_kern_ntp
, OID_AUTO
, permanent
,
563 CTLTYPE_QUAD
|CTLFLAG_RW
, 0, 0,
564 sysctl_adjfreq
, "Q", "permanent correction per second");
565 SYSCTL_PROC(_kern_ntp
, OID_AUTO
, delta
,
566 CTLTYPE_QUAD
|CTLFLAG_RW
, 0, 0,
567 sysctl_delta
, "Q", "one-time delta");
568 SYSCTL_OPAQUE(_kern_ntp
, OID_AUTO
, big_delta
, CTLFLAG_RD
,
569 &ntp_big_delta
, sizeof(ntp_big_delta
), "Q",
570 "threshold for fast adjustment");
571 SYSCTL_OPAQUE(_kern_ntp
, OID_AUTO
, tick_delta
, CTLFLAG_RD
,
572 &ntp_tick_delta
, sizeof(ntp_tick_delta
), "LU",
573 "per-tick adjustment");
574 SYSCTL_OPAQUE(_kern_ntp
, OID_AUTO
, default_tick_delta
, CTLFLAG_RD
,
575 &ntp_default_tick_delta
, sizeof(ntp_default_tick_delta
), "LU",
576 "default per-tick adjustment");
577 SYSCTL_OPAQUE(_kern_ntp
, OID_AUTO
, next_leap_second
, CTLFLAG_RW
,
578 &ntp_leap_second
, sizeof(ntp_leap_second
), "LU",
580 SYSCTL_INT(_kern_ntp
, OID_AUTO
, insert_leap_second
, CTLFLAG_RW
,
581 &ntp_leap_insert
, 0, "insert or remove leap second");
582 SYSCTL_PROC(_kern_ntp
, OID_AUTO
, adjust
,
583 CTLTYPE_QUAD
|CTLFLAG_RW
, 0, 0,
584 sysctl_adjtime
, "Q", "relative adjust for delta");
587 * Get value of an interval timer. The process virtual and
588 * profiling virtual time timers are kept in the p_stats area, since
589 * they can be swapped out. These are kept internally in the
590 * way they are specified externally: in time until they expire.
592 * The real time interval timer is kept in the process table slot
593 * for the process, and its value (it_value) is kept as an
594 * absolute time rather than as a delta, so that it is easy to keep
595 * periodic real-time signals from drifting.
597 * Virtual time timers are processed in the hardclock() routine of
598 * kern_clock.c. The real time timer is processed by a timeout
599 * routine, called from the softclock() routine. Since a callout
600 * may be delayed in real time due to interrupt processing in the system,
601 * it is possible for the real time timeout routine (realitexpire, given below),
602 * to be delayed in real time past when it is supposed to occur. It
603 * does not suffice, therefore, to reload the real timer .it_value from the
604 * real time timers .it_interval. Rather, we compute the next time in
605 * absolute time the timer should go off.
609 sys_getitimer(struct getitimer_args
*uap
)
611 struct proc
*p
= curproc
;
613 struct itimerval aitv
;
615 if (uap
->which
> ITIMER_PROF
)
618 if (uap
->which
== ITIMER_REAL
) {
620 * Convert from absolute to relative time in .it_value
621 * part of real time timer. If time for real time timer
622 * has passed return 0, else return difference between
623 * current time and time for the timer to go off.
625 aitv
= p
->p_realtimer
;
626 if (timevalisset(&aitv
.it_value
)) {
627 getmicrouptime(&ctv
);
628 if (timevalcmp(&aitv
.it_value
, &ctv
, <))
629 timevalclear(&aitv
.it_value
);
631 timevalsub(&aitv
.it_value
, &ctv
);
634 aitv
= p
->p_timer
[uap
->which
];
637 return (copyout((caddr_t
)&aitv
, (caddr_t
)uap
->itv
,
638 sizeof (struct itimerval
)));
643 sys_setitimer(struct setitimer_args
*uap
)
645 struct itimerval aitv
;
647 struct itimerval
*itvp
;
648 struct proc
*p
= curproc
;
651 if (uap
->which
> ITIMER_PROF
)
654 if (itvp
&& (error
= copyin((caddr_t
)itvp
, (caddr_t
)&aitv
,
655 sizeof(struct itimerval
))))
657 if ((uap
->itv
= uap
->oitv
) &&
658 (error
= sys_getitimer((struct getitimer_args
*)uap
)))
662 if (itimerfix(&aitv
.it_value
))
664 if (!timevalisset(&aitv
.it_value
))
665 timevalclear(&aitv
.it_interval
);
666 else if (itimerfix(&aitv
.it_interval
))
669 if (uap
->which
== ITIMER_REAL
) {
670 if (timevalisset(&p
->p_realtimer
.it_value
))
671 callout_stop(&p
->p_ithandle
);
672 if (timevalisset(&aitv
.it_value
))
673 callout_reset(&p
->p_ithandle
,
674 tvtohz_high(&aitv
.it_value
), realitexpire
, p
);
675 getmicrouptime(&ctv
);
676 timevaladd(&aitv
.it_value
, &ctv
);
677 p
->p_realtimer
= aitv
;
679 p
->p_timer
[uap
->which
] = aitv
;
686 * Real interval timer expired:
687 * send process whose timer expired an alarm signal.
688 * If time is not set up to reload, then just return.
689 * Else compute next time timer should go off which is > current time.
690 * This is where delay in processing this timeout causes multiple
691 * SIGALRM calls to be compressed into one.
692 * tvtohz_high() always adds 1 to allow for the time until the next clock
693 * interrupt being strictly less than 1 clock tick, but we don't want
694 * that here since we want to appear to be in sync with the clock
695 * interrupt even when we're delayed.
698 realitexpire(void *arg
)
701 struct timeval ctv
, ntv
;
703 p
= (struct proc
*)arg
;
705 if (!timevalisset(&p
->p_realtimer
.it_interval
)) {
706 timevalclear(&p
->p_realtimer
.it_value
);
711 timevaladd(&p
->p_realtimer
.it_value
,
712 &p
->p_realtimer
.it_interval
);
713 getmicrouptime(&ctv
);
714 if (timevalcmp(&p
->p_realtimer
.it_value
, &ctv
, >)) {
715 ntv
= p
->p_realtimer
.it_value
;
716 timevalsub(&ntv
, &ctv
);
717 callout_reset(&p
->p_ithandle
, tvtohz_low(&ntv
),
727 * Check that a proposed value to load into the .it_value or
728 * .it_interval part of an interval timer is acceptable, and
729 * fix it to have at least minimal value (i.e. if it is less
730 * than the resolution of the clock, round it up.)
733 itimerfix(struct timeval
*tv
)
736 if (tv
->tv_sec
< 0 || tv
->tv_sec
> 100000000 ||
737 tv
->tv_usec
< 0 || tv
->tv_usec
>= 1000000)
739 if (tv
->tv_sec
== 0 && tv
->tv_usec
!= 0 && tv
->tv_usec
< tick
)
745 * Decrement an interval timer by a specified number
746 * of microseconds, which must be less than a second,
747 * i.e. < 1000000. If the timer expires, then reload
748 * it. In this case, carry over (usec - old value) to
749 * reduce the value reloaded into the timer so that
750 * the timer does not drift. This routine assumes
751 * that it is called in a context where the timers
752 * on which it is operating cannot change in value.
755 itimerdecr(struct itimerval
*itp
, int usec
)
758 if (itp
->it_value
.tv_usec
< usec
) {
759 if (itp
->it_value
.tv_sec
== 0) {
760 /* expired, and already in next interval */
761 usec
-= itp
->it_value
.tv_usec
;
764 itp
->it_value
.tv_usec
+= 1000000;
765 itp
->it_value
.tv_sec
--;
767 itp
->it_value
.tv_usec
-= usec
;
769 if (timevalisset(&itp
->it_value
))
771 /* expired, exactly at end of interval */
773 if (timevalisset(&itp
->it_interval
)) {
774 itp
->it_value
= itp
->it_interval
;
775 itp
->it_value
.tv_usec
-= usec
;
776 if (itp
->it_value
.tv_usec
< 0) {
777 itp
->it_value
.tv_usec
+= 1000000;
778 itp
->it_value
.tv_sec
--;
781 itp
->it_value
.tv_usec
= 0; /* sec is already 0 */
786 * Add and subtract routines for timevals.
787 * N.B.: subtract routine doesn't deal with
788 * results which are before the beginning,
789 * it just gets very confused in this case.
793 timevaladd(struct timeval
*t1
, const struct timeval
*t2
)
796 t1
->tv_sec
+= t2
->tv_sec
;
797 t1
->tv_usec
+= t2
->tv_usec
;
802 timevalsub(struct timeval
*t1
, const struct timeval
*t2
)
805 t1
->tv_sec
-= t2
->tv_sec
;
806 t1
->tv_usec
-= t2
->tv_usec
;
811 timevalfix(struct timeval
*t1
)
814 if (t1
->tv_usec
< 0) {
816 t1
->tv_usec
+= 1000000;
818 if (t1
->tv_usec
>= 1000000) {
820 t1
->tv_usec
-= 1000000;
825 * ratecheck(): simple time-based rate-limit checking.
828 ratecheck(struct timeval
*lasttime
, const struct timeval
*mininterval
)
830 struct timeval tv
, delta
;
833 getmicrouptime(&tv
); /* NB: 10ms precision */
835 timevalsub(&delta
, lasttime
);
838 * check for 0,0 is so that the message will be seen at least once,
839 * even if interval is huge.
841 if (timevalcmp(&delta
, mininterval
, >=) ||
842 (lasttime
->tv_sec
== 0 && lasttime
->tv_usec
== 0)) {
851 * ppsratecheck(): packets (or events) per second limitation.
853 * Return 0 if the limit is to be enforced (e.g. the caller
854 * should drop a packet because of the rate limitation).
856 * maxpps of 0 always causes zero to be returned. maxpps of -1
857 * always causes 1 to be returned; this effectively defeats rate
860 * Note that we maintain the struct timeval for compatibility
861 * with other bsd systems. We reuse the storage and just monitor
862 * clock ticks for minimal overhead.
865 ppsratecheck(struct timeval
*lasttime
, int *curpps
, int maxpps
)
870 * Reset the last time and counter if this is the first call
871 * or more than a second has passed since the last update of
875 if (lasttime
->tv_sec
== 0 || (u_int
)(now
- lasttime
->tv_sec
) >= hz
) {
876 lasttime
->tv_sec
= now
;
878 return (maxpps
!= 0);
880 (*curpps
)++; /* NB: ignore potential overflow */
881 return (maxpps
< 0 || *curpps
< maxpps
);