1/*
2 * Copyright (c) 2000-2018 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 <sys/param.h>
73#include <sys/systm.h>
74#include <sys/time.h>
75#include <sys/resourcevar.h>
76#include <sys/kernel.h>
77#include <sys/resource.h>
78#include <sys/proc_internal.h>
79#include <sys/vm.h>
80#include <sys/sysctl.h>
81
82#include <kern/thread.h>
83#include <kern/ast.h>
84#include <kern/assert.h>
85#include <mach/boolean.h>
86
87#include <kern/thread_call.h>
88
89void bsd_uprofil(struct time_value *syst, user_addr_t pc);
90int tvtohz(struct timeval *tv);
91
92/*
93 * Clock handling routines.
94 *
95 * This code is written to operate with two timers which run
96 * independently of each other. The main clock, running at hz
97 * times per second, is used to do scheduling and timeout calculations.
98 * The second timer does resource utilization estimation statistically
99 * based on the state of the machine phz times a second. Both functions
100 * can be performed by a single clock (ie hz == phz), however the
101 * statistics will be much more prone to errors. Ideally a machine
102 * would have separate clocks measuring time spent in user state, system
103 * state, interrupt state, and idle state. These clocks would allow a non-
104 * approximate measure of resource utilization.
105 */
106
107/*
108 * The hz hardware interval timer.
109 */
110
111int hz = 100; /* GET RID OF THIS !!! */
112int tick = (1000000 / 100); /* GET RID OF THIS !!! */
113
114/*
115 * Kernel timeout services.
116 */
117
118/*
119 * Set a timeout.
120 *
121 * fcn: function to call
122 * param: parameter to pass to function
123 * interval: timeout interval, in hz.
124 */
125void
126timeout(
127 timeout_fcn_t fcn,
128 void *param,
129 int interval)
130{
131 uint64_t deadline;
132
133 clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, result: &deadline);
134 thread_call_func_delayed(func: (thread_call_func_t)(void (*)(void))fcn, param, deadline);
135}
136
137/*
138 * Set a timeout with leeway.
139 *
140 * fcn: function to call
141 * param: parameter to pass to function
142 * interval: timeout interval, in hz.
143 * leeway_interval: leeway interval, in hz.
144 */
145void
146timeout_with_leeway(
147 timeout_fcn_t fcn,
148 void *param,
149 int interval,
150 int leeway_interval)
151{
152 uint64_t deadline;
153 uint64_t leeway;
154
155 clock_interval_to_deadline(interval, NSEC_PER_SEC / hz, result: &deadline);
156
157 clock_interval_to_absolutetime_interval(interval: leeway_interval, NSEC_PER_SEC / hz, result: &leeway);
158
159 thread_call_func_delayed_with_leeway(func: (thread_call_func_t)(void (*)(void))fcn, param, deadline, leeway, THREAD_CALL_DELAY_LEEWAY);
160}
161
162/*
163 * Cancel a timeout.
164 * Deprecated because it's very inefficient.
165 * Switch to an allocated thread call instead.
166 */
167void
168untimeout(
169 timeout_fcn_t fcn,
170 void *param)
171{
172 thread_call_func_cancel(func: (thread_call_func_t)(void (*)(void))fcn, param, FALSE);
173}
174
175
176/*
177 * Set a timeout.
178 *
179 * fcn: function to call
180 * param: parameter to pass to function
181 * ts: timeout interval, in timespec
182 */
183void
184bsd_timeout(
185 timeout_fcn_t fcn,
186 void *param,
187 struct timespec *ts)
188{
189 uint64_t deadline = 0;
190
191 if (ts && (ts->tv_sec || ts->tv_nsec)) {
192 nanoseconds_to_absolutetime(nanoseconds: (uint64_t)ts->tv_sec * NSEC_PER_SEC + ts->tv_nsec, result: &deadline );
193 clock_absolutetime_interval_to_deadline( abstime: deadline, result: &deadline );
194 }
195 thread_call_func_delayed(func: (thread_call_func_t)(void (*)(void))fcn, param, deadline);
196}
197
198/*
199 * Cancel a timeout.
200 * Deprecated because it's very inefficient.
201 * Switch to an allocated thread call instead.
202 */
203void
204bsd_untimeout(
205 timeout_fcn_t fcn,
206 void *param)
207{
208 thread_call_func_cancel(func: (thread_call_func_t)(void (*)(void))fcn, param, FALSE);
209}
210
211
212/*
213 * Compute number of hz until specified time.
214 * Used to compute third argument to timeout() from an
215 * absolute time.
216 */
217int
218hzto(struct timeval *tv)
219{
220 struct timeval now;
221 long ticks;
222 long sec;
223
224 microtime(tv: &now);
225 /*
226 * If number of milliseconds will fit in 32 bit arithmetic,
227 * then compute number of milliseconds to time and scale to
228 * ticks. Otherwise just compute number of hz in time, rounding
229 * times greater than representible to maximum value.
230 *
231 * Delta times less than 25 days can be computed ``exactly''.
232 * Maximum value for any timeout in 10ms ticks is 250 days.
233 */
234 sec = tv->tv_sec - now.tv_sec;
235 if (sec <= 0x7fffffff / 1000 - 1000) {
236 ticks = ((tv->tv_sec - now.tv_sec) * 1000 +
237 (tv->tv_usec - now.tv_usec) / 1000)
238 / (tick / 1000);
239 } else if (sec <= 0x7fffffff / hz) {
240 ticks = sec * hz;
241 } else {
242 ticks = 0x7fffffff;
243 }
244
245 return (int)ticks;
246}
247
248/*
249 * Return information about system clocks.
250 */
251static int
252sysctl_clockrate
253(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, __unused struct sysctl_req *req)
254{
255 struct clockinfo clkinfo = {
256 .hz = hz,
257 .tick = tick,
258 .tickadj = 0,
259 .stathz = hz,
260 .profhz = hz,
261 };
262
263 return sysctl_io_opaque(req, pValue: &clkinfo, valueSize: sizeof(clkinfo), NULL);
264}
265
266SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate,
267 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
268 0, 0, sysctl_clockrate, "S,clockinfo", "");
269
270
271/*
272 * Compute number of ticks in the specified amount of time.
273 */
274int
275tvtohz(struct timeval *tv)
276{
277 unsigned long ticks;
278 long sec, usec;
279
280 /*
281 * If the number of usecs in the whole seconds part of the time
282 * difference fits in a long, then the total number of usecs will
283 * fit in an unsigned long. Compute the total and convert it to
284 * ticks, rounding up and adding 1 to allow for the current tick
285 * to expire. Rounding also depends on unsigned long arithmetic
286 * to avoid overflow.
287 *
288 * Otherwise, if the number of ticks in the whole seconds part of
289 * the time difference fits in a long, then convert the parts to
290 * ticks separately and add, using similar rounding methods and
291 * overflow avoidance. This method would work in the previous
292 * case but it is slightly slower and assumes that hz is integral.
293 *
294 * Otherwise, round the time difference down to the maximum
295 * representable value.
296 *
297 * If ints have 32 bits, then the maximum value for any timeout in
298 * 10ms ticks is 248 days.
299 */
300 sec = tv->tv_sec;
301 usec = tv->tv_usec;
302 if (usec < 0) {
303 sec--;
304 usec += 1000000;
305 }
306 if (sec < 0) {
307#ifdef DIAGNOSTIC
308 if (usec > 0) {
309 sec++;
310 usec -= 1000000;
311 }
312 printf("tvotohz: negative time difference %ld sec %ld usec\n",
313 sec, usec);
314#endif
315 ticks = 1;
316 } else if (sec <= LONG_MAX / 1000000) {
317 ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1))
318 / tick + 1;
319 } else if (sec <= LONG_MAX / hz) {
320 ticks = sec * hz
321 + ((unsigned long)usec + (tick - 1)) / tick + 1;
322 } else {
323 ticks = LONG_MAX;
324 }
325 if (ticks > INT_MAX) {
326 ticks = INT_MAX;
327 }
328 return (int)ticks;
329}
330
331/* TBD locking user profiling is not resolved yet */
332void
333get_procrustime(time_value_t *tv)
334{
335 struct proc *p = current_proc();
336 struct timeval st;
337
338 if (p == NULL) {
339 return;
340 }
341 if (!(p->p_flag & P_PROFIL)) {
342 return;
343 }
344
345 //proc_lock(p);
346 st = p->p_stats->p_ru.ru_stime;
347 //proc_unlock(p);
348
349 tv->seconds = (integer_t)st.tv_sec;
350 tv->microseconds = st.tv_usec;
351}
352