X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/a3d08fcd5120d2aa8303b6349ca8b14e3f284af3..91447636331957f3d9b5ca5b508f07c526b0074d:/bsd/kern/kern_time.c diff --git a/bsd/kern/kern_time.c b/bsd/kern/kern_time.c index 0a4d9e52e..07354b8b7 100644 --- a/bsd/kern/kern_time.c +++ b/bsd/kern/kern_time.c @@ -59,18 +59,38 @@ #include #include #include -#include +#include +#include #include -#include +#include +#include +#include #include +#include #define HZ 100 /* XXX */ -volatile struct timeval time; /* simple lock used to access timezone, tz structure */ -decl_simple_lock_data(, tz_slock); +lck_spin_t * tz_slock; +lck_grp_t * tz_slock_grp; +lck_attr_t * tz_slock_attr; +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); + /* * Time of day and interval timer support. * @@ -79,177 +99,183 @@ decl_simple_lock_data(, tz_slock); * 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 */ -struct gettimeofday_args{ - struct timeval *tp; - struct timezone *tzp; -}; /* ARGSUSED */ int -gettimeofday(p, uap, retval) - struct proc *p; - register struct gettimeofday_args *uap; - register_t *retval; +gettimeofday(__unused struct proc *p, +#ifdef __ppc__ + register struct ppc_gettimeofday_args *uap, +#else + register struct gettimeofday_args *uap, +#endif + __unused register_t *retval) { struct timeval atv; int error = 0; - extern simple_lock_data_t tz_slock; struct timezone ltz; /* local copy */ /* NOTE THIS implementation is for non ppc architectures only */ if (uap->tp) { - clock_get_calendar_microtime(&atv.tv_sec, &atv.tv_usec); - if (error = copyout((caddr_t)&atv, (caddr_t)uap->tp, - sizeof (atv))) + 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->tzp) { - usimple_lock(&tz_slock); + lck_spin_lock(tz_slock); ltz = tz; - usimple_unlock(&tz_slock); - error = copyout((caddr_t)<z, (caddr_t)uap->tzp, + lck_spin_unlock(tz_slock); + error = copyout((caddr_t)<z, CAST_USER_ADDR_T(uap->tzp), sizeof (tz)); } return(error); } -struct settimeofday_args { - struct timeval *tv; - struct timezone *tzp; -}; +/* + * XXX Y2038 bug because of setthetime() argument + */ /* ARGSUSED */ int -settimeofday(p, uap, retval) - struct proc *p; - struct settimeofday_args *uap; - register_t *retval; +settimeofday(struct proc *p, struct settimeofday_args *uap, __unused register_t *retval) { struct timeval atv; struct timezone atz; - int error, s; - extern simple_lock_data_t tz_slock; + int error; - if (error = suser(p->p_ucred, &p->p_acflag)) - return (error); - /* Verify all parameters before changing time. */ - if (uap->tv && (error = copyin((caddr_t)uap->tv, - (caddr_t)&atv, sizeof(atv)))) + if ((error = suser(kauth_cred_get(), &p->p_acflag))) return (error); - if (uap->tzp && (error = copyin((caddr_t)uap->tzp, - (caddr_t)&atz, sizeof(atz)))) + /* Verify all parameters before changing time */ + if (uap->tv) { + if (IS_64BIT_PROCESS(p)) { + struct user_timeval user_atv; + error = copyin(uap->tv, &user_atv, sizeof(struct user_timeval)); + atv.tv_sec = user_atv.tv_sec; + atv.tv_usec = user_atv.tv_usec; + } else { + error = copyin(uap->tv, &atv, sizeof(struct timeval)); + } + if (error) + return (error); + } + if (uap->tzp && (error = copyin(uap->tzp, (caddr_t)&atz, sizeof(atz)))) return (error); - if (uap->tv) + if (uap->tv) { + timevalfix(&atv); + if (atv.tv_sec < 0 || (atv.tv_sec == 0 && atv.tv_usec < 0)) + return (EPERM); setthetime(&atv); + } if (uap->tzp) { - usimple_lock(&tz_slock); + lck_spin_lock(tz_slock); tz = atz; - usimple_unlock(&tz_slock); + lck_spin_unlock(tz_slock); } return (0); } -setthetime(tv) - struct timeval *tv; +static void +setthetime( + struct timeval *tv) { - long delta = tv->tv_sec - time.tv_sec; - clock_set_calendar_microtime(tv->tv_sec, tv->tv_usec); - boottime.tv_sec += delta; -#if NFSCLIENT || NFSSERVER - lease_updatetime(delta); -#endif } -struct adjtime_args { - struct timeval *delta; - struct timeval *olddelta; -}; +/* + * XXX Y2038 bug because of clock_adjtime() first argument + */ /* ARGSUSED */ int -adjtime(p, uap, retval) - struct proc *p; - register struct adjtime_args *uap; - register_t *retval; +adjtime(struct proc *p, register struct adjtime_args *uap, __unused register_t *retval) { struct timeval atv; int error; - if (error = suser(p->p_ucred, &p->p_acflag)) + if ((error = suser(kauth_cred_get(), &p->p_acflag))) return (error); - if (error = copyin((caddr_t)uap->delta, - (caddr_t)&atv, sizeof (struct timeval))) + if (IS_64BIT_PROCESS(p)) { + struct user_timeval user_atv; + error = copyin(uap->delta, &user_atv, sizeof(struct user_timeval)); + atv.tv_sec = user_atv.tv_sec; + atv.tv_usec = user_atv.tv_usec; + } else { + error = copyin(uap->delta, &atv, sizeof(struct timeval)); + } + if (error) return (error); - /* - * Compute the total correction and the rate at which to apply it. - */ - clock_adjtime(&atv.tv_sec, &atv.tv_usec); + /* + * Compute the total correction and the rate at which to apply it. + */ + clock_adjtime((int32_t *)&atv.tv_sec, &atv.tv_usec); if (uap->olddelta) { - (void) copyout((caddr_t)&atv, - (caddr_t)uap->olddelta, sizeof (struct timeval)); + if (IS_64BIT_PROCESS(p)) { + struct user_timeval user_atv; + user_atv.tv_sec = atv.tv_sec; + user_atv.tv_usec = atv.tv_usec; + error = copyout(&user_atv, uap->olddelta, sizeof(struct user_timeval)); + } else { + error = copyout(&atv, uap->olddelta, sizeof(struct timeval)); + } } return (0); } /* - * Initialze the time of day register. - * Trust the RTC except for the case where it is set before - * the UNIX epoch. In that case use the the UNIX epoch. - * The argument passed in is ignored. + * Verify the calendar value. If negative, + * reset to zero (the epoch). */ void -inittodr(base) - time_t base; +inittodr( + __unused time_t base) { struct timeval tv; /* * Assertion: * The calendar has already been - * set up from the battery clock. + * set up from the platform clock. * * The value returned by microtime() * is gotten from the calendar. */ microtime(&tv); - time = tv; - boottime.tv_sec = tv.tv_sec; - boottime.tv_usec = 0; - - /* - * If the RTC does not have acceptable value, i.e. time before - * the UNIX epoch, set it to the UNIX epoch - */ - if (tv.tv_sec < 0) { + if (tv.tv_sec < 0 || tv.tv_usec < 0) { printf ("WARNING: preposterous time in Real Time Clock"); - time.tv_sec = 0; /* the UNIX epoch */ - time.tv_usec = 0; - setthetime(&time); - boottime = time; + tv.tv_sec = 0; /* the UNIX epoch */ + tv.tv_usec = 0; + setthetime(&tv); printf(" -- CHECK AND RESET THE DATE!\n"); } - - return; } -void timevaladd( - struct timeval *t1, - struct timeval *t2); -void timevalsub( - struct timeval *t1, - struct timeval *t2); -void timevalfix( - struct timeval *t1); +time_t +boottime_sec(void) +{ + uint32_t sec, nanosec; + clock_get_boottime_nanotime(&sec, &nanosec); + return (sec); +} -uint64_t - tvtoabstime( - struct timeval *tvp); +uint64_t tvtoabstime(struct timeval *tvp); /* * Get value of an interval timer. The process virtual and @@ -271,16 +297,9 @@ uint64_t * absolute time when the timer should go off. */ -struct getitimer_args { - u_int which; - struct itimerval *itv; -}; /* ARGSUSED */ int -getitimer(p, uap, retval) - struct proc *p; - register struct getitimer_args *uap; - register_t *retval; +getitimer(struct proc *p, register struct getitimer_args *uap, __unused register_t *retval) { struct itimerval aitv; @@ -310,15 +329,18 @@ getitimer(p, uap, retval) else aitv = p->p_stats->p_timer[uap->which]; - return (copyout((caddr_t)&aitv, - (caddr_t)uap->itv, sizeof (struct itimerval))); + if (IS_64BIT_PROCESS(p)) { + struct user_itimerval user_itv; + user_itv.it_interval.tv_sec = aitv.it_interval.tv_sec; + user_itv.it_interval.tv_usec = aitv.it_interval.tv_usec; + user_itv.it_value.tv_sec = aitv.it_value.tv_sec; + user_itv.it_value.tv_usec = aitv.it_value.tv_usec; + return (copyout((caddr_t)&user_itv, uap->itv, sizeof (struct user_itimerval))); + } else { + return (copyout((caddr_t)&aitv, uap->itv, sizeof (struct itimerval))); + } } -struct setitimer_args { - u_int which; - struct itimerval *itv; - struct itimerval *oitv; -}; /* ARGSUSED */ int setitimer(p, uap, retval) @@ -327,28 +349,38 @@ setitimer(p, uap, retval) register_t *retval; { struct itimerval aitv; - register struct itimerval *itvp; + user_addr_t itvp; int error; if (uap->which > ITIMER_PROF) return (EINVAL); - if ((itvp = uap->itv) && - (error = copyin((caddr_t)itvp, - (caddr_t)&aitv, sizeof (struct itimerval)))) - return (error); - if ((uap->itv = uap->oitv) && (error = getitimer(p, uap, retval))) + if ((itvp = uap->itv)) { + if (IS_64BIT_PROCESS(p)) { + struct user_itimerval user_itv; + if ((error = copyin(itvp, (caddr_t)&user_itv, sizeof (struct user_itimerval)))) + return (error); + aitv.it_interval.tv_sec = user_itv.it_interval.tv_sec; + aitv.it_interval.tv_usec = user_itv.it_interval.tv_usec; + aitv.it_value.tv_sec = user_itv.it_value.tv_sec; + aitv.it_value.tv_usec = user_itv.it_value.tv_usec; + } else { + if ((error = copyin(itvp, (caddr_t)&aitv, sizeof (struct itimerval)))) + return (error); + } + } + if ((uap->itv = uap->oitv) && (error = getitimer(p, (struct getitimer_args *)uap, retval))) return (error); if (itvp == 0) return (0); if (itimerfix(&aitv.it_value) || itimerfix(&aitv.it_interval)) return (EINVAL); if (uap->which == ITIMER_REAL) { - thread_call_func_cancel(realitexpire, (void *)p->p_pid, FALSE); + thread_call_func_cancel((thread_call_func_t)realitexpire, (void *)p->p_pid, FALSE); if (timerisset(&aitv.it_value)) { microuptime(&p->p_rtime); timevaladd(&p->p_rtime, &aitv.it_value); thread_call_func_delayed( - realitexpire, (void *)p->p_pid, + (thread_call_func_t)realitexpire, (void *)p->p_pid, tvtoabstime(&p->p_rtime)); } else @@ -376,8 +408,9 @@ realitexpire( { register struct proc *p; struct timeval now; - boolean_t funnel_state = thread_funnel_set(kernel_flock, TRUE); + 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); @@ -410,7 +443,7 @@ realitexpire( psignal(p, SIGALRM); - thread_call_func_delayed(realitexpire, pid, tvtoabstime(&p->p_rtime)); + thread_call_func_delayed((thread_call_func_t)realitexpire, pid, tvtoabstime(&p->p_rtime)); (void) thread_funnel_set(kernel_flock, FALSE); } @@ -527,14 +560,14 @@ void microtime( struct timeval *tvp) { - clock_get_calendar_microtime(&tvp->tv_sec, &tvp->tv_usec); + clock_get_calendar_microtime((uint32_t *)&tvp->tv_sec, &tvp->tv_usec); } void microuptime( struct timeval *tvp) { - clock_get_system_microtime(&tvp->tv_sec, &tvp->tv_usec); + clock_get_system_microtime((uint32_t *)&tvp->tv_sec, &tvp->tv_usec); } /* @@ -544,14 +577,14 @@ void nanotime( struct timespec *tsp) { - clock_get_calendar_nanotime((uint32_t *)&tsp->tv_sec, &tsp->tv_nsec); + clock_get_calendar_nanotime((uint32_t *)&tsp->tv_sec, (uint32_t *)&tsp->tv_nsec); } void nanouptime( struct timespec *tsp) { - clock_get_system_nanotime((uint32_t *)&tsp->tv_sec, &tsp->tv_nsec); + clock_get_system_nanotime((uint32_t *)&tsp->tv_sec, (uint32_t *)&tsp->tv_nsec); } uint64_t @@ -570,9 +603,17 @@ tvtoabstime( void time_zone_slock_init(void) { - extern simple_lock_data_t tz_slock; + /* allocate lock group attribute and group */ + tz_slock_grp_attr = lck_grp_attr_alloc_init(); + lck_grp_attr_setstat(tz_slock_grp_attr); - simple_lock_init(&tz_slock); + 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); } +