Home | History | Annotate | Line # | Download | only in kern
kern_time.c revision 1.131
      1  1.131        ad /*	$NetBSD: kern_time.c,v 1.131 2007/11/15 20:12:04 ad Exp $	*/
      2   1.42       cgd 
      3   1.42       cgd /*-
      4  1.131        ad  * Copyright (c) 2000, 2004, 2005, 2007 The NetBSD Foundation, Inc.
      5   1.42       cgd  * All rights reserved.
      6   1.42       cgd  *
      7   1.42       cgd  * This code is derived from software contributed to The NetBSD Foundation
      8   1.42       cgd  * by Christopher G. Demetriou.
      9   1.42       cgd  *
     10   1.42       cgd  * Redistribution and use in source and binary forms, with or without
     11   1.42       cgd  * modification, are permitted provided that the following conditions
     12   1.42       cgd  * are met:
     13   1.42       cgd  * 1. Redistributions of source code must retain the above copyright
     14   1.42       cgd  *    notice, this list of conditions and the following disclaimer.
     15   1.42       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.42       cgd  *    notice, this list of conditions and the following disclaimer in the
     17   1.42       cgd  *    documentation and/or other materials provided with the distribution.
     18   1.42       cgd  * 3. All advertising materials mentioning features or use of this software
     19   1.42       cgd  *    must display the following acknowledgement:
     20   1.42       cgd  *	This product includes software developed by the NetBSD
     21   1.42       cgd  *	Foundation, Inc. and its contributors.
     22   1.42       cgd  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23   1.42       cgd  *    contributors may be used to endorse or promote products derived
     24   1.42       cgd  *    from this software without specific prior written permission.
     25   1.42       cgd  *
     26   1.42       cgd  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27   1.42       cgd  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28   1.42       cgd  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29   1.42       cgd  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30   1.42       cgd  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31   1.42       cgd  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32   1.42       cgd  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33   1.42       cgd  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34   1.42       cgd  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35   1.42       cgd  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36   1.42       cgd  * POSSIBILITY OF SUCH DAMAGE.
     37   1.42       cgd  */
     38    1.9       cgd 
     39    1.1       cgd /*
     40    1.8       cgd  * Copyright (c) 1982, 1986, 1989, 1993
     41    1.8       cgd  *	The Regents of the University of California.  All rights reserved.
     42    1.1       cgd  *
     43    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     44    1.1       cgd  * modification, are permitted provided that the following conditions
     45    1.1       cgd  * are met:
     46    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     47    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     48    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     49    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     50    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     51   1.72       agc  * 3. Neither the name of the University nor the names of its contributors
     52    1.1       cgd  *    may be used to endorse or promote products derived from this software
     53    1.1       cgd  *    without specific prior written permission.
     54    1.1       cgd  *
     55    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     56    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     57    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     58    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     59    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     60    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     61    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     62    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     63    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     64    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     65    1.1       cgd  * SUCH DAMAGE.
     66    1.1       cgd  *
     67   1.33      fvdl  *	@(#)kern_time.c	8.4 (Berkeley) 5/26/95
     68    1.1       cgd  */
     69   1.58     lukem 
     70   1.58     lukem #include <sys/cdefs.h>
     71  1.131        ad __KERNEL_RCSID(0, "$NetBSD: kern_time.c,v 1.131 2007/11/15 20:12:04 ad Exp $");
     72    1.1       cgd 
     73    1.5   mycroft #include <sys/param.h>
     74    1.5   mycroft #include <sys/resourcevar.h>
     75    1.5   mycroft #include <sys/kernel.h>
     76    1.8       cgd #include <sys/systm.h>
     77    1.5   mycroft #include <sys/proc.h>
     78    1.8       cgd #include <sys/vnode.h>
     79   1.17  christos #include <sys/signalvar.h>
     80   1.25     perry #include <sys/syslog.h>
     81  1.101    kardel #include <sys/timetc.h>
     82  1.122       dsl #ifndef __HAVE_TIMECOUNTER
     83   1.95      cube #include <sys/timevar.h>
     84  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
     85   1.99      elad #include <sys/kauth.h>
     86    1.1       cgd 
     87   1.11       cgd #include <sys/mount.h>
     88   1.11       cgd #include <sys/syscallargs.h>
     89   1.19  christos 
     90   1.37   thorpej #include <uvm/uvm_extern.h>
     91   1.37   thorpej 
     92  1.130        ad #include <sys/cpu.h>
     93   1.23       cgd 
     94  1.131        ad kmutex_t	time_lock;
     95  1.131        ad 
     96   1.97    simonb POOL_INIT(ptimer_pool, sizeof(struct ptimer), 0, 0, 0, "ptimerpl",
     97  1.118        ad     &pool_allocator_nointr, IPL_NONE);
     98   1.97    simonb POOL_INIT(ptimers_pool, sizeof(struct ptimers), 0, 0, 0, "ptimerspl",
     99  1.118        ad     &pool_allocator_nointr, IPL_NONE);
    100   1.97    simonb 
    101  1.131        ad /*
    102  1.131        ad  * Initialize timekeeping.
    103  1.131        ad  */
    104  1.131        ad void
    105  1.131        ad time_init(void)
    106  1.131        ad {
    107  1.131        ad 
    108  1.131        ad 	mutex_init(&time_lock, MUTEX_DEFAULT, IPL_NONE);
    109  1.131        ad }
    110  1.131        ad 
    111   1.63   thorpej /* Time of day and interval timer support.
    112    1.1       cgd  *
    113    1.1       cgd  * These routines provide the kernel entry points to get and set
    114    1.1       cgd  * the time-of-day and per-process interval timers.  Subroutines
    115    1.1       cgd  * here provide support for adding and subtracting timeval structures
    116    1.1       cgd  * and decrementing interval timers, optionally reloading the interval
    117    1.1       cgd  * timers when they expire.
    118    1.1       cgd  */
    119    1.1       cgd 
    120   1.22       jtc /* This function is used by clock_settime and settimeofday */
    121   1.39      tron int
    122   1.98  christos settime(struct proc *p, struct timespec *ts)
    123   1.22       jtc {
    124   1.98  christos 	struct timeval delta, tv;
    125  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    126  1.101    kardel 	struct timeval now;
    127  1.101    kardel 	struct timespec ts1;
    128  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    129  1.129        ad 	lwp_t *l;
    130  1.129        ad 	int s;
    131   1.22       jtc 
    132   1.98  christos 	/*
    133   1.98  christos 	 * Don't allow the time to be set forward so far it will wrap
    134   1.98  christos 	 * and become negative, thus allowing an attacker to bypass
    135   1.98  christos 	 * the next check below.  The cutoff is 1 year before rollover
    136   1.98  christos 	 * occurs, so even if the attacker uses adjtime(2) to move
    137   1.98  christos 	 * the time past the cutoff, it will take a very long time
    138   1.98  christos 	 * to get to the wrap point.
    139   1.98  christos 	 *
    140   1.98  christos 	 * XXX: we check against INT_MAX since on 64-bit
    141   1.98  christos 	 *	platforms, sizeof(int) != sizeof(long) and
    142   1.98  christos 	 *	time_t is 32 bits even when atv.tv_sec is 64 bits.
    143   1.98  christos 	 */
    144   1.98  christos 	if (ts->tv_sec > INT_MAX - 365*24*60*60) {
    145  1.113        ad 		struct proc *pp;
    146  1.113        ad 
    147  1.117        ad 		mutex_enter(&proclist_lock);
    148  1.113        ad 		pp = p->p_pptr;
    149  1.113        ad 		mutex_enter(&pp->p_mutex);
    150   1.98  christos 		log(LOG_WARNING, "pid %d (%s) "
    151   1.98  christos 		    "invoked by uid %d ppid %d (%s) "
    152   1.98  christos 		    "tried to set clock forward to %ld\n",
    153   1.99      elad 		    p->p_pid, p->p_comm, kauth_cred_geteuid(pp->p_cred),
    154   1.98  christos 		    pp->p_pid, pp->p_comm, (long)ts->tv_sec);
    155  1.113        ad 		mutex_exit(&pp->p_mutex);
    156  1.117        ad 		mutex_exit(&proclist_lock);
    157   1.98  christos 		return (EPERM);
    158   1.98  christos 	}
    159   1.98  christos 	TIMESPEC_TO_TIMEVAL(&tv, ts);
    160   1.98  christos 
    161   1.22       jtc 	/* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */
    162  1.129        ad 	s = splclock();
    163  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    164  1.101    kardel 	microtime(&now);
    165  1.101    kardel 	timersub(&tv, &now, &delta);
    166  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    167   1.98  christos 	timersub(&tv, &time, &delta);
    168  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    169  1.106      elad 	if ((delta.tv_sec < 0 || delta.tv_usec < 0) &&
    170  1.106      elad 	    kauth_authorize_system(p->p_cred, KAUTH_SYSTEM_TIME,
    171  1.106      elad 	    KAUTH_REQ_SYSTEM_TIME_BACKWARDS, NULL, NULL, NULL)) {
    172  1.129        ad 		splx(s);
    173   1.29       tls 		return (EPERM);
    174   1.55      tron 	}
    175   1.29       tls #ifdef notyet
    176  1.109      elad 	if ((delta.tv_sec < 86400) && securelevel > 0) { /* XXX elad - notyet */
    177  1.129        ad 		splx(s);
    178   1.29       tls 		return (EPERM);
    179   1.55      tron 	}
    180   1.29       tls #endif
    181  1.103    kardel 
    182  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    183  1.103    kardel 	TIMEVAL_TO_TIMESPEC(&tv, &ts1);
    184  1.101    kardel 	tc_setclock(&ts1);
    185  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    186   1.98  christos 	time = tv;
    187  1.103    kardel #endif /* !__HAVE_TIMECOUNTER */
    188  1.103    kardel 
    189   1.22       jtc 	timeradd(&boottime, &delta, &boottime);
    190  1.103    kardel 
    191   1.47   thorpej 	/*
    192  1.129        ad 	 * XXXSMP: There is a short race between setting the time above
    193  1.129        ad 	 * and adjusting LWP's run times.  Fixing this properly means
    194  1.129        ad 	 * pausing all CPUs while we adjust the clock.
    195   1.47   thorpej 	 */
    196  1.129        ad 	mutex_enter(&proclist_lock);
    197  1.129        ad 	LIST_FOREACH(l, &alllwp, l_list) {
    198  1.129        ad 		lwp_lock(l);
    199  1.129        ad 		timeradd(&l->l_stime, &delta, &l->l_stime);
    200  1.129        ad 		lwp_unlock(l);
    201  1.129        ad 	}
    202  1.129        ad 	mutex_exit(&proclist_lock);
    203   1.22       jtc 	resettodr();
    204  1.129        ad 	splx(s);
    205  1.129        ad 
    206   1.29       tls 	return (0);
    207   1.22       jtc }
    208   1.22       jtc 
    209   1.22       jtc /* ARGSUSED */
    210   1.22       jtc int
    211  1.110      yamt sys_clock_gettime(struct lwp *l, void *v, register_t *retval)
    212   1.22       jtc {
    213   1.45  augustss 	struct sys_clock_gettime_args /* {
    214   1.22       jtc 		syscallarg(clockid_t) clock_id;
    215   1.23       cgd 		syscallarg(struct timespec *) tp;
    216   1.23       cgd 	} */ *uap = v;
    217   1.22       jtc 	clockid_t clock_id;
    218   1.22       jtc 	struct timespec ats;
    219   1.22       jtc 
    220   1.22       jtc 	clock_id = SCARG(uap, clock_id);
    221   1.61    simonb 	switch (clock_id) {
    222   1.61    simonb 	case CLOCK_REALTIME:
    223   1.96    simonb 		nanotime(&ats);
    224   1.61    simonb 		break;
    225   1.61    simonb 	case CLOCK_MONOTONIC:
    226  1.101    kardel 		nanouptime(&ats);
    227   1.61    simonb 		break;
    228   1.61    simonb 	default:
    229   1.22       jtc 		return (EINVAL);
    230   1.61    simonb 	}
    231   1.22       jtc 
    232   1.24       cgd 	return copyout(&ats, SCARG(uap, tp), sizeof(ats));
    233   1.22       jtc }
    234   1.22       jtc 
    235   1.22       jtc /* ARGSUSED */
    236   1.22       jtc int
    237  1.110      yamt sys_clock_settime(struct lwp *l, void *v, register_t *retval)
    238   1.22       jtc {
    239   1.45  augustss 	struct sys_clock_settime_args /* {
    240   1.22       jtc 		syscallarg(clockid_t) clock_id;
    241   1.23       cgd 		syscallarg(const struct timespec *) tp;
    242   1.23       cgd 	} */ *uap = v;
    243   1.22       jtc 	int error;
    244   1.22       jtc 
    245  1.106      elad 	if ((error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_TIME,
    246  1.106      elad 	    KAUTH_REQ_SYSTEM_TIME_SYSTEM, NULL, NULL, NULL)) != 0)
    247   1.22       jtc 		return (error);
    248   1.22       jtc 
    249  1.105        ad 	return clock_settime1(l->l_proc, SCARG(uap, clock_id), SCARG(uap, tp));
    250   1.56      manu }
    251   1.56      manu 
    252   1.56      manu 
    253   1.56      manu int
    254   1.98  christos clock_settime1(struct proc *p, clockid_t clock_id, const struct timespec *tp)
    255   1.56      manu {
    256   1.60      manu 	struct timespec ats;
    257   1.56      manu 	int error;
    258   1.56      manu 
    259   1.60      manu 	if ((error = copyin(tp, &ats, sizeof(ats))) != 0)
    260   1.60      manu 		return (error);
    261   1.60      manu 
    262   1.61    simonb 	switch (clock_id) {
    263   1.61    simonb 	case CLOCK_REALTIME:
    264   1.98  christos 		if ((error = settime(p, &ats)) != 0)
    265   1.61    simonb 			return (error);
    266   1.61    simonb 		break;
    267   1.61    simonb 	case CLOCK_MONOTONIC:
    268   1.61    simonb 		return (EINVAL);	/* read-only clock */
    269   1.61    simonb 	default:
    270   1.56      manu 		return (EINVAL);
    271   1.61    simonb 	}
    272   1.22       jtc 
    273   1.22       jtc 	return 0;
    274   1.22       jtc }
    275   1.22       jtc 
    276   1.22       jtc int
    277  1.110      yamt sys_clock_getres(struct lwp *l, void *v, register_t *retval)
    278   1.22       jtc {
    279   1.45  augustss 	struct sys_clock_getres_args /* {
    280   1.22       jtc 		syscallarg(clockid_t) clock_id;
    281   1.23       cgd 		syscallarg(struct timespec *) tp;
    282   1.23       cgd 	} */ *uap = v;
    283   1.22       jtc 	clockid_t clock_id;
    284   1.22       jtc 	struct timespec ts;
    285   1.22       jtc 	int error = 0;
    286   1.22       jtc 
    287   1.22       jtc 	clock_id = SCARG(uap, clock_id);
    288   1.61    simonb 	switch (clock_id) {
    289   1.61    simonb 	case CLOCK_REALTIME:
    290   1.61    simonb 	case CLOCK_MONOTONIC:
    291   1.22       jtc 		ts.tv_sec = 0;
    292  1.102    kardel 		if (tc_getfrequency() > 1000000000)
    293  1.102    kardel 			ts.tv_nsec = 1;
    294  1.102    kardel 		else
    295  1.102    kardel 			ts.tv_nsec = 1000000000 / tc_getfrequency();
    296   1.61    simonb 		break;
    297   1.61    simonb 	default:
    298   1.61    simonb 		return (EINVAL);
    299   1.61    simonb 	}
    300   1.22       jtc 
    301   1.61    simonb 	if (SCARG(uap, tp))
    302   1.35     perry 		error = copyout(&ts, SCARG(uap, tp), sizeof(ts));
    303   1.22       jtc 
    304   1.22       jtc 	return error;
    305   1.22       jtc }
    306   1.22       jtc 
    307   1.27       jtc /* ARGSUSED */
    308   1.27       jtc int
    309  1.110      yamt sys_nanosleep(struct lwp *l, void *v, register_t *retval)
    310   1.27       jtc {
    311  1.101    kardel 	struct sys_nanosleep_args/* {
    312  1.101    kardel 		syscallarg(struct timespec *) rqtp;
    313  1.101    kardel 		syscallarg(struct timespec *) rmtp;
    314  1.101    kardel 	} */ *uap = v;
    315  1.101    kardel 	struct timespec rmt, rqt;
    316  1.120       dsl 	int error, error1;
    317  1.101    kardel 
    318  1.101    kardel 	error = copyin(SCARG(uap, rqtp), &rqt, sizeof(struct timespec));
    319  1.101    kardel 	if (error)
    320  1.101    kardel 		return (error);
    321  1.101    kardel 
    322  1.120       dsl 	error = nanosleep1(l, &rqt, SCARG(uap, rmtp) ? &rmt : NULL);
    323  1.120       dsl 	if (SCARG(uap, rmtp) == NULL || (error != 0 && error != EINTR))
    324  1.120       dsl 		return error;
    325  1.120       dsl 
    326  1.120       dsl 	error1 = copyout(&rmt, SCARG(uap, rmtp), sizeof(rmt));
    327  1.120       dsl 	return error1 ? error1 : error;
    328  1.120       dsl }
    329  1.120       dsl 
    330  1.120       dsl int
    331  1.120       dsl nanosleep1(struct lwp *l, struct timespec *rqt, struct timespec *rmt)
    332  1.120       dsl {
    333  1.120       dsl #ifdef __HAVE_TIMECOUNTER
    334  1.120       dsl 	int error, timo;
    335  1.120       dsl 
    336  1.120       dsl 	if (itimespecfix(rqt))
    337  1.101    kardel 		return (EINVAL);
    338  1.101    kardel 
    339  1.120       dsl 	timo = tstohz(rqt);
    340  1.101    kardel 	/*
    341  1.101    kardel 	 * Avoid inadvertantly sleeping forever
    342  1.101    kardel 	 */
    343  1.101    kardel 	if (timo == 0)
    344  1.101    kardel 		timo = 1;
    345  1.101    kardel 
    346  1.123       dsl 	if (rmt != NULL)
    347  1.123       dsl 		getnanouptime(rmt);
    348  1.104    kardel 
    349  1.115   thorpej 	error = kpause("nanoslp", true, timo, NULL);
    350  1.101    kardel 	if (error == ERESTART)
    351  1.101    kardel 		error = EINTR;
    352  1.101    kardel 	if (error == EWOULDBLOCK)
    353  1.101    kardel 		error = 0;
    354  1.101    kardel 
    355  1.120       dsl 	if (rmt!= NULL) {
    356  1.104    kardel 		struct timespec rmtend;
    357  1.101    kardel 
    358  1.104    kardel 		getnanouptime(&rmtend);
    359  1.101    kardel 
    360  1.120       dsl 		timespecsub(&rmtend, rmt, rmt);
    361  1.120       dsl 		timespecsub(rqt, rmt, rmt);
    362  1.120       dsl 		if (rmt->tv_sec < 0)
    363  1.120       dsl 			timespecclear(rmt);
    364  1.101    kardel 	}
    365  1.101    kardel 
    366  1.101    kardel 	return error;
    367  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    368   1.27       jtc 	struct timeval atv, utv;
    369   1.27       jtc 	int error, s, timo;
    370   1.27       jtc 
    371  1.120       dsl 	TIMESPEC_TO_TIMEVAL(&atv, rqt);
    372   1.80  christos 	if (itimerfix(&atv))
    373   1.27       jtc 		return (EINVAL);
    374   1.27       jtc 
    375   1.27       jtc 	s = splclock();
    376   1.27       jtc 	timeradd(&atv,&time,&atv);
    377   1.27       jtc 	timo = hzto(&atv);
    378   1.63   thorpej 	/*
    379   1.27       jtc 	 * Avoid inadvertantly sleeping forever
    380   1.27       jtc 	 */
    381   1.27       jtc 	if (timo == 0)
    382   1.27       jtc 		timo = 1;
    383   1.27       jtc 	splx(s);
    384   1.27       jtc 
    385  1.115   thorpej 	error = kpause("nanoslp", true, timo, NULL);
    386   1.27       jtc 	if (error == ERESTART)
    387   1.27       jtc 		error = EINTR;
    388   1.27       jtc 	if (error == EWOULDBLOCK)
    389   1.27       jtc 		error = 0;
    390   1.27       jtc 
    391  1.120       dsl 	if (rmt != NULL) {
    392   1.27       jtc 		s = splclock();
    393   1.27       jtc 		utv = time;
    394   1.27       jtc 		splx(s);
    395   1.27       jtc 
    396   1.27       jtc 		timersub(&atv, &utv, &utv);
    397   1.27       jtc 		if (utv.tv_sec < 0)
    398   1.27       jtc 			timerclear(&utv);
    399   1.27       jtc 
    400  1.120       dsl 		TIMEVAL_TO_TIMESPEC(&utv, rmt);
    401   1.27       jtc 	}
    402   1.27       jtc 
    403   1.27       jtc 	return error;
    404  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    405   1.27       jtc }
    406   1.22       jtc 
    407    1.1       cgd /* ARGSUSED */
    408    1.3    andrew int
    409  1.110      yamt sys_gettimeofday(struct lwp *l, void *v, register_t *retval)
    410   1.15   thorpej {
    411   1.45  augustss 	struct sys_gettimeofday_args /* {
    412   1.11       cgd 		syscallarg(struct timeval *) tp;
    413   1.84    simonb 		syscallarg(void *) tzp;		really "struct timezone *"
    414   1.15   thorpej 	} */ *uap = v;
    415    1.1       cgd 	struct timeval atv;
    416    1.1       cgd 	int error = 0;
    417   1.25     perry 	struct timezone tzfake;
    418    1.1       cgd 
    419   1.11       cgd 	if (SCARG(uap, tp)) {
    420    1.1       cgd 		microtime(&atv);
    421   1.35     perry 		error = copyout(&atv, SCARG(uap, tp), sizeof(atv));
    422   1.17  christos 		if (error)
    423    1.1       cgd 			return (error);
    424    1.1       cgd 	}
    425   1.25     perry 	if (SCARG(uap, tzp)) {
    426   1.25     perry 		/*
    427   1.32   mycroft 		 * NetBSD has no kernel notion of time zone, so we just
    428   1.25     perry 		 * fake up a timezone struct and return it if demanded.
    429   1.25     perry 		 */
    430   1.25     perry 		tzfake.tz_minuteswest = 0;
    431   1.25     perry 		tzfake.tz_dsttime = 0;
    432   1.35     perry 		error = copyout(&tzfake, SCARG(uap, tzp), sizeof(tzfake));
    433   1.25     perry 	}
    434    1.1       cgd 	return (error);
    435    1.1       cgd }
    436    1.1       cgd 
    437    1.1       cgd /* ARGSUSED */
    438    1.3    andrew int
    439  1.110      yamt sys_settimeofday(struct lwp *l, void *v, register_t *retval)
    440   1.15   thorpej {
    441   1.16   mycroft 	struct sys_settimeofday_args /* {
    442   1.24       cgd 		syscallarg(const struct timeval *) tv;
    443   1.84    simonb 		syscallarg(const void *) tzp;	really "const struct timezone *"
    444   1.15   thorpej 	} */ *uap = v;
    445   1.60      manu 
    446  1.119       dsl 	return settimeofday1(SCARG(uap, tv), true, SCARG(uap, tzp), l, true);
    447   1.60      manu }
    448   1.60      manu 
    449   1.60      manu int
    450  1.119       dsl settimeofday1(const struct timeval *utv, bool userspace,
    451  1.119       dsl     const void *utzp, struct lwp *l, bool check_kauth)
    452   1.60      manu {
    453   1.22       jtc 	struct timeval atv;
    454   1.98  christos 	struct timespec ts;
    455   1.22       jtc 	int error;
    456    1.1       cgd 
    457    1.8       cgd 	/* Verify all parameters before changing time. */
    458  1.119       dsl 
    459  1.119       dsl 	if (check_kauth) {
    460  1.119       dsl 		error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_TIME,
    461  1.119       dsl 		    KAUTH_REQ_SYSTEM_TIME_SYSTEM, NULL, NULL, NULL);
    462  1.119       dsl 		if (error != 0)
    463  1.119       dsl 			return (error);
    464  1.119       dsl 	}
    465  1.119       dsl 
    466   1.25     perry 	/*
    467   1.32   mycroft 	 * NetBSD has no kernel notion of time zone, and only an
    468   1.25     perry 	 * obsolete program would try to set it, so we log a warning.
    469   1.25     perry 	 */
    470   1.98  christos 	if (utzp)
    471   1.25     perry 		log(LOG_WARNING, "pid %d attempted to set the "
    472  1.119       dsl 		    "(obsolete) kernel time zone\n", l->l_proc->p_pid);
    473   1.98  christos 
    474   1.98  christos 	if (utv == NULL)
    475   1.98  christos 		return 0;
    476   1.98  christos 
    477  1.119       dsl 	if (userspace) {
    478  1.119       dsl 		if ((error = copyin(utv, &atv, sizeof(atv))) != 0)
    479  1.119       dsl 			return error;
    480  1.119       dsl 		utv = &atv;
    481  1.119       dsl 	}
    482  1.119       dsl 
    483  1.119       dsl 	TIMEVAL_TO_TIMESPEC(utv, &ts);
    484  1.119       dsl 	return settime(l->l_proc, &ts);
    485    1.1       cgd }
    486    1.1       cgd 
    487  1.101    kardel #ifndef __HAVE_TIMECOUNTER
    488    1.1       cgd int	tickdelta;			/* current clock skew, us. per tick */
    489    1.1       cgd long	timedelta;			/* unapplied time correction, us. */
    490    1.1       cgd long	bigadj = 1000000;		/* use 10x skew above bigadj us. */
    491  1.101    kardel #endif
    492  1.101    kardel 
    493   1.68       dsl int	time_adjusted;			/* set if an adjustment is made */
    494    1.1       cgd 
    495    1.1       cgd /* ARGSUSED */
    496    1.3    andrew int
    497  1.110      yamt sys_adjtime(struct lwp *l, void *v, register_t *retval)
    498   1.15   thorpej {
    499   1.45  augustss 	struct sys_adjtime_args /* {
    500   1.24       cgd 		syscallarg(const struct timeval *) delta;
    501   1.11       cgd 		syscallarg(struct timeval *) olddelta;
    502   1.15   thorpej 	} */ *uap = v;
    503   1.56      manu 	int error;
    504    1.1       cgd 
    505  1.106      elad 	if ((error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_TIME,
    506  1.106      elad 	    KAUTH_REQ_SYSTEM_TIME_ADJTIME, NULL, NULL, NULL)) != 0)
    507    1.1       cgd 		return (error);
    508   1.17  christos 
    509  1.105        ad 	return adjtime1(SCARG(uap, delta), SCARG(uap, olddelta), l->l_proc);
    510   1.56      manu }
    511   1.56      manu 
    512   1.56      manu int
    513  1.110      yamt adjtime1(const struct timeval *delta, struct timeval *olddelta, struct proc *p)
    514   1.56      manu {
    515   1.60      manu 	struct timeval atv;
    516  1.101    kardel 	int error = 0;
    517  1.101    kardel 
    518  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    519  1.101    kardel 	extern int64_t time_adjtime;  /* in kern_ntptime.c */
    520  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    521   1.56      manu 	long ndelta, ntickdelta, odelta;
    522   1.56      manu 	int s;
    523  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    524  1.101    kardel 
    525  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    526  1.101    kardel 	if (olddelta) {
    527  1.101    kardel 		atv.tv_sec = time_adjtime / 1000000;
    528  1.101    kardel 		atv.tv_usec = time_adjtime % 1000000;
    529  1.101    kardel 		if (atv.tv_usec < 0) {
    530  1.101    kardel 			atv.tv_usec += 1000000;
    531  1.101    kardel 			atv.tv_sec--;
    532  1.101    kardel 		}
    533  1.101    kardel 		error = copyout(&atv, olddelta, sizeof(struct timeval));
    534  1.101    kardel 		if (error)
    535  1.101    kardel 			return (error);
    536  1.101    kardel 	}
    537  1.101    kardel 
    538  1.101    kardel 	if (delta) {
    539  1.101    kardel 		error = copyin(delta, &atv, sizeof(struct timeval));
    540  1.101    kardel 		if (error)
    541  1.101    kardel 			return (error);
    542  1.101    kardel 
    543  1.101    kardel 		time_adjtime = (int64_t)atv.tv_sec * 1000000 +
    544  1.101    kardel 			atv.tv_usec;
    545    1.8       cgd 
    546  1.101    kardel 		if (time_adjtime)
    547  1.101    kardel 			/* We need to save the system time during shutdown */
    548  1.101    kardel 			time_adjusted |= 1;
    549  1.101    kardel 	}
    550  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    551   1.60      manu 	error = copyin(delta, &atv, sizeof(struct timeval));
    552   1.60      manu 	if (error)
    553   1.60      manu 		return (error);
    554   1.60      manu 
    555    1.8       cgd 	/*
    556    1.8       cgd 	 * Compute the total correction and the rate at which to apply it.
    557    1.8       cgd 	 * Round the adjustment down to a whole multiple of the per-tick
    558    1.8       cgd 	 * delta, so that after some number of incremental changes in
    559    1.8       cgd 	 * hardclock(), tickdelta will become zero, lest the correction
    560    1.8       cgd 	 * overshoot and start taking us away from the desired final time.
    561    1.8       cgd 	 */
    562   1.60      manu 	ndelta = atv.tv_sec * 1000000 + atv.tv_usec;
    563   1.41       hwr 	if (ndelta > bigadj || ndelta < -bigadj)
    564    1.8       cgd 		ntickdelta = 10 * tickadj;
    565    1.8       cgd 	else
    566    1.8       cgd 		ntickdelta = tickadj;
    567    1.8       cgd 	if (ndelta % ntickdelta)
    568    1.8       cgd 		ndelta = ndelta / ntickdelta * ntickdelta;
    569    1.8       cgd 
    570    1.8       cgd 	/*
    571    1.8       cgd 	 * To make hardclock()'s job easier, make the per-tick delta negative
    572    1.8       cgd 	 * if we want time to run slower; then hardclock can simply compute
    573    1.8       cgd 	 * tick + tickdelta, and subtract tickdelta from timedelta.
    574    1.8       cgd 	 */
    575    1.8       cgd 	if (ndelta < 0)
    576    1.8       cgd 		ntickdelta = -ntickdelta;
    577   1.68       dsl 	if (ndelta != 0)
    578   1.68       dsl 		/* We need to save the system clock time during shutdown */
    579   1.68       dsl 		time_adjusted |= 1;
    580    1.1       cgd 	s = splclock();
    581    1.8       cgd 	odelta = timedelta;
    582    1.1       cgd 	timedelta = ndelta;
    583    1.8       cgd 	tickdelta = ntickdelta;
    584    1.1       cgd 	splx(s);
    585    1.1       cgd 
    586   1.56      manu 	if (olddelta) {
    587   1.60      manu 		atv.tv_sec = odelta / 1000000;
    588   1.60      manu 		atv.tv_usec = odelta % 1000000;
    589   1.79       chs 		error = copyout(&atv, olddelta, sizeof(struct timeval));
    590    1.8       cgd 	}
    591  1.101    kardel #endif /* __HAVE_TIMECOUNTER */
    592  1.101    kardel 
    593   1.79       chs 	return error;
    594    1.1       cgd }
    595    1.1       cgd 
    596    1.1       cgd /*
    597   1.63   thorpej  * Interval timer support. Both the BSD getitimer() family and the POSIX
    598   1.63   thorpej  * timer_*() family of routines are supported.
    599    1.1       cgd  *
    600   1.63   thorpej  * All timers are kept in an array pointed to by p_timers, which is
    601   1.63   thorpej  * allocated on demand - many processes don't use timers at all. The
    602   1.63   thorpej  * first three elements in this array are reserved for the BSD timers:
    603   1.63   thorpej  * element 0 is ITIMER_REAL, element 1 is ITIMER_VIRTUAL, and element
    604   1.63   thorpej  * 2 is ITIMER_PROF. The rest may be allocated by the timer_create()
    605   1.63   thorpej  * syscall.
    606    1.1       cgd  *
    607   1.63   thorpej  * Realtime timers are kept in the ptimer structure as an absolute
    608   1.63   thorpej  * time; virtual time timers are kept as a linked list of deltas.
    609    1.1       cgd  * Virtual time timers are processed in the hardclock() routine of
    610   1.63   thorpej  * kern_clock.c.  The real time timer is processed by a callout
    611   1.63   thorpej  * routine, called from the softclock() routine.  Since a callout may
    612   1.63   thorpej  * be delayed in real time due to interrupt processing in the system,
    613   1.63   thorpej  * it is possible for the real time timeout routine (realtimeexpire,
    614   1.63   thorpej  * given below), to be delayed in real time past when it is supposed
    615   1.63   thorpej  * to occur.  It does not suffice, therefore, to reload the real timer
    616   1.63   thorpej  * .it_value from the real time timers .it_interval.  Rather, we
    617   1.63   thorpej  * compute the next time in absolute time the timer should go off.  */
    618   1.63   thorpej 
    619   1.63   thorpej /* Allocate a POSIX realtime timer. */
    620   1.63   thorpej int
    621  1.110      yamt sys_timer_create(struct lwp *l, void *v, register_t *retval)
    622   1.63   thorpej {
    623   1.63   thorpej 	struct sys_timer_create_args /* {
    624   1.63   thorpej 		syscallarg(clockid_t) clock_id;
    625   1.63   thorpej 		syscallarg(struct sigevent *) evp;
    626   1.63   thorpej 		syscallarg(timer_t *) timerid;
    627   1.63   thorpej 	} */ *uap = v;
    628   1.92      cube 
    629   1.92      cube 	return timer_create1(SCARG(uap, timerid), SCARG(uap, clock_id),
    630  1.105        ad 	    SCARG(uap, evp), copyin, l);
    631   1.92      cube }
    632   1.92      cube 
    633   1.92      cube int
    634   1.92      cube timer_create1(timer_t *tid, clockid_t id, struct sigevent *evp,
    635  1.105        ad     copyin_t fetch_event, struct lwp *l)
    636   1.92      cube {
    637   1.92      cube 	int error;
    638   1.92      cube 	timer_t timerid;
    639   1.63   thorpej 	struct ptimer *pt;
    640  1.105        ad 	struct proc *p;
    641  1.105        ad 
    642  1.105        ad 	p = l->l_proc;
    643   1.63   thorpej 
    644   1.63   thorpej 	if (id < CLOCK_REALTIME ||
    645   1.63   thorpej 	    id > CLOCK_PROF)
    646   1.63   thorpej 		return (EINVAL);
    647   1.63   thorpej 
    648   1.63   thorpej 	if (p->p_timers == NULL)
    649   1.63   thorpej 		timers_alloc(p);
    650   1.63   thorpej 
    651   1.63   thorpej 	/* Find a free timer slot, skipping those reserved for setitimer(). */
    652   1.63   thorpej 	for (timerid = 3; timerid < TIMER_MAX; timerid++)
    653   1.63   thorpej 		if (p->p_timers->pts_timers[timerid] == NULL)
    654   1.63   thorpej 			break;
    655   1.63   thorpej 
    656   1.63   thorpej 	if (timerid == TIMER_MAX)
    657   1.63   thorpej 		return EAGAIN;
    658   1.63   thorpej 
    659   1.63   thorpej 	pt = pool_get(&ptimer_pool, PR_WAITOK);
    660   1.63   thorpej 	if (evp) {
    661   1.63   thorpej 		if (((error =
    662   1.92      cube 		    (*fetch_event)(evp, &pt->pt_ev, sizeof(pt->pt_ev))) != 0) ||
    663   1.63   thorpej 		    ((pt->pt_ev.sigev_notify < SIGEV_NONE) ||
    664   1.63   thorpej 			(pt->pt_ev.sigev_notify > SIGEV_SA))) {
    665   1.63   thorpej 			pool_put(&ptimer_pool, pt);
    666   1.63   thorpej 			return (error ? error : EINVAL);
    667   1.63   thorpej 		}
    668   1.63   thorpej 	} else {
    669   1.63   thorpej 		pt->pt_ev.sigev_notify = SIGEV_SIGNAL;
    670   1.63   thorpej 		switch (id) {
    671   1.63   thorpej 		case CLOCK_REALTIME:
    672   1.63   thorpej 			pt->pt_ev.sigev_signo = SIGALRM;
    673   1.63   thorpej 			break;
    674   1.63   thorpej 		case CLOCK_VIRTUAL:
    675   1.63   thorpej 			pt->pt_ev.sigev_signo = SIGVTALRM;
    676   1.63   thorpej 			break;
    677   1.63   thorpej 		case CLOCK_PROF:
    678   1.63   thorpej 			pt->pt_ev.sigev_signo = SIGPROF;
    679   1.63   thorpej 			break;
    680   1.63   thorpej 		}
    681   1.63   thorpej 		pt->pt_ev.sigev_value.sival_int = timerid;
    682   1.63   thorpej 	}
    683   1.73  christos 	pt->pt_info.ksi_signo = pt->pt_ev.sigev_signo;
    684   1.73  christos 	pt->pt_info.ksi_errno = 0;
    685   1.73  christos 	pt->pt_info.ksi_code = 0;
    686   1.73  christos 	pt->pt_info.ksi_pid = p->p_pid;
    687  1.105        ad 	pt->pt_info.ksi_uid = kauth_cred_getuid(l->l_cred);
    688  1.124  christos 	pt->pt_info.ksi_value = pt->pt_ev.sigev_value;
    689   1.63   thorpej 
    690   1.63   thorpej 	pt->pt_type = id;
    691   1.63   thorpej 	pt->pt_proc = p;
    692   1.63   thorpej 	pt->pt_overruns = 0;
    693   1.63   thorpej 	pt->pt_poverruns = 0;
    694   1.64   nathanw 	pt->pt_entry = timerid;
    695   1.63   thorpej 	timerclear(&pt->pt_time.it_value);
    696   1.63   thorpej 	if (id == CLOCK_REALTIME)
    697  1.125        ad 		callout_init(&pt->pt_ch, 0);
    698   1.63   thorpej 	else
    699   1.63   thorpej 		pt->pt_active = 0;
    700   1.63   thorpej 
    701   1.63   thorpej 	p->p_timers->pts_timers[timerid] = pt;
    702   1.63   thorpej 
    703   1.92      cube 	return copyout(&timerid, tid, sizeof(timerid));
    704   1.63   thorpej }
    705   1.63   thorpej 
    706   1.63   thorpej /* Delete a POSIX realtime timer */
    707    1.3    andrew int
    708  1.110      yamt sys_timer_delete(struct lwp *l, void *v, register_t *retval)
    709   1.15   thorpej {
    710   1.63   thorpej 	struct sys_timer_delete_args /*  {
    711   1.63   thorpej 		syscallarg(timer_t) timerid;
    712   1.15   thorpej 	} */ *uap = v;
    713   1.63   thorpej 	struct proc *p = l->l_proc;
    714   1.65  jdolecek 	timer_t timerid;
    715   1.63   thorpej 	struct ptimer *pt, *ptn;
    716    1.1       cgd 	int s;
    717    1.1       cgd 
    718   1.63   thorpej 	timerid = SCARG(uap, timerid);
    719   1.63   thorpej 
    720   1.63   thorpej 	if ((p->p_timers == NULL) ||
    721   1.63   thorpej 	    (timerid < 2) || (timerid >= TIMER_MAX) ||
    722   1.63   thorpej 	    ((pt = p->p_timers->pts_timers[timerid]) == NULL))
    723    1.1       cgd 		return (EINVAL);
    724   1.63   thorpej 
    725  1.125        ad 	if (pt->pt_type == CLOCK_REALTIME) {
    726   1.63   thorpej 		callout_stop(&pt->pt_ch);
    727  1.125        ad 		callout_destroy(&pt->pt_ch);
    728  1.125        ad 	} else if (pt->pt_active) {
    729   1.63   thorpej 		s = splclock();
    730   1.63   thorpej 		ptn = LIST_NEXT(pt, pt_list);
    731   1.63   thorpej 		LIST_REMOVE(pt, pt_list);
    732   1.63   thorpej 		for ( ; ptn; ptn = LIST_NEXT(ptn, pt_list))
    733   1.63   thorpej 			timeradd(&pt->pt_time.it_value, &ptn->pt_time.it_value,
    734   1.63   thorpej 			    &ptn->pt_time.it_value);
    735   1.63   thorpej 		splx(s);
    736   1.63   thorpej 	}
    737   1.63   thorpej 
    738   1.63   thorpej 	p->p_timers->pts_timers[timerid] = NULL;
    739   1.63   thorpej 	pool_put(&ptimer_pool, pt);
    740   1.63   thorpej 
    741   1.63   thorpej 	return (0);
    742   1.63   thorpej }
    743   1.63   thorpej 
    744   1.63   thorpej /*
    745   1.67   nathanw  * Set up the given timer. The value in pt->pt_time.it_value is taken
    746   1.67   nathanw  * to be an absolute time for CLOCK_REALTIME timers and a relative
    747   1.67   nathanw  * time for virtual timers.
    748   1.63   thorpej  * Must be called at splclock().
    749   1.63   thorpej  */
    750   1.63   thorpej void
    751   1.63   thorpej timer_settime(struct ptimer *pt)
    752   1.63   thorpej {
    753   1.63   thorpej 	struct ptimer *ptn, *pptn;
    754   1.63   thorpej 	struct ptlist *ptl;
    755   1.63   thorpej 
    756   1.63   thorpej 	if (pt->pt_type == CLOCK_REALTIME) {
    757   1.63   thorpej 		callout_stop(&pt->pt_ch);
    758   1.63   thorpej 		if (timerisset(&pt->pt_time.it_value)) {
    759   1.63   thorpej 			/*
    760   1.63   thorpej 			 * Don't need to check hzto() return value, here.
    761   1.63   thorpej 			 * callout_reset() does it for us.
    762   1.63   thorpej 			 */
    763   1.63   thorpej 			callout_reset(&pt->pt_ch, hzto(&pt->pt_time.it_value),
    764   1.63   thorpej 			    realtimerexpire, pt);
    765   1.63   thorpej 		}
    766   1.63   thorpej 	} else {
    767   1.63   thorpej 		if (pt->pt_active) {
    768   1.63   thorpej 			ptn = LIST_NEXT(pt, pt_list);
    769   1.63   thorpej 			LIST_REMOVE(pt, pt_list);
    770   1.63   thorpej 			for ( ; ptn; ptn = LIST_NEXT(ptn, pt_list))
    771   1.63   thorpej 				timeradd(&pt->pt_time.it_value,
    772   1.63   thorpej 				    &ptn->pt_time.it_value,
    773   1.63   thorpej 				    &ptn->pt_time.it_value);
    774   1.63   thorpej 		}
    775   1.63   thorpej 		if (timerisset(&pt->pt_time.it_value)) {
    776   1.63   thorpej 			if (pt->pt_type == CLOCK_VIRTUAL)
    777   1.63   thorpej 				ptl = &pt->pt_proc->p_timers->pts_virtual;
    778   1.63   thorpej 			else
    779   1.63   thorpej 				ptl = &pt->pt_proc->p_timers->pts_prof;
    780   1.63   thorpej 
    781   1.63   thorpej 			for (ptn = LIST_FIRST(ptl), pptn = NULL;
    782   1.63   thorpej 			     ptn && timercmp(&pt->pt_time.it_value,
    783   1.63   thorpej 				 &ptn->pt_time.it_value, >);
    784   1.63   thorpej 			     pptn = ptn, ptn = LIST_NEXT(ptn, pt_list))
    785   1.63   thorpej 				timersub(&pt->pt_time.it_value,
    786   1.63   thorpej 				    &ptn->pt_time.it_value,
    787   1.63   thorpej 				    &pt->pt_time.it_value);
    788   1.63   thorpej 
    789   1.63   thorpej 			if (pptn)
    790   1.63   thorpej 				LIST_INSERT_AFTER(pptn, pt, pt_list);
    791   1.63   thorpej 			else
    792   1.63   thorpej 				LIST_INSERT_HEAD(ptl, pt, pt_list);
    793   1.63   thorpej 
    794   1.63   thorpej 			for ( ; ptn ; ptn = LIST_NEXT(ptn, pt_list))
    795   1.63   thorpej 				timersub(&ptn->pt_time.it_value,
    796   1.63   thorpej 				    &pt->pt_time.it_value,
    797   1.63   thorpej 				    &ptn->pt_time.it_value);
    798   1.63   thorpej 
    799   1.63   thorpej 			pt->pt_active = 1;
    800   1.63   thorpej 		} else
    801   1.63   thorpej 			pt->pt_active = 0;
    802   1.63   thorpej 	}
    803   1.63   thorpej }
    804   1.63   thorpej 
    805   1.63   thorpej void
    806   1.63   thorpej timer_gettime(struct ptimer *pt, struct itimerval *aitv)
    807   1.63   thorpej {
    808  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    809  1.101    kardel 	struct timeval now;
    810  1.101    kardel #endif
    811   1.63   thorpej 	struct ptimer *ptn;
    812   1.63   thorpej 
    813   1.63   thorpej 	*aitv = pt->pt_time;
    814   1.63   thorpej 	if (pt->pt_type == CLOCK_REALTIME) {
    815    1.1       cgd 		/*
    816   1.12   mycroft 		 * Convert from absolute to relative time in .it_value
    817   1.63   thorpej 		 * part of real time timer.  If time for real time
    818   1.63   thorpej 		 * timer has passed return 0, else return difference
    819   1.63   thorpej 		 * between current time and time for the timer to go
    820   1.63   thorpej 		 * off.
    821    1.1       cgd 		 */
    822   1.63   thorpej 		if (timerisset(&aitv->it_value)) {
    823  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    824  1.101    kardel 			getmicrotime(&now);
    825  1.101    kardel 			if (timercmp(&aitv->it_value, &now, <))
    826  1.101    kardel 				timerclear(&aitv->it_value);
    827  1.101    kardel 			else
    828  1.101    kardel 				timersub(&aitv->it_value, &now,
    829  1.101    kardel 				    &aitv->it_value);
    830  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    831   1.63   thorpej 			if (timercmp(&aitv->it_value, &time, <))
    832   1.63   thorpej 				timerclear(&aitv->it_value);
    833    1.1       cgd 			else
    834   1.63   thorpej 				timersub(&aitv->it_value, &time,
    835   1.63   thorpej 				    &aitv->it_value);
    836  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    837   1.36   thorpej 		}
    838   1.63   thorpej 	} else if (pt->pt_active) {
    839   1.63   thorpej 		if (pt->pt_type == CLOCK_VIRTUAL)
    840   1.63   thorpej 			ptn = LIST_FIRST(&pt->pt_proc->p_timers->pts_virtual);
    841   1.63   thorpej 		else
    842   1.63   thorpej 			ptn = LIST_FIRST(&pt->pt_proc->p_timers->pts_prof);
    843   1.63   thorpej 		for ( ; ptn && ptn != pt; ptn = LIST_NEXT(ptn, pt_list))
    844   1.63   thorpej 			timeradd(&aitv->it_value,
    845   1.63   thorpej 			    &ptn->pt_time.it_value, &aitv->it_value);
    846   1.63   thorpej 		KASSERT(ptn != NULL); /* pt should be findable on the list */
    847    1.1       cgd 	} else
    848   1.63   thorpej 		timerclear(&aitv->it_value);
    849   1.63   thorpej }
    850   1.63   thorpej 
    851   1.63   thorpej 
    852   1.63   thorpej 
    853   1.63   thorpej /* Set and arm a POSIX realtime timer */
    854   1.63   thorpej int
    855  1.110      yamt sys_timer_settime(struct lwp *l, void *v, register_t *retval)
    856   1.63   thorpej {
    857   1.63   thorpej 	struct sys_timer_settime_args /* {
    858   1.63   thorpej 		syscallarg(timer_t) timerid;
    859   1.63   thorpej 		syscallarg(int) flags;
    860   1.63   thorpej 		syscallarg(const struct itimerspec *) value;
    861   1.63   thorpej 		syscallarg(struct itimerspec *) ovalue;
    862   1.63   thorpej 	} */ *uap = v;
    863   1.92      cube 	int error;
    864   1.92      cube 	struct itimerspec value, ovalue, *ovp = NULL;
    865   1.92      cube 
    866   1.92      cube 	if ((error = copyin(SCARG(uap, value), &value,
    867   1.92      cube 	    sizeof(struct itimerspec))) != 0)
    868   1.92      cube 		return (error);
    869   1.92      cube 
    870   1.92      cube 	if (SCARG(uap, ovalue))
    871   1.92      cube 		ovp = &ovalue;
    872   1.92      cube 
    873   1.92      cube 	if ((error = dotimer_settime(SCARG(uap, timerid), &value, ovp,
    874   1.92      cube 	    SCARG(uap, flags), l->l_proc)) != 0)
    875   1.92      cube 		return error;
    876   1.92      cube 
    877   1.92      cube 	if (ovp)
    878   1.92      cube 		return copyout(&ovalue, SCARG(uap, ovalue),
    879   1.92      cube 		    sizeof(struct itimerspec));
    880   1.92      cube 	return 0;
    881   1.92      cube }
    882   1.92      cube 
    883   1.92      cube int
    884   1.92      cube dotimer_settime(int timerid, struct itimerspec *value,
    885   1.92      cube     struct itimerspec *ovalue, int flags, struct proc *p)
    886   1.92      cube {
    887  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    888  1.101    kardel 	struct timeval now;
    889  1.101    kardel #endif
    890   1.63   thorpej 	struct itimerval val, oval;
    891   1.63   thorpej 	struct ptimer *pt;
    892  1.101    kardel 	int s;
    893   1.63   thorpej 
    894   1.63   thorpej 	if ((p->p_timers == NULL) ||
    895   1.63   thorpej 	    (timerid < 2) || (timerid >= TIMER_MAX) ||
    896   1.63   thorpej 	    ((pt = p->p_timers->pts_timers[timerid]) == NULL))
    897   1.63   thorpej 		return (EINVAL);
    898   1.63   thorpej 
    899   1.92      cube 	TIMESPEC_TO_TIMEVAL(&val.it_value, &value->it_value);
    900   1.92      cube 	TIMESPEC_TO_TIMEVAL(&val.it_interval, &value->it_interval);
    901   1.63   thorpej 	if (itimerfix(&val.it_value) || itimerfix(&val.it_interval))
    902   1.63   thorpej 		return (EINVAL);
    903   1.63   thorpej 
    904   1.63   thorpej 	oval = pt->pt_time;
    905   1.63   thorpej 	pt->pt_time = val;
    906   1.63   thorpej 
    907   1.63   thorpej 	s = splclock();
    908   1.67   nathanw 	/*
    909   1.67   nathanw 	 * If we've been passed a relative time for a realtime timer,
    910   1.67   nathanw 	 * convert it to absolute; if an absolute time for a virtual
    911   1.67   nathanw 	 * timer, convert it to relative and make sure we don't set it
    912   1.67   nathanw 	 * to zero, which would cancel the timer, or let it go
    913   1.67   nathanw 	 * negative, which would confuse the comparison tests.
    914   1.67   nathanw 	 */
    915   1.67   nathanw 	if (timerisset(&pt->pt_time.it_value)) {
    916   1.67   nathanw 		if (pt->pt_type == CLOCK_REALTIME) {
    917  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    918  1.101    kardel 			if ((flags & TIMER_ABSTIME) == 0) {
    919  1.101    kardel 				getmicrotime(&now);
    920  1.101    kardel 				timeradd(&pt->pt_time.it_value, &now,
    921  1.101    kardel 				    &pt->pt_time.it_value);
    922  1.101    kardel 			}
    923  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    924   1.92      cube 			if ((flags & TIMER_ABSTIME) == 0)
    925   1.67   nathanw 				timeradd(&pt->pt_time.it_value, &time,
    926   1.67   nathanw 				    &pt->pt_time.it_value);
    927  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    928   1.67   nathanw 		} else {
    929   1.92      cube 			if ((flags & TIMER_ABSTIME) != 0) {
    930  1.101    kardel #ifdef __HAVE_TIMECOUNTER
    931  1.101    kardel 				getmicrotime(&now);
    932  1.101    kardel 				timersub(&pt->pt_time.it_value, &now,
    933  1.101    kardel 				    &pt->pt_time.it_value);
    934  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
    935   1.67   nathanw 				timersub(&pt->pt_time.it_value, &time,
    936   1.67   nathanw 				    &pt->pt_time.it_value);
    937  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
    938   1.67   nathanw 				if (!timerisset(&pt->pt_time.it_value) ||
    939   1.67   nathanw 				    pt->pt_time.it_value.tv_sec < 0) {
    940   1.67   nathanw 					pt->pt_time.it_value.tv_sec = 0;
    941   1.67   nathanw 					pt->pt_time.it_value.tv_usec = 1;
    942   1.67   nathanw 				}
    943   1.67   nathanw 			}
    944   1.67   nathanw 		}
    945   1.67   nathanw 	}
    946   1.67   nathanw 
    947   1.63   thorpej 	timer_settime(pt);
    948   1.63   thorpej 	splx(s);
    949   1.63   thorpej 
    950   1.92      cube 	if (ovalue) {
    951   1.92      cube 		TIMEVAL_TO_TIMESPEC(&oval.it_value, &ovalue->it_value);
    952   1.92      cube 		TIMEVAL_TO_TIMESPEC(&oval.it_interval, &ovalue->it_interval);
    953   1.63   thorpej 	}
    954   1.63   thorpej 
    955   1.63   thorpej 	return (0);
    956   1.63   thorpej }
    957   1.63   thorpej 
    958   1.63   thorpej /* Return the time remaining until a POSIX timer fires. */
    959   1.63   thorpej int
    960  1.110      yamt sys_timer_gettime(struct lwp *l, void *v, register_t *retval)
    961   1.63   thorpej {
    962   1.63   thorpej 	struct sys_timer_gettime_args /* {
    963   1.63   thorpej 		syscallarg(timer_t) timerid;
    964   1.63   thorpej 		syscallarg(struct itimerspec *) value;
    965   1.63   thorpej 	} */ *uap = v;
    966   1.63   thorpej 	struct itimerspec its;
    967   1.92      cube 	int error;
    968   1.92      cube 
    969   1.92      cube 	if ((error = dotimer_gettime(SCARG(uap, timerid), l->l_proc,
    970   1.92      cube 	    &its)) != 0)
    971   1.92      cube 		return error;
    972   1.92      cube 
    973   1.92      cube 	return copyout(&its, SCARG(uap, value), sizeof(its));
    974   1.92      cube }
    975   1.92      cube 
    976   1.92      cube int
    977   1.92      cube dotimer_gettime(int timerid, struct proc *p, struct itimerspec *its)
    978   1.92      cube {
    979   1.92      cube 	int s;
    980   1.63   thorpej 	struct ptimer *pt;
    981   1.92      cube 	struct itimerval aitv;
    982   1.63   thorpej 
    983   1.63   thorpej 	if ((p->p_timers == NULL) ||
    984   1.63   thorpej 	    (timerid < 2) || (timerid >= TIMER_MAX) ||
    985   1.63   thorpej 	    ((pt = p->p_timers->pts_timers[timerid]) == NULL))
    986   1.63   thorpej 		return (EINVAL);
    987   1.63   thorpej 
    988   1.63   thorpej 	s = splclock();
    989   1.63   thorpej 	timer_gettime(pt, &aitv);
    990    1.1       cgd 	splx(s);
    991   1.63   thorpej 
    992   1.92      cube 	TIMEVAL_TO_TIMESPEC(&aitv.it_interval, &its->it_interval);
    993   1.92      cube 	TIMEVAL_TO_TIMESPEC(&aitv.it_value, &its->it_value);
    994   1.63   thorpej 
    995   1.92      cube 	return 0;
    996   1.63   thorpej }
    997   1.63   thorpej 
    998   1.63   thorpej /*
    999   1.63   thorpej  * Return the count of the number of times a periodic timer expired
   1000   1.63   thorpej  * while a notification was already pending. The counter is reset when
   1001   1.63   thorpej  * a timer expires and a notification can be posted.
   1002   1.63   thorpej  */
   1003   1.63   thorpej int
   1004   1.63   thorpej sys_timer_getoverrun(struct lwp *l, void *v, register_t *retval)
   1005   1.63   thorpej {
   1006   1.63   thorpej 	struct sys_timer_getoverrun_args /* {
   1007   1.63   thorpej 		syscallarg(timer_t) timerid;
   1008   1.63   thorpej 	} */ *uap = v;
   1009   1.63   thorpej 	struct proc *p = l->l_proc;
   1010   1.63   thorpej 	int timerid;
   1011   1.63   thorpej 	struct ptimer *pt;
   1012   1.63   thorpej 
   1013   1.63   thorpej 	timerid = SCARG(uap, timerid);
   1014   1.63   thorpej 
   1015   1.63   thorpej 	if ((p->p_timers == NULL) ||
   1016   1.63   thorpej 	    (timerid < 2) || (timerid >= TIMER_MAX) ||
   1017   1.63   thorpej 	    ((pt = p->p_timers->pts_timers[timerid]) == NULL))
   1018   1.63   thorpej 		return (EINVAL);
   1019   1.63   thorpej 
   1020   1.63   thorpej 	*retval = pt->pt_poverruns;
   1021   1.63   thorpej 
   1022   1.63   thorpej 	return (0);
   1023   1.63   thorpej }
   1024   1.63   thorpej 
   1025   1.63   thorpej /*
   1026   1.63   thorpej  * Real interval timer expired:
   1027   1.63   thorpej  * send process whose timer expired an alarm signal.
   1028   1.63   thorpej  * If time is not set up to reload, then just return.
   1029   1.63   thorpej  * Else compute next time timer should go off which is > current time.
   1030   1.63   thorpej  * This is where delay in processing this timeout causes multiple
   1031   1.63   thorpej  * SIGALRM calls to be compressed into one.
   1032   1.63   thorpej  */
   1033   1.63   thorpej void
   1034   1.63   thorpej realtimerexpire(void *arg)
   1035   1.63   thorpej {
   1036  1.101    kardel #ifdef __HAVE_TIMECOUNTER
   1037  1.101    kardel 	struct timeval now;
   1038  1.101    kardel #endif
   1039   1.63   thorpej 	struct ptimer *pt;
   1040   1.63   thorpej 	int s;
   1041   1.63   thorpej 
   1042   1.63   thorpej 	pt = (struct ptimer *)arg;
   1043   1.63   thorpej 
   1044   1.63   thorpej 	itimerfire(pt);
   1045   1.63   thorpej 
   1046   1.63   thorpej 	if (!timerisset(&pt->pt_time.it_interval)) {
   1047   1.63   thorpej 		timerclear(&pt->pt_time.it_value);
   1048   1.63   thorpej 		return;
   1049   1.63   thorpej 	}
   1050  1.101    kardel #ifdef __HAVE_TIMECOUNTER
   1051  1.101    kardel 	for (;;) {
   1052  1.101    kardel 		s = splclock();	/* XXX need spl now? */
   1053  1.101    kardel 		timeradd(&pt->pt_time.it_value,
   1054  1.101    kardel 		    &pt->pt_time.it_interval, &pt->pt_time.it_value);
   1055  1.101    kardel 		getmicrotime(&now);
   1056  1.101    kardel 		if (timercmp(&pt->pt_time.it_value, &now, >)) {
   1057  1.101    kardel 			/*
   1058  1.101    kardel 			 * Don't need to check hzto() return value, here.
   1059  1.101    kardel 			 * callout_reset() does it for us.
   1060  1.101    kardel 			 */
   1061  1.101    kardel 			callout_reset(&pt->pt_ch, hzto(&pt->pt_time.it_value),
   1062  1.101    kardel 			    realtimerexpire, pt);
   1063  1.101    kardel 			splx(s);
   1064  1.101    kardel 			return;
   1065  1.101    kardel 		}
   1066  1.101    kardel 		splx(s);
   1067  1.101    kardel 		pt->pt_overruns++;
   1068  1.101    kardel 	}
   1069  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
   1070   1.63   thorpej 	for (;;) {
   1071   1.63   thorpej 		s = splclock();
   1072   1.63   thorpej 		timeradd(&pt->pt_time.it_value,
   1073   1.63   thorpej 		    &pt->pt_time.it_interval, &pt->pt_time.it_value);
   1074   1.63   thorpej 		if (timercmp(&pt->pt_time.it_value, &time, >)) {
   1075   1.63   thorpej 			/*
   1076   1.63   thorpej 			 * Don't need to check hzto() return value, here.
   1077   1.63   thorpej 			 * callout_reset() does it for us.
   1078   1.63   thorpej 			 */
   1079   1.63   thorpej 			callout_reset(&pt->pt_ch, hzto(&pt->pt_time.it_value),
   1080   1.63   thorpej 			    realtimerexpire, pt);
   1081   1.63   thorpej 			splx(s);
   1082   1.63   thorpej 			return;
   1083   1.63   thorpej 		}
   1084   1.63   thorpej 		splx(s);
   1085   1.63   thorpej 		pt->pt_overruns++;
   1086   1.63   thorpej 	}
   1087  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
   1088   1.63   thorpej }
   1089   1.63   thorpej 
   1090   1.63   thorpej /* BSD routine to get the value of an interval timer. */
   1091   1.63   thorpej /* ARGSUSED */
   1092   1.63   thorpej int
   1093  1.110      yamt sys_getitimer(struct lwp *l, void *v, register_t *retval)
   1094   1.63   thorpej {
   1095   1.63   thorpej 	struct sys_getitimer_args /* {
   1096   1.63   thorpej 		syscallarg(int) which;
   1097   1.63   thorpej 		syscallarg(struct itimerval *) itv;
   1098   1.63   thorpej 	} */ *uap = v;
   1099   1.63   thorpej 	struct proc *p = l->l_proc;
   1100   1.63   thorpej 	struct itimerval aitv;
   1101   1.91      cube 	int error;
   1102   1.91      cube 
   1103   1.91      cube 	error = dogetitimer(p, SCARG(uap, which), &aitv);
   1104   1.91      cube 	if (error)
   1105   1.91      cube 		return error;
   1106   1.91      cube 	return (copyout(&aitv, SCARG(uap, itv), sizeof(struct itimerval)));
   1107   1.91      cube }
   1108   1.63   thorpej 
   1109   1.91      cube int
   1110   1.91      cube dogetitimer(struct proc *p, int which, struct itimerval *itvp)
   1111   1.91      cube {
   1112   1.91      cube 	int s;
   1113   1.63   thorpej 
   1114   1.63   thorpej 	if ((u_int)which > ITIMER_PROF)
   1115   1.63   thorpej 		return (EINVAL);
   1116   1.63   thorpej 
   1117   1.63   thorpej 	if ((p->p_timers == NULL) || (p->p_timers->pts_timers[which] == NULL)){
   1118   1.91      cube 		timerclear(&itvp->it_value);
   1119   1.91      cube 		timerclear(&itvp->it_interval);
   1120   1.63   thorpej 	} else {
   1121   1.63   thorpej 		s = splclock();
   1122   1.91      cube 		timer_gettime(p->p_timers->pts_timers[which], itvp);
   1123   1.63   thorpej 		splx(s);
   1124   1.63   thorpej 	}
   1125   1.63   thorpej 
   1126   1.91      cube 	return 0;
   1127    1.1       cgd }
   1128    1.1       cgd 
   1129   1.63   thorpej /* BSD routine to set/arm an interval timer. */
   1130    1.1       cgd /* ARGSUSED */
   1131    1.3    andrew int
   1132   1.63   thorpej sys_setitimer(struct lwp *l, void *v, register_t *retval)
   1133   1.15   thorpej {
   1134   1.45  augustss 	struct sys_setitimer_args /* {
   1135   1.30   mycroft 		syscallarg(int) which;
   1136   1.24       cgd 		syscallarg(const struct itimerval *) itv;
   1137   1.11       cgd 		syscallarg(struct itimerval *) oitv;
   1138   1.15   thorpej 	} */ *uap = v;
   1139   1.63   thorpej 	struct proc *p = l->l_proc;
   1140   1.30   mycroft 	int which = SCARG(uap, which);
   1141   1.21       cgd 	struct sys_getitimer_args getargs;
   1142   1.91      cube 	const struct itimerval *itvp;
   1143    1.1       cgd 	struct itimerval aitv;
   1144   1.91      cube 	int error;
   1145    1.1       cgd 
   1146   1.30   mycroft 	if ((u_int)which > ITIMER_PROF)
   1147    1.1       cgd 		return (EINVAL);
   1148   1.11       cgd 	itvp = SCARG(uap, itv);
   1149   1.63   thorpej 	if (itvp &&
   1150   1.56      manu 	    (error = copyin(itvp, &aitv, sizeof(struct itimerval)) != 0))
   1151    1.1       cgd 		return (error);
   1152   1.21       cgd 	if (SCARG(uap, oitv) != NULL) {
   1153   1.30   mycroft 		SCARG(&getargs, which) = which;
   1154   1.21       cgd 		SCARG(&getargs, itv) = SCARG(uap, oitv);
   1155   1.63   thorpej 		if ((error = sys_getitimer(l, &getargs, retval)) != 0)
   1156   1.21       cgd 			return (error);
   1157   1.21       cgd 	}
   1158    1.1       cgd 	if (itvp == 0)
   1159    1.1       cgd 		return (0);
   1160   1.91      cube 
   1161   1.91      cube 	return dosetitimer(p, which, &aitv);
   1162   1.91      cube }
   1163   1.91      cube 
   1164   1.91      cube int
   1165   1.91      cube dosetitimer(struct proc *p, int which, struct itimerval *itvp)
   1166   1.91      cube {
   1167  1.101    kardel #ifdef __HAVE_TIMECOUNTER
   1168  1.101    kardel 	struct timeval now;
   1169  1.101    kardel #endif
   1170   1.91      cube 	struct ptimer *pt;
   1171   1.91      cube 	int s;
   1172   1.91      cube 
   1173   1.91      cube 	if (itimerfix(&itvp->it_value) || itimerfix(&itvp->it_interval))
   1174    1.1       cgd 		return (EINVAL);
   1175   1.63   thorpej 
   1176   1.63   thorpej 	/*
   1177   1.63   thorpej 	 * Don't bother allocating data structures if the process just
   1178   1.63   thorpej 	 * wants to clear the timer.
   1179   1.63   thorpej 	 */
   1180   1.91      cube 	if (!timerisset(&itvp->it_value) &&
   1181   1.63   thorpej 	    ((p->p_timers == NULL) ||(p->p_timers->pts_timers[which] == NULL)))
   1182   1.63   thorpej 		return (0);
   1183   1.63   thorpej 
   1184   1.63   thorpej 	if (p->p_timers == NULL)
   1185   1.63   thorpej 		timers_alloc(p);
   1186   1.63   thorpej 	if (p->p_timers->pts_timers[which] == NULL) {
   1187   1.63   thorpej 		pt = pool_get(&ptimer_pool, PR_WAITOK);
   1188   1.63   thorpej 		pt->pt_ev.sigev_notify = SIGEV_SIGNAL;
   1189   1.76  christos 		pt->pt_ev.sigev_value.sival_int = which;
   1190   1.63   thorpej 		pt->pt_overruns = 0;
   1191   1.63   thorpej 		pt->pt_proc = p;
   1192   1.63   thorpej 		pt->pt_type = which;
   1193   1.64   nathanw 		pt->pt_entry = which;
   1194   1.63   thorpej 		switch (which) {
   1195   1.63   thorpej 		case ITIMER_REAL:
   1196  1.125        ad 			callout_init(&pt->pt_ch, 0);
   1197   1.63   thorpej 			pt->pt_ev.sigev_signo = SIGALRM;
   1198   1.63   thorpej 			break;
   1199   1.63   thorpej 		case ITIMER_VIRTUAL:
   1200   1.63   thorpej 			pt->pt_active = 0;
   1201   1.63   thorpej 			pt->pt_ev.sigev_signo = SIGVTALRM;
   1202   1.63   thorpej 			break;
   1203   1.63   thorpej 		case ITIMER_PROF:
   1204   1.63   thorpej 			pt->pt_active = 0;
   1205   1.63   thorpej 			pt->pt_ev.sigev_signo = SIGPROF;
   1206   1.63   thorpej 			break;
   1207    1.1       cgd 		}
   1208    1.1       cgd 	} else
   1209   1.63   thorpej 		pt = p->p_timers->pts_timers[which];
   1210   1.63   thorpej 
   1211   1.91      cube 	pt->pt_time = *itvp;
   1212   1.63   thorpej 	p->p_timers->pts_timers[which] = pt;
   1213   1.63   thorpej 
   1214   1.63   thorpej 	s = splclock();
   1215   1.67   nathanw 	if ((which == ITIMER_REAL) && timerisset(&pt->pt_time.it_value)) {
   1216   1.67   nathanw 		/* Convert to absolute time */
   1217  1.101    kardel #ifdef __HAVE_TIMECOUNTER
   1218  1.101    kardel 		/* XXX need to wrap in splclock for timecounters case? */
   1219  1.101    kardel 		getmicrotime(&now);
   1220  1.101    kardel 		timeradd(&pt->pt_time.it_value, &now, &pt->pt_time.it_value);
   1221  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
   1222   1.67   nathanw 		timeradd(&pt->pt_time.it_value, &time, &pt->pt_time.it_value);
   1223  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
   1224   1.67   nathanw 	}
   1225   1.63   thorpej 	timer_settime(pt);
   1226    1.1       cgd 	splx(s);
   1227   1.63   thorpej 
   1228    1.1       cgd 	return (0);
   1229    1.1       cgd }
   1230    1.1       cgd 
   1231   1.63   thorpej /* Utility routines to manage the array of pointers to timers. */
   1232   1.63   thorpej void
   1233   1.63   thorpej timers_alloc(struct proc *p)
   1234   1.63   thorpej {
   1235   1.63   thorpej 	int i;
   1236   1.63   thorpej 	struct ptimers *pts;
   1237   1.63   thorpej 
   1238  1.100      yamt 	pts = pool_get(&ptimers_pool, PR_WAITOK);
   1239   1.63   thorpej 	LIST_INIT(&pts->pts_virtual);
   1240   1.63   thorpej 	LIST_INIT(&pts->pts_prof);
   1241   1.63   thorpej 	for (i = 0; i < TIMER_MAX; i++)
   1242   1.63   thorpej 		pts->pts_timers[i] = NULL;
   1243   1.64   nathanw 	pts->pts_fired = 0;
   1244   1.63   thorpej 	p->p_timers = pts;
   1245   1.63   thorpej }
   1246   1.63   thorpej 
   1247    1.1       cgd /*
   1248   1.63   thorpej  * Clean up the per-process timers. If "which" is set to TIMERS_ALL,
   1249   1.63   thorpej  * then clean up all timers and free all the data structures. If
   1250   1.63   thorpej  * "which" is set to TIMERS_POSIX, only clean up the timers allocated
   1251   1.63   thorpej  * by timer_create(), not the BSD setitimer() timers, and only free the
   1252   1.63   thorpej  * structure if none of those remain.
   1253    1.1       cgd  */
   1254    1.3    andrew void
   1255   1.63   thorpej timers_free(struct proc *p, int which)
   1256    1.6       cgd {
   1257   1.63   thorpej 	int i, s;
   1258   1.63   thorpej 	struct ptimers *pts;
   1259   1.63   thorpej 	struct ptimer *pt, *ptn;
   1260   1.63   thorpej 	struct timeval tv;
   1261   1.63   thorpej 
   1262   1.63   thorpej 	if (p->p_timers) {
   1263   1.63   thorpej 		pts = p->p_timers;
   1264   1.63   thorpej 		if (which == TIMERS_ALL)
   1265   1.63   thorpej 			i = 0;
   1266   1.63   thorpej 		else {
   1267   1.63   thorpej 			s = splclock();
   1268   1.63   thorpej 			timerclear(&tv);
   1269   1.63   thorpej 			for (ptn = LIST_FIRST(&p->p_timers->pts_virtual);
   1270   1.63   thorpej 			     ptn && ptn != pts->pts_timers[ITIMER_VIRTUAL];
   1271   1.63   thorpej 			     ptn = LIST_NEXT(ptn, pt_list))
   1272   1.63   thorpej 				timeradd(&tv, &ptn->pt_time.it_value, &tv);
   1273   1.63   thorpej 			LIST_FIRST(&p->p_timers->pts_virtual) = NULL;
   1274   1.63   thorpej 			if (ptn) {
   1275   1.63   thorpej 				timeradd(&tv, &ptn->pt_time.it_value,
   1276   1.63   thorpej 				    &ptn->pt_time.it_value);
   1277   1.63   thorpej 				LIST_INSERT_HEAD(&p->p_timers->pts_virtual,
   1278   1.63   thorpej 				    ptn, pt_list);
   1279   1.63   thorpej 			}
   1280   1.63   thorpej 
   1281   1.63   thorpej 			timerclear(&tv);
   1282   1.63   thorpej 			for (ptn = LIST_FIRST(&p->p_timers->pts_prof);
   1283   1.63   thorpej 			     ptn && ptn != pts->pts_timers[ITIMER_PROF];
   1284   1.63   thorpej 			     ptn = LIST_NEXT(ptn, pt_list))
   1285   1.63   thorpej 				timeradd(&tv, &ptn->pt_time.it_value, &tv);
   1286   1.63   thorpej 			LIST_FIRST(&p->p_timers->pts_prof) = NULL;
   1287   1.63   thorpej 			if (ptn) {
   1288   1.63   thorpej 				timeradd(&tv, &ptn->pt_time.it_value,
   1289   1.63   thorpej 				    &ptn->pt_time.it_value);
   1290   1.63   thorpej 				LIST_INSERT_HEAD(&p->p_timers->pts_prof, ptn,
   1291   1.63   thorpej 				    pt_list);
   1292   1.63   thorpej 			}
   1293    1.1       cgd 			splx(s);
   1294   1.63   thorpej 			i = 3;
   1295   1.63   thorpej 		}
   1296   1.63   thorpej 		for ( ; i < TIMER_MAX; i++)
   1297   1.63   thorpej 			if ((pt = pts->pts_timers[i]) != NULL) {
   1298  1.125        ad 				if (pt->pt_type == CLOCK_REALTIME) {
   1299   1.63   thorpej 					callout_stop(&pt->pt_ch);
   1300  1.125        ad 					callout_destroy(&pt->pt_ch);
   1301  1.125        ad 				}
   1302   1.63   thorpej 				pts->pts_timers[i] = NULL;
   1303   1.63   thorpej 				pool_put(&ptimer_pool, pt);
   1304   1.63   thorpej 			}
   1305   1.63   thorpej 		if ((pts->pts_timers[0] == NULL) &&
   1306   1.63   thorpej 		    (pts->pts_timers[1] == NULL) &&
   1307   1.63   thorpej 		    (pts->pts_timers[2] == NULL)) {
   1308   1.63   thorpej 			p->p_timers = NULL;
   1309   1.97    simonb 			pool_put(&ptimers_pool, pts);
   1310    1.1       cgd 		}
   1311    1.1       cgd 	}
   1312    1.1       cgd }
   1313    1.1       cgd 
   1314    1.1       cgd /*
   1315    1.1       cgd  * Decrement an interval timer by a specified number
   1316    1.1       cgd  * of microseconds, which must be less than a second,
   1317    1.1       cgd  * i.e. < 1000000.  If the timer expires, then reload
   1318    1.1       cgd  * it.  In this case, carry over (usec - old value) to
   1319    1.8       cgd  * reduce the value reloaded into the timer so that
   1320    1.1       cgd  * the timer does not drift.  This routine assumes
   1321    1.1       cgd  * that it is called in a context where the timers
   1322    1.1       cgd  * on which it is operating cannot change in value.
   1323    1.1       cgd  */
   1324    1.3    andrew int
   1325   1.63   thorpej itimerdecr(struct ptimer *pt, int usec)
   1326   1.63   thorpej {
   1327   1.45  augustss 	struct itimerval *itp;
   1328    1.1       cgd 
   1329   1.63   thorpej 	itp = &pt->pt_time;
   1330    1.1       cgd 	if (itp->it_value.tv_usec < usec) {
   1331    1.1       cgd 		if (itp->it_value.tv_sec == 0) {
   1332    1.1       cgd 			/* expired, and already in next interval */
   1333    1.1       cgd 			usec -= itp->it_value.tv_usec;
   1334    1.1       cgd 			goto expire;
   1335    1.1       cgd 		}
   1336    1.1       cgd 		itp->it_value.tv_usec += 1000000;
   1337    1.1       cgd 		itp->it_value.tv_sec--;
   1338    1.1       cgd 	}
   1339    1.1       cgd 	itp->it_value.tv_usec -= usec;
   1340    1.1       cgd 	usec = 0;
   1341    1.1       cgd 	if (timerisset(&itp->it_value))
   1342    1.1       cgd 		return (1);
   1343    1.1       cgd 	/* expired, exactly at end of interval */
   1344    1.1       cgd expire:
   1345    1.1       cgd 	if (timerisset(&itp->it_interval)) {
   1346    1.1       cgd 		itp->it_value = itp->it_interval;
   1347    1.1       cgd 		itp->it_value.tv_usec -= usec;
   1348    1.1       cgd 		if (itp->it_value.tv_usec < 0) {
   1349    1.1       cgd 			itp->it_value.tv_usec += 1000000;
   1350    1.1       cgd 			itp->it_value.tv_sec--;
   1351    1.1       cgd 		}
   1352   1.63   thorpej 		timer_settime(pt);
   1353    1.1       cgd 	} else
   1354    1.1       cgd 		itp->it_value.tv_usec = 0;		/* sec is already 0 */
   1355    1.1       cgd 	return (0);
   1356   1.42       cgd }
   1357   1.42       cgd 
   1358   1.63   thorpej void
   1359   1.63   thorpej itimerfire(struct ptimer *pt)
   1360   1.63   thorpej {
   1361   1.63   thorpej 	struct proc *p = pt->pt_proc;
   1362   1.78        cl 
   1363   1.63   thorpej 	if (pt->pt_ev.sigev_notify == SIGEV_SIGNAL) {
   1364   1.63   thorpej 		/*
   1365   1.63   thorpej 		 * No RT signal infrastructure exists at this time;
   1366   1.63   thorpej 		 * just post the signal number and throw away the
   1367   1.63   thorpej 		 * value.
   1368   1.63   thorpej 		 */
   1369  1.113        ad 		if (sigismember(&p->p_sigpend.sp_set, pt->pt_ev.sigev_signo))
   1370   1.63   thorpej 			pt->pt_overruns++;
   1371   1.63   thorpej 		else {
   1372   1.75  christos 			ksiginfo_t ksi;
   1373  1.111      yamt 			KSI_INIT(&ksi);
   1374   1.75  christos 			ksi.ksi_signo = pt->pt_ev.sigev_signo;
   1375   1.75  christos 			ksi.ksi_code = SI_TIMER;
   1376  1.124  christos 			ksi.ksi_value = pt->pt_ev.sigev_value;
   1377   1.63   thorpej 			pt->pt_poverruns = pt->pt_overruns;
   1378   1.63   thorpej 			pt->pt_overruns = 0;
   1379  1.113        ad 			mutex_enter(&proclist_mutex);
   1380   1.75  christos 			kpsignal(p, &ksi, NULL);
   1381  1.113        ad 			mutex_exit(&proclist_mutex);
   1382   1.64   nathanw 		}
   1383   1.63   thorpej 	}
   1384   1.63   thorpej }
   1385   1.63   thorpej 
   1386   1.42       cgd /*
   1387   1.42       cgd  * ratecheck(): simple time-based rate-limit checking.  see ratecheck(9)
   1388   1.42       cgd  * for usage and rationale.
   1389   1.42       cgd  */
   1390   1.42       cgd int
   1391   1.63   thorpej ratecheck(struct timeval *lasttime, const struct timeval *mininterval)
   1392   1.42       cgd {
   1393   1.49    itojun 	struct timeval tv, delta;
   1394  1.101    kardel 	int rv = 0;
   1395  1.101    kardel #ifndef __HAVE_TIMECOUNTER
   1396  1.101    kardel 	int s;
   1397  1.101    kardel #endif
   1398   1.42       cgd 
   1399  1.101    kardel #ifdef __HAVE_TIMECOUNTER
   1400  1.101    kardel 	getmicrouptime(&tv);
   1401  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
   1402   1.63   thorpej 	s = splclock();
   1403   1.49    itojun 	tv = mono_time;
   1404   1.49    itojun 	splx(s);
   1405  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
   1406   1.49    itojun 	timersub(&tv, lasttime, &delta);
   1407   1.42       cgd 
   1408   1.42       cgd 	/*
   1409   1.42       cgd 	 * check for 0,0 is so that the message will be seen at least once,
   1410   1.42       cgd 	 * even if interval is huge.
   1411   1.42       cgd 	 */
   1412   1.42       cgd 	if (timercmp(&delta, mininterval, >=) ||
   1413   1.42       cgd 	    (lasttime->tv_sec == 0 && lasttime->tv_usec == 0)) {
   1414   1.49    itojun 		*lasttime = tv;
   1415   1.42       cgd 		rv = 1;
   1416   1.42       cgd 	}
   1417   1.50    itojun 
   1418   1.50    itojun 	return (rv);
   1419   1.50    itojun }
   1420   1.50    itojun 
   1421   1.50    itojun /*
   1422   1.50    itojun  * ppsratecheck(): packets (or events) per second limitation.
   1423   1.50    itojun  */
   1424   1.50    itojun int
   1425   1.63   thorpej ppsratecheck(struct timeval *lasttime, int *curpps, int maxpps)
   1426   1.50    itojun {
   1427   1.50    itojun 	struct timeval tv, delta;
   1428  1.101    kardel 	int rv;
   1429  1.101    kardel #ifndef __HAVE_TIMECOUNTER
   1430  1.101    kardel 	int s;
   1431  1.101    kardel #endif
   1432   1.50    itojun 
   1433  1.101    kardel #ifdef __HAVE_TIMECOUNTER
   1434  1.101    kardel 	getmicrouptime(&tv);
   1435  1.101    kardel #else /* !__HAVE_TIMECOUNTER */
   1436   1.63   thorpej 	s = splclock();
   1437   1.50    itojun 	tv = mono_time;
   1438   1.50    itojun 	splx(s);
   1439  1.101    kardel #endif /* !__HAVE_TIMECOUNTER */
   1440   1.50    itojun 	timersub(&tv, lasttime, &delta);
   1441   1.50    itojun 
   1442   1.50    itojun 	/*
   1443   1.50    itojun 	 * check for 0,0 is so that the message will be seen at least once.
   1444   1.50    itojun 	 * if more than one second have passed since the last update of
   1445   1.50    itojun 	 * lasttime, reset the counter.
   1446   1.50    itojun 	 *
   1447   1.50    itojun 	 * we do increment *curpps even in *curpps < maxpps case, as some may
   1448   1.50    itojun 	 * try to use *curpps for stat purposes as well.
   1449   1.50    itojun 	 */
   1450   1.50    itojun 	if ((lasttime->tv_sec == 0 && lasttime->tv_usec == 0) ||
   1451   1.50    itojun 	    delta.tv_sec >= 1) {
   1452   1.50    itojun 		*lasttime = tv;
   1453   1.50    itojun 		*curpps = 0;
   1454   1.69    dyoung 	}
   1455   1.69    dyoung 	if (maxpps < 0)
   1456   1.53    itojun 		rv = 1;
   1457   1.53    itojun 	else if (*curpps < maxpps)
   1458   1.50    itojun 		rv = 1;
   1459   1.50    itojun 	else
   1460   1.50    itojun 		rv = 0;
   1461   1.50    itojun 
   1462   1.51     jhawk #if 1 /*DIAGNOSTIC?*/
   1463   1.50    itojun 	/* be careful about wrap-around */
   1464   1.50    itojun 	if (*curpps + 1 > *curpps)
   1465   1.50    itojun 		*curpps = *curpps + 1;
   1466   1.50    itojun #else
   1467   1.50    itojun 	/*
   1468   1.50    itojun 	 * assume that there's not too many calls to this function.
   1469   1.50    itojun 	 * not sure if the assumption holds, as it depends on *caller's*
   1470   1.50    itojun 	 * behavior, not the behavior of this function.
   1471   1.50    itojun 	 * IMHO it is wrong to make assumption on the caller's behavior,
   1472   1.51     jhawk 	 * so the above #if is #if 1, not #ifdef DIAGNOSTIC.
   1473   1.50    itojun 	 */
   1474   1.50    itojun 	*curpps = *curpps + 1;
   1475   1.50    itojun #endif
   1476   1.42       cgd 
   1477   1.42       cgd 	return (rv);
   1478    1.1       cgd }
   1479