[apple/xnu.git] / osfmk / kperf / kperf_timer.c

/*
 * Copyright (c) 2011 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * 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.
 *
 * 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

/*  Manage timers */

#include <mach/mach_types.h>
#include <kern/cpu_data.h> /* current_thread() */
#include <kern/kalloc.h>
#include <sys/errno.h>
#include <sys/vm.h>
#include <sys/ktrace.h>

#include <machine/machine_routines.h>
#if defined(__x86_64__)
#include <i386/mp.h>
#endif /* defined(__x86_64__) */

#include <kperf/kperf.h>
#include <kperf/buffer.h>
#include <kperf/context.h>
#include <kperf/action.h>
#include <kperf/kperf_timer.h>
#include <kperf/kperf_arch.h>
#include <kperf/pet.h>
#include <kperf/sample.h>

/* the list of timers */
struct kperf_timer *kperf_timerv = NULL;
unsigned int kperf_timerc = 0;

static unsigned int pet_timer_id = 999;

/* maximum number of timers we can construct */
#define TIMER_MAX (16)

#if defined(__x86_64__)

#define MIN_PERIOD_NS        (20 * NSEC_PER_USEC)
#define MIN_PERIOD_BG_NS     (10 * NSEC_PER_MSEC)
#define MIN_PERIOD_PET_NS    (2 * NSEC_PER_MSEC)
#define MIN_PERIOD_PET_BG_NS (10 * NSEC_PER_MSEC)

#else /* defined(__x86_64__) */
#error "unsupported architecture"
#endif /* defined(__x86_64__) */

static uint64_t min_period_abstime;
static uint64_t min_period_bg_abstime;
static uint64_t min_period_pet_abstime;
static uint64_t min_period_pet_bg_abstime;

static uint64_t
kperf_timer_min_period_abstime(void)
{
	if (ktrace_background_active()) {
		return min_period_bg_abstime;
	} else {
		return min_period_abstime;
	}
}

static uint64_t
kperf_timer_min_pet_period_abstime(void)
{
	if (ktrace_background_active()) {
		return min_period_pet_bg_abstime;
	} else {
		return min_period_pet_abstime;
	}
}

static void
kperf_timer_schedule(struct kperf_timer *timer, uint64_t now)
{
	BUF_INFO(PERF_TM_SCHED, timer->period);

	/* if we re-programmed the timer to zero, just drop it */
	if (timer->period == 0) {
		return;
	}

	/* calculate deadline */
	uint64_t deadline = now + timer->period;

	/* re-schedule the timer, making sure we don't apply slop */
	timer_call_enter(&timer->tcall, deadline, TIMER_CALL_SYS_CRITICAL);
}

void
kperf_ipi_handler(void *param)
{
	struct kperf_context ctx;
	struct kperf_timer *timer = param;

	assert(timer != NULL);

	/* Always cut a tracepoint to show a sample event occurred */
	BUF_DATA(PERF_TM_HNDLR | DBG_FUNC_START, 0);

	int ncpu = cpu_number();

	struct kperf_sample *intbuf = kperf_intr_sample_buffer();

	/* On a timer, we can see the "real" current thread */
	ctx.cur_thread = current_thread();
	ctx.cur_pid = task_pid(get_threadtask(ctx.cur_thread));

	/* who fired */
	ctx.trigger_type = TRIGGER_TYPE_TIMER;
	ctx.trigger_id = (unsigned int)(timer - kperf_timerv);

	if (ctx.trigger_id == pet_timer_id && ncpu < machine_info.logical_cpu_max) {
		kperf_thread_on_cpus[ncpu] = ctx.cur_thread;
	}

	/* make sure sampling is on */
	unsigned int status = kperf_sampling_status();
	if (status == KPERF_SAMPLING_OFF) {
		BUF_INFO(PERF_TM_HNDLR | DBG_FUNC_END, SAMPLE_OFF);
		return;
	} else if (status == KPERF_SAMPLING_SHUTDOWN) {
		BUF_INFO(PERF_TM_HNDLR | DBG_FUNC_END, SAMPLE_SHUTDOWN);
		return;
	}

	/* call the action -- kernel-only from interrupt, pend user */
	int r = kperf_sample(intbuf, &ctx, timer->actionid, SAMPLE_FLAG_PEND_USER);

	/* end tracepoint is informational */
	BUF_INFO(PERF_TM_HNDLR | DBG_FUNC_END, r);

#if defined(__x86_64__)
	(void)atomic_bit_clear(&(timer->pending_cpus), ncpu, __ATOMIC_RELAXED);
#endif /* defined(__x86_64__) */
}

