xnu-1699.32.7.tar.gz

[apple/xnu.git] / bsd / kern / kern_clock.c

diff --git a/bsd/kern/kern_clock.c b/bsd/kern/kern_clock.c
index 582f463779dfd6203d848bf8309f88e124bd4994..1aae2df47cafbdeda69144c11727970722818ca6 100644 (file)
--- a/bsd/kern/kern_clock.c
+++ b/bsd/kern/kern_clock.c
@@ -1,23 +1,29 @@
 /*
 /*

- * 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,
  * 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 */
 /*-
  */
 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
 /*-


@@ -68,12 +74,12 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.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/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/vm.h>

+#include <sys/sysctl.h>

 
 #ifdef GPROF
 #include <sys/gmon.h>
 
 #ifdef GPROF
 #include <sys/gmon.h>


@@ -86,6 +92,9 @@
 
 #include <kern/thread_call.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.
  *
 /*
  * Clock handling routines.
  *


@@ -103,216 +112,65 @@
 
 /*
  * The hz hardware interval timer.
 
 /*
  * 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);
-                }
-       }
-
-       /*
-        * 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.
-        */
-
-       /*
-        * Gather the statistics.
-        */
-       gatherstats(usermode, pc);
+int             hz = 100;                /* GET RID OF THIS !!! */
+int             tick = (1000000 / 100);  /* GET RID OF THIS !!! */

 
 

-       }
-       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);
-}
+/*
+ * Kernel timeout services.
+ */

 
 /*
 
 /*

- * Gather statistics on resource utilization.
+ *     Set a timeout.

  *
  *

- * 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.

  */
  */

-/*ARGSUSED*/

 void
 void

-gatherstats(usermode, pc)
-       boolean_t usermode;
-       caddr_t pc;
+timeout(
+       timeout_fcn_t                   fcn,
+       void                                    *param,
+       int                                             interval)

 {
 {

-       register int cpstate, s;
-       struct proc *proc =current_proc();
-#ifdef GPROF
-    struct gmonparam *p = &_gmonparam;
-#endif
+       uint64_t                deadline;

 
 

-       /*
-        * 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);
+       thread_call_func_delayed((thread_call_func_t)fcn, param, deadline);

 }
 
 }
 

-

 /*
 /*

- * Kernel timeout services.
+ * Cancel a timeout.

  */
  */

+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
 
 /*
  *     Set a timeout.
  *
  *     fcn:            function to call
  *     param:          parameter to pass to function

- *     interval:       timeout interval, in hz.
+ *     ts:             timeout interval, in timespec

  */
 void
  */
 void

-timeout(
+bsd_timeout(

        timeout_fcn_t                   fcn,
        void                                    *param,
        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);
 }
 
        thread_call_func_delayed((thread_call_func_t)fcn, param, deadline);
 }
 


@@ -320,27 +178,27 @@ timeout(
  * Cancel a timeout.
  */
 void
  * Cancel a timeout.
  */
 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);
 }
 
 
 {
        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.
  */
 /*
  * 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
        /*
         * If number of milliseconds will fit in 32 bit arithmetic,
         * then compute number of milliseconds to time and scale to


@@ -350,40 +208,25 @@ hzto(tv)
         * Delta times less than 25 days can be computed ``exactly''.
         * Maximum value for any timeout in 10ms ticks is 250 days.
         */
         * 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)
        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;
                                / (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.
  */
 
 /*
  * 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;
 
 {
        struct clockinfo clkinfo;
 


@@ -394,19 +237,22 @@ sysctl_clockrate(where, sizep)
        clkinfo.tick = tick;
        clkinfo.profhz = hz;
        clkinfo.stathz = hz;
        clkinfo.tick = tick;
        clkinfo.profhz = hz;
        clkinfo.stathz = hz;

-       return sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo));
+       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
 
 /*
  * 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
 
        /*
         * If the number of usecs in the whole seconds part of the time


@@ -465,31 +311,30 @@ tvtohz(tv)
  * keeps the profile clock running constantly.
  */
 void
  * keeps the profile clock running constantly.
  */
 void

-startprofclock(p)
-       register struct proc *p;
+startprofclock(struct proc *p)

 {
        if ((p->p_flag & P_PROFIL) == 0)
 {
        if ((p->p_flag & P_PROFIL) == 0)

-               p->p_flag |= P_PROFIL;
+               OSBitOrAtomic(P_PROFIL, &p->p_flag);

 }
 
 /*
  * Stop profiling on a process.
  */
 void
 }
 
 /*
  * Stop profiling on a process.
  */
 void

-stopprofclock(p)
-       register struct proc *p;
+stopprofclock(struct proc *p)

 {
        if (p->p_flag & P_PROFIL)
 {
        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
 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;
 
        if (p == NULL)
                return;


@@ -508,6 +353,7 @@ struct timeval st;
                addupc_task(p, pc, ticks);
 }
 
                addupc_task(p, pc, ticks);
 }
 

+/* TBD locking user profiling is not resolved yet */

 void
 get_procrustime(time_value_t *tv)
 {
 void
 get_procrustime(time_value_t *tv)
 {


@@ -519,7 +365,9 @@ get_procrustime(time_value_t *tv)
        if ( !(p->p_flag & P_PROFIL))
                return;
 
        if ( !(p->p_flag & P_PROFIL))
                return;
 

+       //proc_lock(p);

        st = p->p_stats->p_ru.ru_stime;
        st = p->p_stats->p_ru.ru_stime;

+       //proc_unlock(p);

        
        tv->seconds = st.tv_sec;
        tv->microseconds = st.tv_usec;
        
        tv->seconds = st.tv_sec;
        tv->microseconds = st.tv_usec;