/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
*
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
*
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*-
* HISTORY
*/
-#include <machine/spl.h>
-
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/time.h>
-#include <sys/dkstat.h>
#include <sys/resourcevar.h>
#include <sys/kernel.h>
#include <sys/resource.h>
-#include <sys/proc.h>
+#include <sys/proc_internal.h>
#include <sys/vm.h>
+#include <sys/sysctl.h>
#ifdef GPROF
#include <sys/gmon.h>
#include <kern/thread_call.h>
+void bsd_uprofil(struct time_value *syst, user_addr_t pc);
+int tvtohz(struct timeval *tv);
+
/*
* Clock handling routines.
*
/*
* The hz hardware interval timer.
- * We update the events relating to real time.
- * If this timer is also being used to gather statistics,
- * we run through the statistics gathering routine as well.
*/
-int bsd_hardclockinit = 0;
-/*ARGSUSED*/
-void
-bsd_hardclock(usermode, pc, numticks)
- boolean_t usermode;
- caddr_t pc;
- int numticks;
-{
- register struct proc *p;
- register int s;
- int ticks = numticks;
- extern int tickdelta;
- extern long timedelta;
- register thread_t thread;
- int nusecs = numticks * tick;
-
- if (!bsd_hardclockinit)
- return;
-
- thread = current_thread();
-
- /*
- * Charge the time out based on the mode the cpu is in.
- * Here again we fudge for the lack of proper interval timers
- * assuming that the current state has been around at least
- * one tick.
- */
- p = (struct proc *)get_bsdtask_info(current_task());
- if (p && ((p->p_flag & P_WEXIT) == NULL)) {
- if (usermode) {
- if (p) {
- if (p->p_stats && p->p_stats->p_prof.pr_scale) {
- p->p_flag |= P_OWEUPC;
- ast_on(AST_BSD);
- }
- }
-
- /*
- * CPU was in user state. Increment
- * user time counter, and process process-virtual time
- * interval timer.
- */
- if (p->p_stats &&
- timerisset(&p->p_stats->p_timer[ITIMER_VIRTUAL].it_value) &&
- itimerdecr(&p->p_stats->p_timer[ITIMER_VIRTUAL], nusecs) == 0) {
- extern void psignal_vtalarm(struct proc *);
-
- /* does psignal(p, SIGVTALRM) in a thread context */
- thread_call_func((thread_call_func_t)psignal_vtalarm, p, FALSE);
- }
- }
-
- /*
- * If the cpu is currently scheduled to a process, then
- * charge it with resource utilization for a tick, updating
- * statistics which run in (user+system) virtual time,
- * such as the cpu time limit and profiling timers.
- * This assumes that the current process has been running
- * the entire last tick.
- */
- if (p && !(is_thread_idle(thread)))
- {
- if (p->p_limit && (p->p_limit->pl_rlimit[RLIMIT_CPU].rlim_cur != RLIM_INFINITY)) {
- time_value_t sys_time, user_time;
-
- thread_read_times(thread, &user_time, &sys_time);
- if ((sys_time.seconds + user_time.seconds + 1) >
- p->p_limit->pl_rlimit[RLIMIT_CPU].rlim_cur) {
- extern void psignal_xcpu(struct proc *);
-
- /* does psignal(p, SIGXCPU) in a thread context */
- thread_call_func((thread_call_func_t)psignal_xcpu, p, FALSE);
-
- if (p->p_limit->pl_rlimit[RLIMIT_CPU].rlim_cur <
- p->p_limit->pl_rlimit[RLIMIT_CPU].rlim_max)
- p->p_limit->pl_rlimit[RLIMIT_CPU].rlim_cur += 5;
- }
- }
- if (timerisset(&p->p_stats->p_timer[ITIMER_PROF].it_value) &&
- itimerdecr(&p->p_stats->p_timer[ITIMER_PROF], nusecs) == 0) {
- extern void psignal_sigprof(struct proc *);
-
- /* does psignal(p, SIGPROF) in a thread context */
- thread_call_func((thread_call_func_t)psignal_sigprof, p, FALSE);
- }
- }
+int hz = 100; /* GET RID OF THIS !!! */
+int tick = (1000000 / 100); /* GET RID OF THIS !!! */
- /*
- * Increment the time-of-day, and schedule
- * processing of the callouts at a very low cpu priority,
- * so we don't keep the relatively high clock interrupt
- * priority any longer than necessary.
- */
+/*
+ * Kernel timeout services.
+ */
- /*
- * Gather the statistics.
- */
- gatherstats(usermode, pc);
+/*
+ * Set a timeout.
+ *
+ * fcn: function to call
+ * param: parameter to pass to function
+ * interval: timeout interval, in hz.
+ */
+void
+timeout(
+ timeout_fcn_t fcn,
+ void *param,
+ int interval)
+{
+ uint64_t deadline;
- }
- if (timedelta != 0) {
- register delta;
- clock_res_t nsdelta = tickdelta * NSEC_PER_USEC;
-
- if (timedelta < 0) {
- delta = ticks - tickdelta;
- timedelta += tickdelta;
- nsdelta = -nsdelta;
- } else {
- delta = ticks + tickdelta;
- timedelta -= tickdelta;
- }
- clock_adjust_calendar(nsdelta);
- }
- microtime(&time);
+ clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, &deadline);
+ thread_call_func_delayed((thread_call_func_t)fcn, param, deadline);
}
/*
- * Gather statistics on resource utilization.
+ * Set a timeout with leeway.
*
- * We make a gross assumption: that the system has been in the
- * state it is in (user state, kernel state, interrupt state,
- * or idle state) for the entire last time interval, and
- * update statistics accordingly.
+ * fcn: function to call
+ * param: parameter to pass to function
+ * interval: timeout interval, in hz.
+ * leeway_interval: leeway interval, in hz.
*/
-/*ARGSUSED*/
void
-gatherstats(usermode, pc)
- boolean_t usermode;
- caddr_t pc;
+timeout_with_leeway(
+ timeout_fcn_t fcn,
+ void *param,
+ int interval,
+ int leeway_interval)
{
- register int cpstate, s;
- struct proc *proc =current_proc();
-#ifdef GPROF
- struct gmonparam *p = &_gmonparam;
-#endif
+ uint64_t deadline;
+ uint64_t leeway;
- /*
- * Determine what state the cpu is in.
- */
- if (usermode) {
- /*
- * CPU was in user state.
- */
- if (proc->p_nice > NZERO)
- cpstate = CP_NICE;
- else
- cpstate = CP_USER;
- } else {
- /*
- * CPU was in system state. If profiling kernel
- * increment a counter. If no process is running
- * then this is a system tick if we were running
- * at a non-zero IPL (in a driver). If a process is running,
- * then we charge it with system time even if we were
- * at a non-zero IPL, since the system often runs
- * this way during processing of system calls.
- * This is approximate, but the lack of true interval
- * timers makes doing anything else difficult.
- */
- cpstate = CP_SYS;
- if (is_thread_idle(current_thread()))
- cpstate = CP_IDLE;
-#ifdef GPROF
- if (p->state == GMON_PROF_ON) {
- s = pc - p->lowpc;
- if (s < p->textsize) {
- s /= (HISTFRACTION * sizeof(*p->kcount));
- p->kcount[s]++;
- }
- }
-#endif
- }
- /*
- * We maintain statistics shown by user-level statistics
- * programs: the amount of time in each cpu state, and
- * the amount of time each of DK_NDRIVE ``drives'' is busy.
- */
- cp_time[cpstate]++;
- for (s = 0; s < DK_NDRIVE; s++)
- if (dk_busy & (1 << s))
- dk_time[s]++;
-}
+ clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, &deadline);
+
+ clock_interval_to_absolutetime_interval(leeway_interval, NSEC_PER_SEC / hz, &leeway);
+ thread_call_func_delayed_with_leeway((thread_call_func_t)fcn, param, deadline, leeway, THREAD_CALL_DELAY_LEEWAY);
+}
/*
- * Kernel timeout services.
+ * Cancel a timeout.
+ * Deprecated because it's very inefficient.
+ * Switch to an allocated thread call instead.
*/
+void
+untimeout(
+ timeout_fcn_t fcn,
+ void *param)
+{
+ thread_call_func_cancel((thread_call_func_t)fcn, param, FALSE);
+}
+
/*
* Set a timeout.
*
* fcn: function to call
* param: parameter to pass to function
- * interval: timeout interval, in hz.
+ * ts: timeout interval, in timespec
*/
void
-timeout(
+bsd_timeout(
timeout_fcn_t fcn,
void *param,
- int interval)
+ struct timespec *ts)
{
- AbsoluteTime deadline;
+ uint64_t deadline = 0;
- clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, &deadline);
+ if (ts && (ts->tv_sec || ts->tv_nsec)) {
+ nanoseconds_to_absolutetime((uint64_t)ts->tv_sec * NSEC_PER_SEC + ts->tv_nsec, &deadline );
+ clock_absolutetime_interval_to_deadline( deadline, &deadline );
+ }
thread_call_func_delayed((thread_call_func_t)fcn, param, deadline);
}
/*
* Cancel a timeout.
+ * Deprecated because it's very inefficient.
+ * Switch to an allocated thread call instead.
*/
void
-untimeout(
- register timeout_fcn_t fcn,
- register void *param)
+bsd_untimeout(
+ timeout_fcn_t fcn,
+ void *param)
{
thread_call_func_cancel((thread_call_func_t)fcn, param, FALSE);
}
-
/*
* Compute number of hz until specified time.
* Used to compute third argument to timeout() from an
* absolute time.
*/
-hzto(tv)
- struct timeval *tv;
+int
+hzto(struct timeval *tv)
{
- register long ticks;
- register long sec;
- int s = splhigh();
-
+ struct timeval now;
+ long ticks;
+ long sec;
+
+ microtime(&now);
/*
* If number of milliseconds will fit in 32 bit arithmetic,
* then compute number of milliseconds to time and scale to
* Delta times less than 25 days can be computed ``exactly''.
* Maximum value for any timeout in 10ms ticks is 250 days.
*/
- sec = tv->tv_sec - time.tv_sec;
+ sec = tv->tv_sec - now.tv_sec;
if (sec <= 0x7fffffff / 1000 - 1000)
- ticks = ((tv->tv_sec - time.tv_sec) * 1000 +
- (tv->tv_usec - time.tv_usec) / 1000)
+ ticks = ((tv->tv_sec - now.tv_sec) * 1000 +
+ (tv->tv_usec - now.tv_usec) / 1000)
/ (tick / 1000);
else if (sec <= 0x7fffffff / hz)
ticks = sec * hz;
else
ticks = 0x7fffffff;
- splx(s);
- return (ticks);
-}
-#if 0 /* [ */
-/*
- * Convert ticks to a timeval
- */
-ticks_to_timeval(ticks, tvp)
- register long ticks;
- struct timeval *tvp;
-{
- tvp->tv_sec = ticks/hz;
- tvp->tv_usec = (ticks%hz) * tick;
- asert(tvp->tv_usec < 1000000);
+ return (ticks);
}
-#endif /* ] */
/*
* Return information about system clocks.
*/
-int
-sysctl_clockrate(where, sizep)
- register char *where;
- size_t *sizep;
+static int
+sysctl_clockrate
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, __unused struct sysctl_req *req)
{
- struct clockinfo clkinfo;
-
- /*
- * Construct clockinfo structure.
- */
- clkinfo.hz = hz;
- clkinfo.tick = tick;
- clkinfo.profhz = hz;
- clkinfo.stathz = hz;
- return sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo));
+ struct clockinfo clkinfo = {
+ .hz = hz,
+ .tick = tick,
+ .tickadj = 0,
+ .stathz = hz,
+ .profhz = hz,
+ };
+
+ return sysctl_io_opaque(req, &clkinfo, sizeof(clkinfo), NULL);
}
+SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate,
+ CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
+ 0, 0, sysctl_clockrate, "S,clockinfo", "");
+
/*
* Compute number of ticks in the specified amount of time.
*/
int
-tvtohz(tv)
- struct timeval *tv;
+tvtohz(struct timeval *tv)
{
- register unsigned long ticks;
- register long sec, usec;
+ unsigned long ticks;
+ long sec, usec;
/*
* If the number of usecs in the whole seconds part of the time
* keeps the profile clock running constantly.
*/
void
-startprofclock(p)
- register struct proc *p;
+startprofclock(struct proc *p)
{
if ((p->p_flag & P_PROFIL) == 0)
- p->p_flag |= P_PROFIL;
+ OSBitOrAtomic(P_PROFIL, &p->p_flag);
}
/*
* Stop profiling on a process.
*/
void
-stopprofclock(p)
- register struct proc *p;
+stopprofclock(struct proc *p)
{
if (p->p_flag & P_PROFIL)
- p->p_flag &= ~P_PROFIL;
+ OSBitAndAtomic(~((uint32_t)P_PROFIL), &p->p_flag);
}
+/* TBD locking user profiling is not resolved yet */
void
-bsd_uprofil(struct time_value *syst, unsigned int pc)
+bsd_uprofil(struct time_value *syst, user_addr_t pc)
{
-struct proc *p = current_proc();
-int ticks;
-struct timeval *tv;
-struct timeval st;
+ struct proc *p = current_proc();
+ int ticks;
+ struct timeval *tv;
+ struct timeval st;
if (p == NULL)
return;
addupc_task(p, pc, ticks);
}
+/* TBD locking user profiling is not resolved yet */
void
get_procrustime(time_value_t *tv)
{
if ( !(p->p_flag & P_PROFIL))
return;
+ //proc_lock(p);
st = p->p_stats->p_ru.ru_stime;
+ //proc_unlock(p);
tv->seconds = st.tv_sec;
tv->microseconds = st.tv_usec;
projects / apple / xnu.git / blobdiff