static void
kperf_timer_handler(void *param0, __unused void *param1)
{
	struct kperf_timer *timer = param0;
	unsigned int ntimer = (unsigned int)(timer - kperf_timerv);
	unsigned int ncpus  = machine_info.logical_cpu_max;

	timer->active = 1;

	/* along the lines of do not ipi if we are all shutting down */
	if (kperf_sampling_status() == KPERF_SAMPLING_SHUTDOWN) {
		goto deactivate;
	}

	BUF_DATA(PERF_TM_FIRE, ntimer, ntimer == pet_timer_id, timer->period,
	                       timer->actionid);

	if (ntimer == pet_timer_id) {
		kperf_pet_fire_before();

		/* clean-up the thread-on-CPUs cache */
		bzero(kperf_thread_on_cpus, ncpus * sizeof(*kperf_thread_on_cpus));
	}

	/* ping all CPUs */
	kperf_mp_broadcast_running(timer);

	/* release the pet thread? */
	if (ntimer == pet_timer_id) {
		/* PET mode is responsible for rearming the timer */
		kperf_pet_fire_after();
	} else {
		/*
		  * FIXME: Get the current time from elsewhere.  The next
		  * timer's period now includes the time taken to reach this
		  * point.  This causes a bias towards longer sampling periods
		  * than requested.
		  */
		kperf_timer_schedule(timer, mach_absolute_time());
	}

deactivate:
	timer->active = 0;
}

/* program the timer from the PET thread */
void
kperf_timer_pet_rearm(uint64_t elapsed_ticks)
{
	struct kperf_timer *timer = NULL;
	uint64_t period = 0;
	uint64_t deadline;

	/*
	 * If the pet_timer_id is invalid, it has been disabled, so this should
	 * do nothing.
	 */
	if (pet_timer_id >= kperf_timerc) {
		return;
	}

	unsigned int status = kperf_sampling_status();
	/* do not reprogram the timer if it has been shutdown or sampling is off */
	if (status == KPERF_SAMPLING_OFF) {
		BUF_INFO(PERF_PET_END, SAMPLE_OFF);
		return;
	} else if (status == KPERF_SAMPLING_SHUTDOWN) {
		BUF_INFO(PERF_PET_END, SAMPLE_SHUTDOWN);
		return;
	}

	timer = &(kperf_timerv[pet_timer_id]);

	/* if we re-programmed the timer to zero, just drop it */
	if (!timer->period) {
		return;
	}

	/* subtract the time the pet sample took being careful not to underflow */
	if (timer->period > elapsed_ticks) {
		period = timer->period - elapsed_ticks;
	}

	/* make sure we don't set the next PET sample to happen too soon */
	if (period < min_period_pet_abstime) {
		period = min_period_pet_abstime;
	}

	/* we probably took so long in the PET thread, it makes sense to take
	 * the time again.
	 */
	deadline = mach_absolute_time() + period;

	BUF_INFO(PERF_PET_SCHED, timer->period, period, elapsed_ticks, deadline);

	/* re-schedule the timer, making sure we don't apply slop */
	timer_call_enter(&(timer->tcall), deadline, TIMER_CALL_SYS_CRITICAL);

	return;
}

/* turn on all the timers */
void
kperf_timer_go(void)
{
	/* get the PET thread going */
	if (pet_timer_id < kperf_timerc) {
		kperf_pet_config(kperf_timerv[pet_timer_id].actionid);
	}

	uint64_t now = mach_absolute_time();

	for (unsigned int i = 0; i < kperf_timerc; i++) {
		if (kperf_timerv[i].period == 0) {
			continue;
		}

		kperf_timer_schedule(&(kperf_timerv[i]), now);
	}
}

