X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/8f6c56a50524aa785f7e596d52dddfb331e18961..36401178fd6817c043cc00b0c00c7f723e58efae:/bsd/kern/kern_time.c?ds=sidebyside diff --git a/bsd/kern/kern_time.c b/bsd/kern/kern_time.c index 2948aff98..30b0a651c 100644 --- a/bsd/kern/kern_time.c +++ b/bsd/kern/kern_time.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2007 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * @@ -60,6 +60,12 @@ * * @(#)kern_time.c 8.4 (Berkeley) 5/26/95 */ +/* + * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce + * support for mandatory and extensible security protections. This notice + * is included in support of clause 2.2 (b) of the Apple Public License, + * Version 2.0. + */ #include #include @@ -74,7 +80,11 @@ #include #include +#include #include +#if CONFIG_MACF +#include +#endif #define HZ 100 /* XXX */ @@ -87,15 +97,7 @@ lck_grp_attr_t *tz_slock_grp_attr; static void setthetime( struct timeval *tv); -void time_zone_slock_init(void); - -int gettimeofday(struct proc *p, -#ifdef __ppc__ - struct ppc_gettimeofday_args *uap, -#else - struct gettimeofday_args *uap, -#endif - register_t *retval); +void time_zone_slock_init(void) __attribute__((section("__TEXT, initcode"))); /* * Time of day and interval timer support. @@ -105,52 +107,29 @@ int gettimeofday(struct proc *p, * here provide support for adding and subtracting timeval structures * and decrementing interval timers, optionally reloading the interval * timers when they expire. - * - * XXX Y2038 bug because of clock_get_calendar_microtime() first argument */ /* ARGSUSED */ int -gettimeofday(__unused struct proc *p, -#ifdef __ppc__ - register struct ppc_gettimeofday_args *uap, -#else - register struct gettimeofday_args *uap, -#endif - __unused register_t *retval) +gettimeofday( +__unused struct proc *p, + struct gettimeofday_args *uap, + register_t *retval) { - struct timeval atv; int error = 0; struct timezone ltz; /* local copy */ -/* NOTE THIS implementation is for non ppc architectures only */ - - if (uap->tp) { - clock_get_calendar_microtime((uint32_t *)&atv.tv_sec, &atv.tv_usec); - if (IS_64BIT_PROCESS(p)) { - struct user_timeval user_atv; - user_atv.tv_sec = atv.tv_sec; - user_atv.tv_usec = atv.tv_usec; - /* - * This cast is not necessary for PPC, but is - * mostly harmless. - */ - error = copyout(&user_atv, CAST_USER_ADDR_T(uap->tp), sizeof(struct user_timeval)); - } else { - error = copyout(&atv, CAST_USER_ADDR_T(uap->tp), sizeof(struct timeval)); - } - if (error) - return(error); - } + if (uap->tp) + clock_gettimeofday((uint32_t *)&retval[0], (uint32_t *)&retval[1]); if (uap->tzp) { lck_spin_lock(tz_slock); ltz = tz; lck_spin_unlock(tz_slock); - error = copyout((caddr_t)<z, CAST_USER_ADDR_T(uap->tzp), - sizeof (tz)); + + error = copyout((caddr_t)<z, CAST_USER_ADDR_T(uap->tzp), sizeof (tz)); } - return(error); + return (error); } /* @@ -158,14 +137,21 @@ gettimeofday(__unused struct proc *p, */ /* ARGSUSED */ int -settimeofday(struct proc *p, struct settimeofday_args *uap, __unused register_t *retval) +settimeofday(__unused struct proc *p, struct settimeofday_args *uap, __unused register_t *retval) { struct timeval atv; struct timezone atz; int error; +#if CONFIG_MACF + error = mac_system_check_settime(kauth_cred_get()); + if (error) + return (error); +#endif +#ifndef CONFIG_EMBEDDED if ((error = suser(kauth_cred_get(), &p->p_acflag))) return (error); +#endif /* Verify all parameters before changing time */ if (uap->tv) { if (IS_64BIT_PROCESS(p)) { @@ -207,11 +193,16 @@ setthetime( */ /* ARGSUSED */ int -adjtime(struct proc *p, register struct adjtime_args *uap, __unused register_t *retval) +adjtime(struct proc *p, struct adjtime_args *uap, __unused register_t *retval) { struct timeval atv; int error; +#if CONFIG_MACF + error = mac_system_check_settime(kauth_cred_get()); + if (error) + return (error); +#endif if ((error = suser(kauth_cred_get(), &p->p_acflag))) return (error); if (IS_64BIT_PROCESS(p)) { @@ -292,26 +283,32 @@ uint64_t tvtoabstime(struct timeval *tvp); * 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 callout - * routine. Since a callout may be delayed in real time due to + * The real time timer is processed by a callout routine. + * Since a callout may be delayed in real time due to * other processing in the system, it is possible for the real * time callout 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 time .it_value from the * real time .it_interval. Rather, we compute the next time in * absolute time when the timer should go off. + * + * Returns: 0 Success + * EINVAL Invalid argument + * copyout:EFAULT Bad address */ - /* ARGSUSED */ int -getitimer(struct proc *p, register struct getitimer_args *uap, __unused register_t *retval) +getitimer(struct proc *p, struct getitimer_args *uap, __unused register_t *retval) { struct itimerval aitv; if (uap->which > ITIMER_PROF) return(EINVAL); - if (uap->which == ITIMER_REAL) { + + proc_spinlock(p); + switch (uap->which) { + + case ITIMER_REAL: /* * If time for real time timer has passed return 0, * else return difference between current time and @@ -331,9 +328,18 @@ getitimer(struct proc *p, register struct getitimer_args *uap, __unused register } else timerclear(&aitv.it_value); + break; + + case ITIMER_VIRTUAL: + aitv = p->p_vtimer_user; + break; + + case ITIMER_PROF: + aitv = p->p_vtimer_prof; + break; } - else - aitv = p->p_stats->p_timer[uap->which]; + + proc_spinunlock(p); if (IS_64BIT_PROCESS(p)) { struct user_itimerval user_itv; @@ -347,12 +353,16 @@ getitimer(struct proc *p, register struct getitimer_args *uap, __unused register } } +/* + * Returns: 0 Success + * EINVAL Invalid argument + * copyin:EFAULT Bad address + * getitimer:EINVAL Invalid argument + * getitimer:EFAULT Bad address + */ /* ARGSUSED */ int -setitimer(p, uap, retval) - struct proc *p; - register struct setitimer_args *uap; - register_t *retval; +setitimer(struct proc *p, struct setitimer_args *uap, register_t *retval) { struct itimerval aitv; user_addr_t itvp; @@ -380,22 +390,50 @@ setitimer(p, uap, retval) return (0); if (itimerfix(&aitv.it_value) || itimerfix(&aitv.it_interval)) return (EINVAL); - if (uap->which == ITIMER_REAL) { - thread_call_func_cancel((thread_call_func_t)realitexpire, (void *)p->p_pid, FALSE); + + switch (uap->which) { + + case ITIMER_REAL: + proc_spinlock(p); if (timerisset(&aitv.it_value)) { microuptime(&p->p_rtime); timevaladd(&p->p_rtime, &aitv.it_value); - thread_call_func_delayed( - (thread_call_func_t)realitexpire, (void *)p->p_pid, - tvtoabstime(&p->p_rtime)); + p->p_realtimer = aitv; + if (!thread_call_enter_delayed(p->p_rcall, tvtoabstime(&p->p_rtime))) + p->p_ractive++; + } else { + timerclear(&p->p_rtime); + p->p_realtimer = aitv; + if (thread_call_cancel(p->p_rcall)) + p->p_ractive--; } + proc_spinunlock(p); + + break; + + + case ITIMER_VIRTUAL: + if (timerisset(&aitv.it_value)) + task_vtimer_set(p->task, TASK_VTIMER_USER); + else + task_vtimer_clear(p->task, TASK_VTIMER_USER); + + proc_spinlock(p); + p->p_vtimer_user = aitv; + proc_spinunlock(p); + break; + + case ITIMER_PROF: + if (timerisset(&aitv.it_value)) + task_vtimer_set(p->task, TASK_VTIMER_PROF); else - timerclear(&p->p_rtime); + task_vtimer_clear(p->task, TASK_VTIMER_PROF); - p->p_realtimer = aitv; + proc_spinlock(p); + p->p_vtimer_prof = aitv; + proc_spinunlock(p); + break; } - else - p->p_stats->p_timer[uap->which] = aitv; return (0); } @@ -410,66 +448,68 @@ setitimer(p, uap, retval) */ void realitexpire( - void *pid) + struct proc *p) { - register struct proc *p; - struct timeval now; - boolean_t funnel_state; - - funnel_state = thread_funnel_set(kernel_flock, TRUE); - p = pfind((pid_t)pid); - if (p == NULL) { - (void) thread_funnel_set(kernel_flock, FALSE); + struct proc *r; + struct timeval t; + + r = proc_find(p->p_pid); + + proc_spinlock(p); + + if (--p->p_ractive > 0 || r != p) { + proc_spinunlock(p); + + if (r != NULL) + proc_rele(r); return; } - + if (!timerisset(&p->p_realtimer.it_interval)) { timerclear(&p->p_rtime); - psignal(p, SIGALRM); + proc_spinunlock(p); - (void) thread_funnel_set(kernel_flock, FALSE); + psignal(p, SIGALRM); + proc_rele(p); return; } - microuptime(&now); + microuptime(&t); timevaladd(&p->p_rtime, &p->p_realtimer.it_interval); - if (timercmp(&p->p_rtime, &now, <=)) { - if ((p->p_rtime.tv_sec + 2) >= now.tv_sec) { + if (timercmp(&p->p_rtime, &t, <=)) { + if ((p->p_rtime.tv_sec + 2) >= t.tv_sec) { for (;;) { timevaladd(&p->p_rtime, &p->p_realtimer.it_interval); - if (timercmp(&p->p_rtime, &now, >)) + if (timercmp(&p->p_rtime, &t, >)) break; } } else { p->p_rtime = p->p_realtimer.it_interval; - timevaladd(&p->p_rtime, &now); + timevaladd(&p->p_rtime, &t); } } - psignal(p, SIGALRM); - - thread_call_func_delayed((thread_call_func_t)realitexpire, pid, tvtoabstime(&p->p_rtime)); + if (!thread_call_enter_delayed(p->p_rcall, tvtoabstime(&p->p_rtime))) + p->p_ractive++; + proc_spinunlock(p); - (void) thread_funnel_set(kernel_flock, FALSE); + psignal(p, SIGALRM); + proc_rele(p); } /* * 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.) + * .it_interval part of an interval timer is acceptable. */ int -itimerfix(tv) - struct timeval *tv; +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); } @@ -478,17 +518,18 @@ itimerfix(tv) * 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 - * reducint the value reloaded into the timer so that + * 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(itp, usec) - register struct itimerval *itp; - int usec; +itimerdecr(proc_t p, + struct itimerval *itp, int usec) { + proc_spinlock(p); + if (itp->it_value.tv_usec < usec) { if (itp->it_value.tv_sec == 0) { /* expired, and already in next interval */ @@ -500,19 +541,24 @@ itimerdecr(itp, usec) } itp->it_value.tv_usec -= usec; usec = 0; - if (timerisset(&itp->it_value)) + if (timerisset(&itp->it_value)) { + proc_spinunlock(p); return (1); + } /* expired, exactly at end of interval */ expire: if (timerisset(&itp->it_interval)) { itp->it_value = itp->it_interval; + if (itp->it_value.tv_sec > 0) { 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 */ + proc_spinunlock(p); return (0); } @@ -566,14 +612,14 @@ void microtime( struct timeval *tvp) { - clock_get_calendar_microtime((uint32_t *)&tvp->tv_sec, &tvp->tv_usec); + clock_get_calendar_microtime((uint32_t *)&tvp->tv_sec, (uint32_t *)&tvp->tv_usec); } void microuptime( struct timeval *tvp) { - clock_get_system_microtime((uint32_t *)&tvp->tv_sec, &tvp->tv_usec); + clock_get_system_microtime((uint32_t *)&tvp->tv_sec, (uint32_t *)&tvp->tv_usec); } /* @@ -611,15 +657,12 @@ time_zone_slock_init(void) { /* allocate lock group attribute and group */ tz_slock_grp_attr = lck_grp_attr_alloc_init(); - lck_grp_attr_setstat(tz_slock_grp_attr); tz_slock_grp = lck_grp_alloc_init("tzlock", tz_slock_grp_attr); /* Allocate lock attribute */ tz_slock_attr = lck_attr_alloc_init(); - //lck_attr_setdebug(tz_slock_attr); /* Allocate the spin lock */ tz_slock = lck_spin_alloc_init(tz_slock_grp, tz_slock_attr); } -