xnu-792.6.61.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 a1b35394e14fd478ac44c428ee5804b87802e418..76c5353de950665f6af2f93f4cb9c11d0eb40cf3 100644 (file)
--- a/bsd/kern/kern_clock.c
+++ b/bsd/kern/kern_clock.c
@@ -71,8 +71,9 @@
 #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>
@@ -85,6 +86,14 @@
 
 #include <kern/thread_call.h>
 
+void bsd_uprofil(struct time_value *syst, user_addr_t pc);
+void get_procrustime(time_value_t *tv);
+int sysctl_clockrate(user_addr_t where, size_t *sizep);
+int tvtohz(struct timeval *tv);
+extern void psignal_sigprof(struct proc *);
+extern void psignal_vtalarm(struct proc *);
+extern void psignal_xcpu(struct proc *);
+
 /*
  * Clock handling routines.
  *
@@ -107,26 +116,30 @@
  * we run through the statistics gathering routine as well.
  */
 
+int             hz = 100;                /* GET RID OF THIS !!! */
+int             tick = (1000000 / 100);  /* GET RID OF THIS !!! */
+
 int bsd_hardclockinit = 0;
 /*ARGSUSED*/
 void
-bsd_hardclock(usermode, pc, numticks)
-       boolean_t usermode;
-       caddr_t pc;
-       int numticks;
+bsd_hardclock(
+                boolean_t usermode, 
+#ifdef GPROF
+                caddr_t pc, 
+#else
+                __unused caddr_t pc, 
+#endif
+                int numticks
+             )
 {
        register struct proc *p;
        register thread_t       thread;
        int nusecs = numticks * tick;
+       struct timeval          tv;
 
        if (!bsd_hardclockinit)
                return;
 
-       /*
-        * Increment the time-of-day.
-        */
-       microtime(&time);
-
        if (bsd_hardclockinit < 0) {
            return;
        }
@@ -139,7 +152,7 @@ bsd_hardclock(usermode, pc, numticks)
         * one tick.
         */
        p = (struct proc *)current_proc();
-       if (p && ((p->p_flag & P_WEXIT) == NULL)) {
+       if (p && ((p->p_flag & P_WEXIT) == 0)) {
                if (usermode) {         
                        if (p->p_stats && p->p_stats->p_prof.pr_scale) {
                                p->p_flag |= P_OWEUPC;
@@ -154,10 +167,9 @@ bsd_hardclock(usermode, pc, numticks)
                        if (p->p_stats && 
                                timerisset(&p->p_stats->p_timer[ITIMER_VIRTUAL].it_value) &&
                                !itimerdecr(&p->p_stats->p_timer[ITIMER_VIRTUAL], nusecs)) {
-                               extern void psignal_vtalarm(struct proc *);
                         
                                /* does psignal(p, SIGVTALRM) in a thread context */
-                               thread_call_func(psignal_vtalarm, p, FALSE);
+                               thread_call_func((thread_call_func_t)psignal_vtalarm, p, FALSE);
                        }
                }
 
@@ -177,10 +189,9 @@ bsd_hardclock(usermode, pc, numticks)
                                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(psignal_xcpu, p, FALSE);
+                                       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)
@@ -189,10 +200,9 @@ bsd_hardclock(usermode, pc, numticks)
                        }
                        if (timerisset(&p->p_stats->p_timer[ITIMER_PROF].it_value) &&
                                !itimerdecr(&p->p_stats->p_timer[ITIMER_PROF], nusecs)) {
-                               extern void psignal_sigprof(struct proc *);
                         
                                /* does psignal(p, SIGPROF) in a thread context */
-                               thread_call_func(psignal_sigprof, p, FALSE);
+                               thread_call_func((thread_call_func_t)psignal_sigprof, p, FALSE);
                        }
                }
        }
@@ -211,8 +221,15 @@ bsd_hardclock(usermode, pc, numticks)
 /*ARGSUSED*/
 void
 gatherstats(
-       boolean_t       usermode,
-       caddr_t         pc)
+#ifdef GPROF
+                boolean_t      usermode,
+                caddr_t                pc
+#else
+                __unused boolean_t     usermode,
+                __unused caddr_t               pc
+#endif
+              )
+               
 {
 #ifdef GPROF
        if (!usermode) {
@@ -267,12 +284,46 @@ untimeout(
 }
 
 
+/*
+ *     Set a timeout.
+ *
+ *     fcn:            function to call
+ *     param:          parameter to pass to function
+ *     ts:             timeout interval, in timespec
+ */
+void
+bsd_timeout(
+       timeout_fcn_t                   fcn,
+       void                                    *param,
+       struct timespec         *ts)
+{
+       uint64_t                deadline = 0;
+
+       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.
+ */
+void
+bsd_untimeout(
+       register timeout_fcn_t          fcn,
+       register 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.
  */
+int
 hzto(tv)
        struct timeval *tv;
 {
@@ -307,9 +358,7 @@ hzto(tv)
  * Return information about system clocks.
  */
 int
-sysctl_clockrate(where, sizep)
-       register char *where;
-       size_t *sizep;
+sysctl_clockrate(user_addr_t where, size_t *sizep)
 {
        struct clockinfo clkinfo;
 
@@ -320,7 +369,7 @@ sysctl_clockrate(where, sizep)
        clkinfo.tick = tick;
        clkinfo.profhz = hz;
        clkinfo.stathz = hz;
-       return sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo));
+       return sysctl_rdstruct(where, sizep, USER_ADDR_NULL, &clkinfo, sizeof(clkinfo));
 }
 
 
@@ -328,8 +377,7 @@ sysctl_clockrate(where, sizep)
  * 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;
@@ -410,7 +458,7 @@ stopprofclock(p)
 }
 
 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;