void
kperf_timer_stop(void)
{
	for (unsigned int i = 0; i < kperf_timerc; i++) {
		if (kperf_timerv[i].period == 0) {
			continue;
		}

		/* wait for the timer to stop */
		while (kperf_timerv[i].active);

		timer_call_cancel(&(kperf_timerv[i].tcall));
	}

	/* wait for PET to stop, too */
	kperf_pet_config(0);
}

unsigned int
kperf_timer_get_petid(void)
{
	return pet_timer_id;
}

int
kperf_timer_set_petid(unsigned int timerid)
{
	if (timerid < kperf_timerc) {
		uint64_t min_period;

		min_period = kperf_timer_min_pet_period_abstime();
		if (kperf_timerv[timerid].period < min_period) {
			kperf_timerv[timerid].period = min_period;
		}
		kperf_pet_config(kperf_timerv[timerid].actionid);
	} else {
		/* clear the PET trigger if it's a bogus ID */
		kperf_pet_config(0);
	}

	pet_timer_id = timerid;

	return 0;
}

int
kperf_timer_get_period(unsigned int timerid, uint64_t *period_abstime)
{
	if (timerid >= kperf_timerc) {
		return EINVAL;
	}

	*period_abstime = kperf_timerv[timerid].period;
	return 0;
}

int
kperf_timer_set_period(unsigned int timerid, uint64_t period_abstime)
{
	uint64_t min_period;

	if (timerid >= kperf_timerc) {
		return EINVAL;
	}

	if (pet_timer_id == timerid) {
		min_period = kperf_timer_min_pet_period_abstime();
	} else {
		min_period = kperf_timer_min_period_abstime();
	}

	if (period_abstime > 0 && period_abstime < min_period) {
		period_abstime = min_period;
	}

	kperf_timerv[timerid].period = period_abstime;

	/* FIXME: re-program running timers? */

	return 0;
}

int
kperf_timer_get_action(unsigned int timerid, uint32_t *action)
{
	if (timerid >= kperf_timerc) {
		return EINVAL;
	}

	*action = kperf_timerv[timerid].actionid;
	return 0;
}

int
kperf_timer_set_action(unsigned int timerid, uint32_t action)
{
	if (timerid >= kperf_timerc) {
		return EINVAL;
	}

	kperf_timerv[timerid].actionid = action;
	return 0;
}

unsigned int
kperf_timer_get_count(void)
{
	return kperf_timerc;
}

void
kperf_timer_reset(void)
{
	kperf_timer_set_petid(999);
	kperf_set_pet_idle_rate(KPERF_PET_DEFAULT_IDLE_RATE);
	kperf_set_lightweight_pet(0);
	for (unsigned int i = 0; i < kperf_timerc; i++) {
		kperf_timerv[i].period = 0;
		kperf_timerv[i].actionid = 0;
#if defined(__x86_64__)
		kperf_timerv[i].pending_cpus = 0;
#endif /* defined(__x86_64__) */
	}
}

