1/* 2 * Copyright (c) 2000-2007 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ 29/*- 30 * Copyright (c) 1982, 1986, 1991, 1993 31 * The Regents of the University of California. All rights reserved. 32 * (c) UNIX System Laboratories, Inc. 33 * All or some portions of this file are derived from material licensed 34 * to the University of California by American Telephone and Telegraph 35 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 36 * the permission of UNIX System Laboratories, Inc. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 3. All advertising materials mentioning features or use of this software 47 * must display the following acknowledgement: 48 * This product includes software developed by the University of 49 * California, Berkeley and its contributors. 50 * 4. Neither the name of the University nor the names of its contributors 51 * may be used to endorse or promote products derived from this software 52 * without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 64 * SUCH DAMAGE. 65 * 66 * @(#)kern_clock.c 8.5 (Berkeley) 1/21/94 67 */ 68/* 69 * HISTORY 70 */ 71 72#include <machine/spl.h> 73 74#include <sys/param.h> 75#include <sys/systm.h> 76#include <sys/time.h> 77#include <sys/resourcevar.h> 78#include <sys/kernel.h> 79#include <sys/resource.h> 80#include <sys/proc_internal.h> 81#include <sys/vm.h> 82#include <sys/sysctl.h> 83 84#ifdef GPROF 85#include <sys/gmon.h> 86#endif 87 88#include <kern/thread.h> 89#include <kern/ast.h> 90#include <kern/assert.h> 91#include <mach/boolean.h> 92 93#include <kern/thread_call.h> 94 95void bsd_uprofil(struct time_value *syst, user_addr_t pc); 96int tvtohz(struct timeval *tv); 97 98/* 99 * Clock handling routines. 100 * 101 * This code is written to operate with two timers which run 102 * independently of each other. The main clock, running at hz 103 * times per second, is used to do scheduling and timeout calculations. 104 * The second timer does resource utilization estimation statistically 105 * based on the state of the machine phz times a second. Both functions 106 * can be performed by a single clock (ie hz == phz), however the 107 * statistics will be much more prone to errors. Ideally a machine 108 * would have separate clocks measuring time spent in user state, system 109 * state, interrupt state, and idle state. These clocks would allow a non- 110 * approximate measure of resource utilization. 111 */ 112 113/* 114 * The hz hardware interval timer. 115 */ 116 117int hz = 100; /* GET RID OF THIS !!! */ 118int tick = (1000000 / 100); /* GET RID OF THIS !!! */ 119 120/* 121 * Kernel timeout services. 122 */ 123 124/* 125 * Set a timeout. 126 * 127 * fcn: function to call 128 * param: parameter to pass to function 129 * interval: timeout interval, in hz. 130 */ 131void 132timeout( 133 timeout_fcn_t fcn, 134 void *param, 135 int interval) 136{ 137 uint64_t deadline; 138 139 clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, &deadline); 140 thread_call_func_delayed((thread_call_func_t)fcn, param, deadline); 141} 142 143/* 144 * Set a timeout with leeway. 145 * 146 * fcn: function to call 147 * param: parameter to pass to function 148 * interval: timeout interval, in hz. 149 * leeway_interval: leeway interval, in hz. 150 */ 151void 152timeout_with_leeway( 153 timeout_fcn_t fcn, 154 void *param, 155 int interval, 156 int leeway_interval) 157{ 158 uint64_t deadline; 159 uint64_t leeway; 160 161 clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, &deadline); 162 163 clock_interval_to_absolutetime_interval(leeway_interval, NSEC_PER_SEC / hz, &leeway); 164 165 thread_call_func_delayed_with_leeway((thread_call_func_t)fcn, param, deadline, leeway, THREAD_CALL_DELAY_LEEWAY); 166} 167 168/* 169 * Cancel a timeout. 170 */ 171void 172untimeout( 173 timeout_fcn_t fcn, 174 void *param) 175{ 176 thread_call_func_cancel((thread_call_func_t)fcn, param, FALSE); 177} 178 179 180/* 181 * Set a timeout. 182 * 183 * fcn: function to call 184 * param: parameter to pass to function 185 * ts: timeout interval, in timespec 186 */ 187void 188bsd_timeout( 189 timeout_fcn_t fcn, 190 void *param, 191 struct timespec *ts) 192{ 193 uint64_t deadline = 0; 194 195 if (ts && (ts->tv_sec || ts->tv_nsec)) { 196 nanoseconds_to_absolutetime((uint64_t)ts->tv_sec * NSEC_PER_SEC + ts->tv_nsec, &deadline ); 197 clock_absolutetime_interval_to_deadline( deadline, &deadline ); 198 } 199 thread_call_func_delayed((thread_call_func_t)fcn, param, deadline); 200} 201 202/* 203 * Cancel a timeout. 204 */ 205void 206bsd_untimeout( 207 timeout_fcn_t fcn, 208 void *param) 209{ 210 thread_call_func_cancel((thread_call_func_t)fcn, param, FALSE); 211} 212 213 214/* 215 * Compute number of hz until specified time. 216 * Used to compute third argument to timeout() from an 217 * absolute time. 218 */ 219int 220hzto(struct timeval *tv) 221{ 222 struct timeval now; 223 long ticks; 224 long sec; 225 226 microtime(&now); 227 /* 228 * If number of milliseconds will fit in 32 bit arithmetic, 229 * then compute number of milliseconds to time and scale to 230 * ticks. Otherwise just compute number of hz in time, rounding 231 * times greater than representible to maximum value. 232 * 233 * Delta times less than 25 days can be computed ``exactly''. 234 * Maximum value for any timeout in 10ms ticks is 250 days. 235 */ 236 sec = tv->tv_sec - now.tv_sec; 237 if (sec <= 0x7fffffff / 1000 - 1000) 238 ticks = ((tv->tv_sec - now.tv_sec) * 1000 + 239 (tv->tv_usec - now.tv_usec) / 1000) 240 / (tick / 1000); 241 else if (sec <= 0x7fffffff / hz) 242 ticks = sec * hz; 243 else 244 ticks = 0x7fffffff; 245 246 return (ticks); 247} 248 249/* 250 * Return information about system clocks. 251 */ 252static int 253sysctl_clockrate 254(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, __unused struct sysctl_req *req) 255{ 256 struct clockinfo clkinfo; 257 258 /* 259 * Construct clockinfo structure. 260 */ 261 clkinfo.hz = hz; 262 clkinfo.tick = tick; 263 clkinfo.profhz = hz; 264 clkinfo.stathz = hz; 265 return sysctl_io_opaque(req, &clkinfo, sizeof(clkinfo), NULL); 266} 267 268SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate, 269 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED, 270 0, 0, sysctl_clockrate, "S,clockinfo", ""); 271 272 273/* 274 * Compute number of ticks in the specified amount of time. 275 */ 276int 277tvtohz(struct timeval *tv) 278{ 279 unsigned long ticks; 280 long sec, usec; 281 282 /* 283 * If the number of usecs in the whole seconds part of the time 284 * difference fits in a long, then the total number of usecs will 285 * fit in an unsigned long. Compute the total and convert it to 286 * ticks, rounding up and adding 1 to allow for the current tick 287 * to expire. Rounding also depends on unsigned long arithmetic 288 * to avoid overflow. 289 * 290 * Otherwise, if the number of ticks in the whole seconds part of 291 * the time difference fits in a long, then convert the parts to 292 * ticks separately and add, using similar rounding methods and 293 * overflow avoidance. This method would work in the previous 294 * case but it is slightly slower and assumes that hz is integral. 295 * 296 * Otherwise, round the time difference down to the maximum 297 * representable value. 298 * 299 * If ints have 32 bits, then the maximum value for any timeout in 300 * 10ms ticks is 248 days. 301 */ 302 sec = tv->tv_sec; 303 usec = tv->tv_usec; 304 if (usec < 0) { 305 sec--; 306 usec += 1000000; 307 } 308 if (sec < 0) { 309#ifdef DIAGNOSTIC 310 if (usec > 0) { 311 sec++; 312 usec -= 1000000; 313 } 314 printf("tvotohz: negative time difference %ld sec %ld usec\n", 315 sec, usec); 316#endif 317 ticks = 1; 318 } else if (sec <= LONG_MAX / 1000000) 319 ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1)) 320 / tick + 1; 321 else if (sec <= LONG_MAX / hz) 322 ticks = sec * hz 323 + ((unsigned long)usec + (tick - 1)) / tick + 1; 324 else 325 ticks = LONG_MAX; 326 if (ticks > INT_MAX) 327 ticks = INT_MAX; 328 return ((int)ticks); 329} 330 331 332/* 333 * Start profiling on a process. 334 * 335 * Kernel profiling passes kernel_proc which never exits and hence 336 * keeps the profile clock running constantly. 337 */ 338void 339startprofclock(struct proc *p) 340{ 341 if ((p->p_flag & P_PROFIL) == 0) 342 OSBitOrAtomic(P_PROFIL, &p->p_flag); 343} 344 345/* 346 * Stop profiling on a process. 347 */ 348void 349stopprofclock(struct proc *p) 350{ 351 if (p->p_flag & P_PROFIL) 352 OSBitAndAtomic(~((uint32_t)P_PROFIL), &p->p_flag); 353} 354 355/* TBD locking user profiling is not resolved yet */ 356void 357bsd_uprofil(struct time_value *syst, user_addr_t pc) 358{ 359 struct proc *p = current_proc(); 360 int ticks; 361 struct timeval *tv; 362 struct timeval st; 363 364 if (p == NULL) 365 return; 366 if ( !(p->p_flag & P_PROFIL)) 367 return; 368 369 st.tv_sec = syst->seconds; 370 st.tv_usec = syst->microseconds; 371 372 tv = &(p->p_stats->p_ru.ru_stime); 373 374 ticks = ((tv->tv_sec - st.tv_sec) * 1000 + 375 (tv->tv_usec - st.tv_usec) / 1000) / 376 (tick / 1000); 377 if (ticks) 378 addupc_task(p, pc, ticks); 379} 380 381/* TBD locking user profiling is not resolved yet */ 382void 383get_procrustime(time_value_t *tv) 384{ 385 struct proc *p = current_proc(); 386 struct timeval st; 387 388 if (p == NULL) 389 return; 390 if ( !(p->p_flag & P_PROFIL)) 391 return; 392 393 //proc_lock(p); 394 st = p->p_stats->p_ru.ru_stime; 395 //proc_unlock(p); 396 397 tv->seconds = st.tv_sec; 398 tv->microseconds = st.tv_usec; 399} 400