| 0,0 → 1,791 |
|---|
| /*- |
| * Copyright (c) 1982, 1986, 1989, 1993 |
| * The Regents of the University of California. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 4. Neither the name of the University nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * |
| * @(#)kern_time.c 8.1 (Berkeley) 6/10/93 |
| */ |
| |
| #include <sys/cdefs.h> |
| __FBSDID("$FreeBSD: src/sys/kern/kern_time.c,v 1.116 2005/03/31 22:51:18 jhb Exp $"); |
| |
| #include "opt_mac.h" |
| |
| #include <sys/param.h> |
| #include <sys/systm.h> |
| #include <sys/lock.h> |
| #include <sys/mutex.h> |
| #include <sys/sysproto.h> |
| #include <sys/resourcevar.h> |
| #include <sys/signalvar.h> |
| #include <sys/jail.h> |
| #include <sys/kernel.h> |
| #include <sys/mac.h> |
| #include <sys/syscallsubr.h> |
| #include <sys/sysctl.h> |
| #include <sys/sysent.h> |
| #include <sys/proc.h> |
| #include <sys/time.h> |
| #include <sys/timetc.h> |
| #include <sys/vnode.h> |
| |
| #include <vm/vm.h> |
| #include <vm/vm_extern.h> |
| |
| int tz_minuteswest; |
| int tz_dsttime; |
| |
| /* |
| * Time of day and interval timer support. |
| * |
| * These routines provide the kernel entry points to get and set |
| * the time-of-day and per-process interval timers. Subroutines |
| * here provide support for adding and subtracting timeval structures |
| * and decrementing interval timers, optionally reloading the interval |
| * timers when they expire. |
| */ |
| |
| static int settime(struct thread *, struct timeval *); |
| static void timevalfix(struct timeval *); |
| static void no_lease_updatetime(int); |
| |
| static int cf_usersettime; |
| static int cf_jailsettime; |
| SYSCTL_INT(_kern, OID_AUTO, usersettime, CTLFLAG_RW, &cf_usersettime, 0, |
| "Non-root is allowed to change system time"); |
| SYSCTL_INT(_kern, OID_AUTO, jailsettime, CTLFLAG_RW, &cf_jailsettime, 0, |
| "System time is allowed to be changed from jail"); |
| |
| static void |
| no_lease_updatetime(deltat) |
| int deltat; |
| { |
| } |
| |
| void (*lease_updatetime)(int) = no_lease_updatetime; |
| |
| static int |
| settime(struct thread *td, struct timeval *tv) |
| { |
| struct timeval delta, tv1, tv2; |
| static struct timeval maxtime, laststep; |
| struct timespec ts; |
| int s; |
| |
| s = splclock(); |
| microtime(&tv1); |
| delta = *tv; |
| timevalsub(&delta, &tv1); |
| |
| /* |
| * If the system is secure, we do not allow the time to be |
| * set to a value earlier than 1 second less than the highest |
| * time we have yet seen. The worst a miscreant can do in |
| * this circumstance is "freeze" time. He couldn't go |
| * back to the past. |
| * |
| * We similarly do not allow the clock to be stepped more |
| * than one second, nor more than once per second. This allows |
| * a miscreant to make the clock march double-time, but no worse. |
| */ |
| if (securelevel_gt(td->td_ucred, 1) != 0) { |
| if (delta.tv_sec < 0 || delta.tv_usec < 0) { |
| /* |
| * Update maxtime to latest time we've seen. |
| */ |
| if (tv1.tv_sec > maxtime.tv_sec) |
| maxtime = tv1; |
| tv2 = *tv; |
| timevalsub(&tv2, &maxtime); |
| if (tv2.tv_sec < -1) { |
| tv->tv_sec = maxtime.tv_sec - 1; |
| printf("Time adjustment clamped to -1 second\n"); |
| } |
| } else { |
| if (tv1.tv_sec == laststep.tv_sec) { |
| splx(s); |
| return (EPERM); |
| } |
| if (delta.tv_sec > 1) { |
| tv->tv_sec = tv1.tv_sec + 1; |
| printf("Time adjustment clamped to +1 second\n"); |
| } |
| laststep = *tv; |
| } |
| } |
| |
| ts.tv_sec = tv->tv_sec; |
| ts.tv_nsec = tv->tv_usec * 1000; |
| mtx_lock(&Giant); |
| tc_setclock(&ts); |
| (void) splsoftclock(); |
| lease_updatetime(delta.tv_sec); |
| splx(s); |
| resettodr(); |
| mtx_unlock(&Giant); |
| return (0); |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct clock_gettime_args { |
| clockid_t clock_id; |
| struct timespec *tp; |
| }; |
| #endif |
| |
| /* |
| * MPSAFE |
| */ |
| /* ARGSUSED */ |
| int |
| clock_gettime(struct thread *td, struct clock_gettime_args *uap) |
| { |
| struct timespec ats; |
| struct timeval sys, user; |
| struct proc *p; |
| |
| p = td->td_proc; |
| switch (uap->clock_id) { |
| case CLOCK_REALTIME: |
| nanotime(&ats); |
| break; |
| case CLOCK_VIRTUAL: |
| PROC_LOCK(p); |
| calcru(p, &user, &sys); |
| PROC_UNLOCK(p); |
| TIMEVAL_TO_TIMESPEC(&user, &ats); |
| break; |
| case CLOCK_PROF: |
| PROC_LOCK(p); |
| calcru(p, &user, &sys); |
| PROC_UNLOCK(p); |
| timevaladd(&user, &sys); |
| TIMEVAL_TO_TIMESPEC(&user, &ats); |
| break; |
| case CLOCK_MONOTONIC: |
| nanouptime(&ats); |
| break; |
| default: |
| return (EINVAL); |
| } |
| return (copyout(&ats, uap->tp, sizeof(ats))); |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct clock_settime_args { |
| clockid_t clock_id; |
| const struct timespec *tp; |
| }; |
| #endif |
| |
| /* |
| * MPSAFE |
| */ |
| /* ARGSUSED */ |
| int |
| clock_settime(struct thread *td, struct clock_settime_args *uap) |
| { |
| struct timeval atv; |
| struct timespec ats; |
| int error; |
| |
| #ifdef MAC |
| error = mac_check_system_settime(td->td_ucred); |
| if (error) |
| return (error); |
| #endif |
| if (!cf_jailsettime && jailed(td->td_ucred)) |
| return (EPERM); |
| if (!cf_usersettime && (error = suser_cred(td->td_ucred, SUSER_ALLOWJAIL)) != 0) |
| return (error); /* jail is already checked */ |
| |
| if (uap->clock_id != CLOCK_REALTIME) |
| return (EINVAL); |
| if ((error = copyin(uap->tp, &ats, sizeof(ats))) != 0) |
| return (error); |
| if (ats.tv_nsec < 0 || ats.tv_nsec >= 1000000000) |
| return (EINVAL); |
| /* XXX Don't convert nsec->usec and back */ |
| TIMESPEC_TO_TIMEVAL(&atv, &ats); |
| error = settime(td, &atv); |
| return (error); |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct clock_getres_args { |
| clockid_t clock_id; |
| struct timespec *tp; |
| }; |
| #endif |
| |
| int |
| clock_getres(struct thread *td, struct clock_getres_args *uap) |
| { |
| struct timespec ts; |
| |
| ts.tv_sec = 0; |
| switch (uap->clock_id) { |
| case CLOCK_REALTIME: |
| case CLOCK_MONOTONIC: |
| /* |
| * Round up the result of the division cheaply by adding 1. |
| * Rounding up is especially important if rounding down |
| * would give 0. Perfect rounding is unimportant. |
| */ |
| ts.tv_nsec = 1000000000 / tc_getfrequency() + 1; |
| break; |
| case CLOCK_VIRTUAL: |
| case CLOCK_PROF: |
| /* Accurately round up here because we can do so cheaply. */ |
| ts.tv_nsec = (1000000000 + hz - 1) / hz; |
| break; |
| default: |
| return (EINVAL); |
| } |
| if (uap->tp == NULL) |
| return (0); |
| return (copyout(&ts, uap->tp, sizeof(ts))); |
| } |
| |
| static int nanowait; |
| |
| int |
| kern_nanosleep(struct thread *td, struct timespec *rqt, struct timespec *rmt) |
| { |
| struct timespec ts, ts2, ts3; |
| struct timeval tv; |
| int error; |
| |
| if (rqt->tv_nsec < 0 || rqt->tv_nsec >= 1000000000) |
| return (EINVAL); |
| if (rqt->tv_sec < 0 || (rqt->tv_sec == 0 && rqt->tv_nsec == 0)) |
| return (0); |
| getnanouptime(&ts); |
| timespecadd(&ts, rqt); |
| TIMESPEC_TO_TIMEVAL(&tv, rqt); |
| for (;;) { |
| error = tsleep(&nanowait, PWAIT | PCATCH, "nanslp", |
| tvtohz(&tv)); |
| getnanouptime(&ts2); |
| if (error != EWOULDBLOCK) { |
| if (error == ERESTART) |
| error = EINTR; |
| if (rmt != NULL) { |
| timespecsub(&ts, &ts2); |
| if (ts.tv_sec < 0) |
| timespecclear(&ts); |
| *rmt = ts; |
| } |
| return (error); |
| } |
| if (timespeccmp(&ts2, &ts, >=)) |
| return (0); |
| ts3 = ts; |
| timespecsub(&ts3, &ts2); |
| TIMESPEC_TO_TIMEVAL(&tv, &ts3); |
| } |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct nanosleep_args { |
| struct timespec *rqtp; |
| struct timespec *rmtp; |
| }; |
| #endif |
| |
| /* |
| * MPSAFE |
| */ |
| /* ARGSUSED */ |
| int |
| nanosleep(struct thread *td, struct nanosleep_args *uap) |
| { |
| struct timespec rmt, rqt; |
| int error; |
| |
| error = copyin(uap->rqtp, &rqt, sizeof(rqt)); |
| if (error) |
| return (error); |
| |
| if (uap->rmtp && |
| !useracc((caddr_t)uap->rmtp, sizeof(rmt), VM_PROT_WRITE)) |
| return (EFAULT); |
| error = kern_nanosleep(td, &rqt, &rmt); |
| if (error && uap->rmtp) { |
| int error2; |
| |
| error2 = copyout(&rmt, uap->rmtp, sizeof(rmt)); |
| if (error2) |
| error = error2; |
| } |
| return (error); |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct gettimeofday_args { |
| struct timeval *tp; |
| struct timezone *tzp; |
| }; |
| #endif |
| /* |
| * MPSAFE |
| */ |
| /* ARGSUSED */ |
| int |
| gettimeofday(struct thread *td, struct gettimeofday_args *uap) |
| { |
| struct timeval atv; |
| struct timezone rtz; |
| int error = 0; |
| |
| if (uap->tp) { |
| microtime(&atv); |
| error = copyout(&atv, uap->tp, sizeof (atv)); |
| } |
| if (error == 0 && uap->tzp != NULL) { |
| rtz.tz_minuteswest = tz_minuteswest; |
| rtz.tz_dsttime = tz_dsttime; |
| error = copyout(&rtz, uap->tzp, sizeof (rtz)); |
| } |
| return (error); |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct settimeofday_args { |
| struct timeval *tv; |
| struct timezone *tzp; |
| }; |
| #endif |
| /* |
| * MPSAFE |
| */ |
| /* ARGSUSED */ |
| int |
| settimeofday(struct thread *td, struct settimeofday_args *uap) |
| { |
| struct timeval atv, *tvp; |
| struct timezone atz, *tzp; |
| int error; |
| |
| if (uap->tv) { |
| error = copyin(uap->tv, &atv, sizeof(atv)); |
| if (error) |
| return (error); |
| tvp = &atv; |
| } else |
| tvp = NULL; |
| if (uap->tzp) { |
| error = copyin(uap->tzp, &atz, sizeof(atz)); |
| if (error) |
| return (error); |
| tzp = &atz; |
| } else |
| tzp = NULL; |
| return (kern_settimeofday(td, tvp, tzp)); |
| } |
| |
| int |
| kern_settimeofday(struct thread *td, struct timeval *tv, struct timezone *tzp) |
| { |
| int error = 0; |
| |
| #ifdef MAC |
| error = mac_check_system_settime(td->td_ucred); |
| if (error) |
| return (error); |
| #endif |
| if (!cf_jailsettime && jailed(td->td_ucred)) |
| return (EPERM); |
| if (!cf_usersettime && (error = suser_cred(td->td_ucred, SUSER_ALLOWJAIL)) != 0) |
| return (error); /* jail is already checked */ |
| |
| /* Verify all parameters before changing time. */ |
| if (tv) { |
| if (tv->tv_usec < 0 || tv->tv_usec >= 1000000) |
| return (EINVAL); |
| error = settime(td, tv); |
| } |
| if (tzp && error == 0) { |
| tz_minuteswest = tzp->tz_minuteswest; |
| tz_dsttime = tzp->tz_dsttime; |
| } |
| return (error); |
| } |
| |
| /* |
| * Get value of an interval timer. The process virtual and |
| * profiling virtual time timers are kept in the p_stats area, since |
| * they can be swapped out. These are kept internally in the |
| * way they are specified externally: in time until they expire. |
| * |
| * The real time interval timer is kept in the process table slot |
| * for the process, and its value (it_value) is kept as an |
| * absolute time rather than as a delta, so that it is easy to keep |
| * periodic real-time signals from drifting. |
| * |
| * Virtual time timers are processed in the hardclock() routine of |
| * kern_clock.c. The real time timer is processed by a timeout |
| * routine, called from the softclock() routine. Since a callout |
| * may be delayed in real time due to interrupt processing in the system, |
| * it is possible for the real time timeout routine (realitexpire, given below), |
| * to be delayed in real time past when it is supposed to occur. It |
| * does not suffice, therefore, to reload the real timer .it_value from the |
| * real time timers .it_interval. Rather, we compute the next time in |
| * absolute time the timer should go off. |
| */ |
| #ifndef _SYS_SYSPROTO_H_ |
| struct getitimer_args { |
| u_int which; |
| struct itimerval *itv; |
| }; |
| #endif |
| /* |
| * MPSAFE |
| */ |
| int |
| getitimer(struct thread *td, struct getitimer_args *uap) |
| { |
| struct itimerval aitv; |
| int error; |
| |
| error = kern_getitimer(td, uap->which, &aitv); |
| if (error != 0) |
| return (error); |
| return (copyout(&aitv, uap->itv, sizeof (struct itimerval))); |
| } |
| |
| int |
| kern_getitimer(struct thread *td, u_int which, struct itimerval *aitv) |
| { |
| struct proc *p = td->td_proc; |
| struct timeval ctv; |
| |
| if (which > ITIMER_PROF) |
| return (EINVAL); |
| |
| if (which == ITIMER_REAL) { |
| /* |
| * Convert from absolute to relative time in .it_value |
| * part of real time timer. If time for real time timer |
| * has passed return 0, else return difference between |
| * current time and time for the timer to go off. |
| */ |
| PROC_LOCK(p); |
| *aitv = p->p_realtimer; |
| PROC_UNLOCK(p); |
| if (timevalisset(&aitv->it_value)) { |
| getmicrouptime(&ctv); |
| if (timevalcmp(&aitv->it_value, &ctv, <)) |
| timevalclear(&aitv->it_value); |
| else |
| timevalsub(&aitv->it_value, &ctv); |
| } |
| } else { |
| mtx_lock_spin(&sched_lock); |
| *aitv = p->p_stats->p_timer[which]; |
| mtx_unlock_spin(&sched_lock); |
| } |
| return (0); |
| } |
| |
| #ifndef _SYS_SYSPROTO_H_ |
| struct setitimer_args { |
| u_int which; |
| struct itimerval *itv, *oitv; |
| }; |
| #endif |
| |
| /* |
| * MPSAFE |
| */ |
| int |
| setitimer(struct thread *td, struct setitimer_args *uap) |
| { |
| struct itimerval aitv, oitv; |
| int error; |
| |
| if (uap->itv == NULL) { |
| uap->itv = uap->oitv; |
| return (getitimer(td, (struct getitimer_args *)uap)); |
| } |
| |
| if ((error = copyin(uap->itv, &aitv, sizeof(struct itimerval)))) |
| return (error); |
| error = kern_setitimer(td, uap->which, &aitv, &oitv); |
| if (error != 0 || uap->oitv == NULL) |
| return (error); |
| return (copyout(&oitv, uap->oitv, sizeof(struct itimerval))); |
| } |
| |
| int |
| kern_setitimer(struct thread *td, u_int which, struct itimerval *aitv, |
| struct itimerval *oitv) |
| { |
| struct proc *p = td->td_proc; |
| struct timeval ctv; |
| |
| if (aitv == NULL) |
| return (kern_getitimer(td, which, oitv)); |
| |
| if (which > ITIMER_PROF) |
| return (EINVAL); |
| if (itimerfix(&aitv->it_value)) |
| return (EINVAL); |
| if (!timevalisset(&aitv->it_value)) |
| timevalclear(&aitv->it_interval); |
| else if (itimerfix(&aitv->it_interval)) |
| return (EINVAL); |
| |
| if (which == ITIMER_REAL) { |
| PROC_LOCK(p); |
| if (timevalisset(&p->p_realtimer.it_value)) |
| callout_stop(&p->p_itcallout); |
| getmicrouptime(&ctv); |
| if (timevalisset(&aitv->it_value)) { |
| callout_reset(&p->p_itcallout, tvtohz(&aitv->it_value), |
| realitexpire, p); |
| timevaladd(&aitv->it_value, &ctv); |
| } |
| *oitv = p->p_realtimer; |
| p->p_realtimer = *aitv; |
| PROC_UNLOCK(p); |
| if (timevalisset(&oitv->it_value)) { |
| if (timevalcmp(&oitv->it_value, &ctv, <)) |
| timevalclear(&oitv->it_value); |
| else |
| timevalsub(&oitv->it_value, &ctv); |
| } |
| } else { |
| mtx_lock_spin(&sched_lock); |
| *oitv = p->p_stats->p_timer[which]; |
| p->p_stats->p_timer[which] = *aitv; |
| mtx_unlock_spin(&sched_lock); |
| } |
| return (0); |
| } |
| |
| /* |
| * Real interval timer expired: |
| * send process whose timer expired an alarm signal. |
| * If time is not set up to reload, then just return. |
| * Else compute next time timer should go off which is > current time. |
| * This is where delay in processing this timeout causes multiple |
| * SIGALRM calls to be compressed into one. |
| * tvtohz() always adds 1 to allow for the time until the next clock |
| * interrupt being strictly less than 1 clock tick, but we don't want |
| * that here since we want to appear to be in sync with the clock |
| * interrupt even when we're delayed. |
| */ |
| void |
| realitexpire(void *arg) |
| { |
| struct proc *p; |
| struct timeval ctv, ntv; |
| |
| p = (struct proc *)arg; |
| PROC_LOCK(p); |
| psignal(p, SIGALRM); |
| if (!timevalisset(&p->p_realtimer.it_interval)) { |
| timevalclear(&p->p_realtimer.it_value); |
| if (p->p_flag & P_WEXIT) |
| wakeup(&p->p_itcallout); |
| PROC_UNLOCK(p); |
| return; |
| } |
| for (;;) { |
| timevaladd(&p->p_realtimer.it_value, |
| &p->p_realtimer.it_interval); |
| getmicrouptime(&ctv); |
| if (timevalcmp(&p->p_realtimer.it_value, &ctv, >)) { |
| ntv = p->p_realtimer.it_value; |
| timevalsub(&ntv, &ctv); |
| callout_reset(&p->p_itcallout, tvtohz(&ntv) - 1, |
| realitexpire, p); |
| PROC_UNLOCK(p); |
| return; |
| } |
| } |
| /*NOTREACHED*/ |
| } |
| |
| /* |
| * Check that a proposed value to load into the .it_value or |
| * .it_interval part of an interval timer is acceptable, and |
| * fix it to have at least minimal value (i.e. if it is less |
| * than the resolution of the clock, round it up.) |
| */ |
| int |
| itimerfix(struct timeval *tv) |
| { |
| |
| if (tv->tv_sec < 0 || tv->tv_sec > 100000000 || |
| tv->tv_usec < 0 || tv->tv_usec >= 1000000) |
| return (EINVAL); |
| if (tv->tv_sec == 0 && tv->tv_usec != 0 && tv->tv_usec < tick) |
| tv->tv_usec = tick; |
| return (0); |
| } |
| |
| /* |
| * Decrement an interval timer by a specified number |
| * of microseconds, which must be less than a second, |
| * i.e. < 1000000. If the timer expires, then reload |
| * it. In this case, carry over (usec - old value) to |
| * reduce the value reloaded into the timer so that |
| * the timer does not drift. This routine assumes |
| * that it is called in a context where the timers |
| * on which it is operating cannot change in value. |
| */ |
| int |
| itimerdecr(struct itimerval *itp, int usec) |
| { |
| |
| if (itp->it_value.tv_usec < usec) { |
| if (itp->it_value.tv_sec == 0) { |
| /* expired, and already in next interval */ |
| usec -= itp->it_value.tv_usec; |
| goto expire; |
| } |
| itp->it_value.tv_usec += 1000000; |
| itp->it_value.tv_sec--; |
| } |
| itp->it_value.tv_usec -= usec; |
| usec = 0; |
| if (timevalisset(&itp->it_value)) |
| return (1); |
| /* expired, exactly at end of interval */ |
| expire: |
| if (timevalisset(&itp->it_interval)) { |
| itp->it_value = itp->it_interval; |
| itp->it_value.tv_usec -= usec; |
| if (itp->it_value.tv_usec < 0) { |
| itp->it_value.tv_usec += 1000000; |
| itp->it_value.tv_sec--; |
| } |
| } else |
| itp->it_value.tv_usec = 0; /* sec is already 0 */ |
| return (0); |
| } |
| |
| /* |
| * Add and subtract routines for timevals. |
| * N.B.: subtract routine doesn't deal with |
| * results which are before the beginning, |
| * it just gets very confused in this case. |
| * Caveat emptor. |
| */ |
| void |
| timevaladd(struct timeval *t1, const struct timeval *t2) |
| { |
| |
| t1->tv_sec += t2->tv_sec; |
| t1->tv_usec += t2->tv_usec; |
| timevalfix(t1); |
| } |
| |
| void |
| timevalsub(struct timeval *t1, const struct timeval *t2) |
| { |
| |
| t1->tv_sec -= t2->tv_sec; |
| t1->tv_usec -= t2->tv_usec; |
| timevalfix(t1); |
| } |
| |
| static void |
| timevalfix(struct timeval *t1) |
| { |
| |
| if (t1->tv_usec < 0) { |
| t1->tv_sec--; |
| t1->tv_usec += 1000000; |
| } |
| if (t1->tv_usec >= 1000000) { |
| t1->tv_sec++; |
| t1->tv_usec -= 1000000; |
| } |
| } |
| |
| /* |
| * ratecheck(): simple time-based rate-limit checking. |
| */ |
| int |
| ratecheck(struct timeval *lasttime, const struct timeval *mininterval) |
| { |
| struct timeval tv, delta; |
| int rv = 0; |
| |
| getmicrouptime(&tv); /* NB: 10ms precision */ |
| delta = tv; |
| timevalsub(&delta, lasttime); |
| |
| /* |
| * check for 0,0 is so that the message will be seen at least once, |
| * even if interval is huge. |
| */ |
| if (timevalcmp(&delta, mininterval, >=) || |
| (lasttime->tv_sec == 0 && lasttime->tv_usec == 0)) { |
| *lasttime = tv; |
| rv = 1; |
| } |
| |
| return (rv); |
| } |
| |
| /* |
| * ppsratecheck(): packets (or events) per second limitation. |
| * |
| * Return 0 if the limit is to be enforced (e.g. the caller |
| * should drop a packet because of the rate limitation). |
| * |
| * maxpps of 0 always causes zero to be returned. maxpps of -1 |
| * always causes 1 to be returned; this effectively defeats rate |
| * limiting. |
| * |
| * Note that we maintain the struct timeval for compatibility |
| * with other bsd systems. We reuse the storage and just monitor |
| * clock ticks for minimal overhead. |
| */ |
| int |
| ppsratecheck(struct timeval *lasttime, int *curpps, int maxpps) |
| { |
| int now; |
| |
| /* |
| * Reset the last time and counter if this is the first call |
| * or more than a second has passed since the last update of |
| * lasttime. |
| */ |
| now = ticks; |
| if (lasttime->tv_sec == 0 || (u_int)(now - lasttime->tv_sec) >= hz) { |
| lasttime->tv_sec = now; |
| *curpps = 1; |
| return (maxpps != 0); |
| } else { |
| (*curpps)++; /* NB: ignore potential overflow */ |
| return (maxpps < 0 || *curpps < maxpps); |
| } |
| } |