extern int
kperf_timer_set_count(unsigned int count)
{
	struct kperf_timer *new_timerv = NULL, *old_timerv = NULL;
	unsigned int old_count;

	if (min_period_abstime == 0) {
		nanoseconds_to_absolutetime(MIN_PERIOD_NS, &min_period_abstime);
		nanoseconds_to_absolutetime(MIN_PERIOD_BG_NS, &min_period_bg_abstime);
		nanoseconds_to_absolutetime(MIN_PERIOD_PET_NS, &min_period_pet_abstime);
		nanoseconds_to_absolutetime(MIN_PERIOD_PET_BG_NS,
			&min_period_pet_bg_abstime);
		assert(min_period_abstime > 0);
	}

	if (count == kperf_timerc) {
		return 0;
	}
	if (count > TIMER_MAX) {
		return EINVAL;
	}

	/* TODO: allow shrinking? */
	if (count < kperf_timerc) {
		return EINVAL;
	}

	/*
	 * Make sure kperf is initialized when creating the array for the first
	 * time.
	 */
	if (kperf_timerc == 0) {
		int r;

		/* main kperf */
		if ((r = kperf_init())) {
			return r;
		}
	}

	/*
	 * Shut down any running timers since we will be messing with the timer
	 * call structures.
	 */
	kperf_timer_stop();

	/* create a new array */
	new_timerv = kalloc_tag(count * sizeof(struct kperf_timer),
		VM_KERN_MEMORY_DIAG);
	if (new_timerv == NULL) {
		return ENOMEM;
	}
	old_timerv = kperf_timerv;
	old_count = kperf_timerc;

	if (old_timerv != NULL) {
		bcopy(kperf_timerv, new_timerv,
			kperf_timerc * sizeof(struct kperf_timer));
	}

	/* zero the new entries */
	bzero(&(new_timerv[kperf_timerc]),
		(count - old_count) * sizeof(struct kperf_timer));

	/* (re-)setup the timer call info for all entries */
	for (unsigned int i = 0; i < count; i++) {
		timer_call_setup(&(new_timerv[i].tcall), kperf_timer_handler, &(new_timerv[i]));
	}

	kperf_timerv = new_timerv;
	kperf_timerc = count;

	if (old_timerv != NULL) {
		kfree(old_timerv, old_count * sizeof(struct kperf_timer));
	}

	return 0;
}
Commit	Line	Data
39037602 A	1	/*
	2	* Copyright (c) 2011 Apple Computer, 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
	29	/* Manage timers */
	30
	31	#include <mach/mach_types.h>
	32	#include <kern/cpu_data.h> /* current_thread() */
	33	#include <kern/kalloc.h>
	34	#include <sys/errno.h>
	35	#include <sys/vm.h>
	36	#include <sys/ktrace.h>
	37
	38	#include <machine/machine_routines.h>
	39	#if defined(__x86_64__)
	40	#include <i386/mp.h>
	41	#endif /* defined(__x86_64__) */
	42
	43	#include <kperf/kperf.h>
	44	#include <kperf/buffer.h>
	45	#include <kperf/context.h>
	46	#include <kperf/action.h>
	47	#include <kperf/kperf_timer.h>
	48	#include <kperf/kperf_arch.h>
	49	#include <kperf/pet.h>
	50	#include <kperf/sample.h>
	51
	52	/* the list of timers */
	53	struct kperf_timer *kperf_timerv = NULL;
	54	unsigned int kperf_timerc = 0;
	55
	56	static unsigned int pet_timer_id = 999;
	57
	58	/* maximum number of timers we can construct */
	59	#define TIMER_MAX (16)
	60
	61	#if defined(__x86_64__)
	62
	63	#define MIN_PERIOD_NS (20 * NSEC_PER_USEC)
	64	#define MIN_PERIOD_BG_NS (10 * NSEC_PER_MSEC)
65	#define MIN_PERIOD_PET_NS (2 * NSEC_PER_MSEC)
66	#define MIN_PERIOD_PET_BG_NS (10 * NSEC_PER_MSEC)
67
68	#else /* defined(__x86_64__) */
69	#error "unsupported architecture"
70	#endif /* defined(__x86_64__) */
71
72	static uint64_t min_period_abstime;
73	static uint64_t min_period_bg_abstime;
74	static uint64_t min_period_pet_abstime;
75	static uint64_t min_period_pet_bg_abstime;
76
77	static uint64_t
78	kperf_timer_min_period_abstime(void)
79	{
80	if (ktrace_background_active()) {
81	return min_period_bg_abstime;
82	} else {
83	return min_period_abstime;
84	}
85	}
86
87	static uint64_t
88	kperf_timer_min_pet_period_abstime(void)
89	{
90	if (ktrace_background_active()) {
91	return min_period_pet_bg_abstime;
92	} else {
93	return min_period_pet_abstime;
94	}
95	}
96
97	static void
98	kperf_timer_schedule(struct kperf_timer *timer, uint64_t now)
99	{
100	BUF_INFO(PERF_TM_SCHED, timer->period);
101
102	/* if we re-programmed the timer to zero, just drop it */
103	if (timer->period == 0) {
104	return;
105	}
106
107	/* calculate deadline */
108	uint64_t deadline = now + timer->period;
109
110	/* re-schedule the timer, making sure we don't apply slop */
111	timer_call_enter(&timer->tcall, deadline, TIMER_CALL_SYS_CRITICAL);
112	}
113
114	void
115	kperf_ipi_handler(void *param)
116	{
117	struct kperf_context ctx;
118	struct kperf_timer *timer = param;
119
120	assert(timer != NULL);
121
122	/* Always cut a tracepoint to show a sample event occurred */
123	BUF_DATA(PERF_TM_HNDLR \| DBG_FUNC_START, 0);
124
125	int ncpu = cpu_number();
126
127	struct kperf_sample *intbuf = kperf_intr_sample_buffer();
128
129	/* On a timer, we can see the "real" current thread */
130	ctx.cur_thread = current_thread();
131	ctx.cur_pid = task_pid(get_threadtask(ctx.cur_thread));
132
133	/* who fired */
134	ctx.trigger_type = TRIGGER_TYPE_TIMER;
135	ctx.trigger_id = (unsigned int)(timer - kperf_timerv);
136
137	if (ctx.trigger_id == pet_timer_id && ncpu < machine_info.logical_cpu_max) {
138	kperf_thread_on_cpus[ncpu] = ctx.cur_thread;
139	}
140
141	/* make sure sampling is on */
142	unsigned int status = kperf_sampling_status();
143	if (status == KPERF_SAMPLING_OFF) {
144	BUF_INFO(PERF_TM_HNDLR \| DBG_FUNC_END, SAMPLE_OFF);
145	return;
146	} else if (status == KPERF_SAMPLING_SHUTDOWN) {
147	BUF_INFO(PERF_TM_HNDLR \| DBG_FUNC_END, SAMPLE_SHUTDOWN);
148	return;
149	}
150
151	/* call the action -- kernel-only from interrupt, pend user */
152	int r = kperf_sample(intbuf, &ctx, timer->actionid, SAMPLE_FLAG_PEND_USER);
153
154	/* end tracepoint is informational */
155	BUF_INFO(PERF_TM_HNDLR \| DBG_FUNC_END, r);
156
157	#if defined(__x86_64__)
158	(void)atomic_bit_clear(&(timer->pending_cpus), ncpu, __ATOMIC_RELAXED);
159	#endif /* defined(__x86_64__) */
160	}
161
162	static void
163	kperf_timer_handler(void param0, __unused void param1)
164	{
165	struct kperf_timer *timer = param0;
166	unsigned int ntimer = (unsigned int)(timer - kperf_timerv);
167	unsigned int ncpus = machine_info.logical_cpu_max;
168
169	timer->active = 1;
170
171	/* along the lines of do not ipi if we are all shutting down */
172	if (kperf_sampling_status() == KPERF_SAMPLING_SHUTDOWN) {
173	goto deactivate;
174	}
175
176	BUF_DATA(PERF_TM_FIRE, ntimer, ntimer == pet_timer_id, timer->period,
177	timer->actionid);
178
179	if (ntimer == pet_timer_id) {
180	kperf_pet_fire_before();
181
182	/* clean-up the thread-on-CPUs cache */
183	bzero(kperf_thread_on_cpus, ncpus * sizeof(*kperf_thread_on_cpus));
184	}
185
186	/* ping all CPUs */
187	kperf_mp_broadcast_running(timer);
188
189	/* release the pet thread? */
190	if (ntimer == pet_timer_id) {
191	/* PET mode is responsible for rearming the timer */
192	kperf_pet_fire_after();
193	} else {
194	/*
195	* FIXME: Get the current time from elsewhere. The next
196	* timer's period now includes the time taken to reach this
197	* point. This causes a bias towards longer sampling periods
198	* than requested.
199	*/
200	kperf_timer_schedule(timer, mach_absolute_time());
201	}
202
203	deactivate:
204	timer->active = 0;
205	}
206
207	/* program the timer from the PET thread */
208	void
209	kperf_timer_pet_rearm(uint64_t elapsed_ticks)
210	{
211	struct kperf_timer *timer = NULL;
212	uint64_t period = 0;
213	uint64_t deadline;
214
215	/*
216	* If the pet_timer_id is invalid, it has been disabled, so this should
217	* do nothing.
218	*/
219	if (pet_timer_id >= kperf_timerc) {
220	return;
221	}
222
223	unsigned int status = kperf_sampling_status();
224	/* do not reprogram the timer if it has been shutdown or sampling is off */
225	if (status == KPERF_SAMPLING_OFF) {
226	BUF_INFO(PERF_PET_END, SAMPLE_OFF);
227	return;
228	} else if (status == KPERF_SAMPLING_SHUTDOWN) {
229	BUF_INFO(PERF_PET_END, SAMPLE_SHUTDOWN);
230	return;
231	}
232
233	timer = &(kperf_timerv[pet_timer_id]);
234
235	/* if we re-programmed the timer to zero, just drop it */
236	if (!timer->period) {
237	return;
238	}
239
240	/* subtract the time the pet sample took being careful not to underflow */
241	if (timer->period > elapsed_ticks) {
242	period = timer->period - elapsed_ticks;
243	}
244
245	/* make sure we don't set the next PET sample to happen too soon */
246	if (period < min_period_pet_abstime) {
247	period = min_period_pet_abstime;
248	}
249
250	/* we probably took so long in the PET thread, it makes sense to take
251	* the time again.
252	*/
253	deadline = mach_absolute_time() + period;
254
255	BUF_INFO(PERF_PET_SCHED, timer->period, period, elapsed_ticks, deadline);
256
257	/* re-schedule the timer, making sure we don't apply slop */
258	timer_call_enter(&(timer->tcall), deadline, TIMER_CALL_SYS_CRITICAL);
259
260	return;
261	}
262
263	/* turn on all the timers */
264	void
265	kperf_timer_go(void)
266	{
267	/* get the PET thread going */
268	if (pet_timer_id < kperf_timerc) {
269	kperf_pet_config(kperf_timerv[pet_timer_id].actionid);
270	}
271
272	uint64_t now = mach_absolute_time();
273
274	for (unsigned int i = 0; i < kperf_timerc; i++) {
275	if (kperf_timerv[i].period == 0) {
276	continue;
277	}
278
279	kperf_timer_schedule(&(kperf_timerv[i]), now);
280	}
281	}
282
283	void
284	kperf_timer_stop(void)
285	{
286	for (unsigned int i = 0; i < kperf_timerc; i++) {
287	if (kperf_timerv[i].period == 0) {
288	continue;
289	}
290
291	/* wait for the timer to stop */
292	while (kperf_timerv[i].active);
293
294	timer_call_cancel(&(kperf_timerv[i].tcall));
295	}
296
297	/* wait for PET to stop, too */
298	kperf_pet_config(0);
299	}
300
301	unsigned int
302	kperf_timer_get_petid(void)
303	{
304	return pet_timer_id;
305	}
306
307	int
308	kperf_timer_set_petid(unsigned int timerid)
309	{
310	if (timerid < kperf_timerc) {
311	uint64_t min_period;
312
313	min_period = kperf_timer_min_pet_period_abstime();
314	if (kperf_timerv[timerid].period < min_period) {
315	kperf_timerv[timerid].period = min_period;
316	}
317	kperf_pet_config(kperf_timerv[timerid].actionid);
318	} else {
319	/* clear the PET trigger if it's a bogus ID */
320	kperf_pet_config(0);
321	}
322
323	pet_timer_id = timerid;
324
325	return 0;
326	}
327
328	int
329	kperf_timer_get_period(unsigned int timerid, uint64_t *period_abstime)
330	{
331	if (timerid >= kperf_timerc) {
332	return EINVAL;
333	}
334
335	*period_abstime = kperf_timerv[timerid].period;
336	return 0;
337	}
338
339	int
340	kperf_timer_set_period(unsigned int timerid, uint64_t period_abstime)
341	{
342	uint64_t min_period;
343
344	if (timerid >= kperf_timerc) {
345	return EINVAL;
346	}
347
348	if (pet_timer_id == timerid) {
349	min_period = kperf_timer_min_pet_period_abstime();
350	} else {
351	min_period = kperf_timer_min_period_abstime();
352	}
353
354	if (period_abstime > 0 && period_abstime < min_period) {
355	period_abstime = min_period;
356	}
357
358	kperf_timerv[timerid].period = period_abstime;
359
360	/* FIXME: re-program running timers? */
361
362	return 0;
363	}
364
365	int
366	kperf_timer_get_action(unsigned int timerid, uint32_t *action)
367	{
368	if (timerid >= kperf_timerc) {
369	return EINVAL;
370	}
371
372	*action = kperf_timerv[timerid].actionid;
373	return 0;
374	}
375
376	int
377	kperf_timer_set_action(unsigned int timerid, uint32_t action)
378	{
379	if (timerid >= kperf_timerc) {
380	return EINVAL;
381	}
382
383	kperf_timerv[timerid].actionid = action;
384	return 0;
385	}
386
387	unsigned int
388	kperf_timer_get_count(void)
389	{
390	return kperf_timerc;
391	}
392
393	void
394	kperf_timer_reset(void)
395	{
396	kperf_timer_set_petid(999);
397	kperf_set_pet_idle_rate(KPERF_PET_DEFAULT_IDLE_RATE);
398	kperf_set_lightweight_pet(0);
399	for (unsigned int i = 0; i < kperf_timerc; i++) {
400	kperf_timerv[i].period = 0;
401	kperf_timerv[i].actionid = 0;
402	#if defined(__x86_64__)
403	kperf_timerv[i].pending_cpus = 0;
404	#endif /* defined(__x86_64__) */
405	}
406	}
407
408	extern int
409	kperf_timer_set_count(unsigned int count)
410	{
411	struct kperf_timer new_timerv = NULL, old_timerv = NULL;
412	unsigned int old_count;
413
414	if (min_period_abstime == 0) {
415	nanoseconds_to_absolutetime(MIN_PERIOD_NS, &min_period_abstime);
416	nanoseconds_to_absolutetime(MIN_PERIOD_BG_NS, &min_period_bg_abstime);
417	nanoseconds_to_absolutetime(MIN_PERIOD_PET_NS, &min_period_pet_abstime);
418	nanoseconds_to_absolutetime(MIN_PERIOD_PET_BG_NS,
419	&min_period_pet_bg_abstime);
420	assert(min_period_abstime > 0);
421	}
422
423	if (count == kperf_timerc) {
424	return 0;
425	}
426	if (count > TIMER_MAX) {
427	return EINVAL;
428	}
429
430	/* TODO: allow shrinking? */
431	if (count < kperf_timerc) {
432	return EINVAL;
433	}
434
435	/*
436	* Make sure kperf is initialized when creating the array for the first
437	* time.
438	*/
439	if (kperf_timerc == 0) {
440	int r;
441
442	/* main kperf */
443	if ((r = kperf_init())) {
444	return r;
445	}
446	}
447
448	/*
449	* Shut down any running timers since we will be messing with the timer
450	* call structures.
451	*/
452	kperf_timer_stop();
453
454	/* create a new array */
455	new_timerv = kalloc_tag(count * sizeof(struct kperf_timer),
456	VM_KERN_MEMORY_DIAG);
457	if (new_timerv == NULL) {
458	return ENOMEM;
459	}
460	old_timerv = kperf_timerv;
461	old_count = kperf_timerc;
462
463	if (old_timerv != NULL) {
464	bcopy(kperf_timerv, new_timerv,
465	kperf_timerc * sizeof(struct kperf_timer));
466	}
467
468	/* zero the new entries */
469	bzero(&(new_timerv[kperf_timerc]),
470	(count - old_count) * sizeof(struct kperf_timer));
471
472	/* (re-)setup the timer call info for all entries */
473	for (unsigned int i = 0; i < count; i++) {
474	timer_call_setup(&(new_timerv[i].tcall), kperf_timer_handler, &(new_timerv[i]));
475	}
476
477	kperf_timerv = new_timerv;
478	kperf_timerc = count;
479
480	if (old_timerv != NULL) {
481	kfree(old_timerv, old_count * sizeof(struct kperf_timer));
482	}
483
484	return 0;
485	}