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

/*
 * Copyright (c) 2012 Apple 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@
 */

#include <kern/debug.h>
#include <sys/param.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <libkern/libkern.h>
#include <kern/assert.h>

#include <kern/kpc.h>

#include <pexpert/pexpert.h>

/* Various sysctl requests */
#define REQ_CLASSES              (1)
#define REQ_COUNTING             (2)
#define REQ_THREAD_COUNTING      (3)
#define REQ_CONFIG_COUNT         (4)
#define REQ_COUNTER_COUNT        (5)
#define REQ_THREAD_COUNTERS      (6)
#define REQ_COUNTERS             (7)
#define REQ_SHADOW_COUNTERS      (8)
#define REQ_CONFIG               (9)
#define REQ_PERIOD              (10)
#define REQ_ACTIONID            (11)
#define REQ_FORCE_ALL_CTRS      (12)
#define REQ_DISABLE_WHITELIST   (13)

/* Type-munging casts */
typedef int (*getint_t)(void);
typedef int (*setint_t)(int);

/* safety */
static int kpc_initted = 0;

/* locking and buffer for large data requests */
static lck_grp_attr_t *sysctl_buffer_lckgrp_attr = NULL;
static lck_grp_t      *sysctl_buffer_lckgrp = NULL;
static lck_mtx_t       sysctl_buffer_lock;
static void           *sysctl_buffer = NULL;

typedef int (*setget_func_t)(int);

/* init our stuff */
extern void kpc_thread_init(void); /* osfmk/kern/kpc_thread.c */
extern void kpc_arch_init(void);

void
kpc_init(void)
{
	sysctl_buffer_lckgrp_attr = lck_grp_attr_alloc_init();
        sysctl_buffer_lckgrp = lck_grp_alloc_init("kpc", 
                                                  sysctl_buffer_lckgrp_attr);
	lck_mtx_init(&sysctl_buffer_lock, sysctl_buffer_lckgrp, LCK_ATTR_NULL);

	kpc_arch_init();
	kpc_thread_init();

	kpc_initted = 1;
}

/* abstract sysctl handlers */
static int
sysctl_get_int( struct sysctl_oid *oidp, struct sysctl_req *req,
                uint32_t value )
{
	int error = 0;
    
	/* copy out the old value */
	error = sysctl_handle_int(oidp, &value, 0, req);
    
	return error;
}

static int
sysctl_getset_int( struct sysctl_oid *oidp, struct sysctl_req *req,
                   int (*get_func)(void), int (*set_func)(int) )
{
	int error = 0;
	uint32_t value = 0;
    
	/* get the old value and process it */
	value = get_func();

	/* copy out the old value, get the new value */
	error = sysctl_handle_int(oidp, &value, 0, req);
	if (error || !req->newptr)
		return (error);

	/* if that worked, and we're writing... */
	error = set_func( value );

	return error;
}

static int
sysctl_setget_int( struct sysctl_req *req,
                   int (*setget_func)(int) )
{
	int error = 0;
	int value = 0;
    
	error = SYSCTL_IN( req, &value, sizeof(value) );
	if( error )
		return error;
	
	value = setget_func(value);

	error = SYSCTL_OUT( req, &value, sizeof(value) );

	return error;
}

static int
kpc_sysctl_acquire_buffer(void)
{
	if( sysctl_buffer == NULL )
		sysctl_buffer = kpc_counterbuf_alloc();

	if( !sysctl_buffer )
	{
		return ENOMEM;
	}

	return 0;
}

static int 
sysctl_kpc_get_counters(uint32_t counters,
                      uint32_t *size, void *buf)
{
	uint64_t *ctr_buf = (uint64_t*)buf;
	int curcpu;
	uint32_t count;

	count = kpc_get_cpu_counters(counters & KPC_ALL_CPUS,
	                             counters,
	                             &curcpu, &ctr_buf[1]);
	if (!count)
		return EINVAL;

	ctr_buf[0] = curcpu;

	*size = (count+1) * sizeof(uint64_t);

	return 0;
}

static int 
sysctl_kpc_get_shadow_counters(uint32_t counters,
                      uint32_t *size, void *buf)
{
	uint64_t *ctr_buf = (uint64_t*)buf;
	int curcpu;
	uint32_t count;

	count = kpc_get_shadow_counters(counters & KPC_ALL_CPUS,
	                                counters,
	                                &curcpu, &ctr_buf[1]);

	if (!count)
		return EINVAL;

	ctr_buf[0] = curcpu;

	*size = (count+1) * sizeof(uint64_t);

	return 0;
}

static int 
sysctl_kpc_get_thread_counters(uint32_t tid,
                             uint32_t *size, void *buf)
{
	uint32_t count = *size / sizeof(uint64_t);
	int r;

	if( tid != 0 )
		return EINVAL;

	r = kpc_get_curthread_counters(&count, buf);
	if( !r )
		*size = count * sizeof(uint64_t);

	return r;
}   

static int
sysctl_kpc_get_config(uint32_t classes, void* buf)
{
	return kpc_get_config( classes, buf );
}

static int
sysctl_kpc_set_config(uint32_t classes, void* buf)
{
	return kpc_set_config( classes, buf);
}

static int
sysctl_kpc_get_period(uint32_t classes, void* buf)
{
	return kpc_get_period( classes, buf );
}

static int
sysctl_kpc_set_period(uint32_t classes, void* buf)
{
	return kpc_set_period( classes, buf);
}

static int
sysctl_kpc_get_actionid(uint32_t classes, void* buf)
{
	return kpc_get_actionid( classes, buf );
}

static int
sysctl_kpc_set_actionid(uint32_t classes, void* buf)
{
	return kpc_set_actionid( classes, buf);
}


static int
sysctl_get_bigarray( struct sysctl_req *req, 
                     int (*get_fn)(uint32_t, uint32_t*, void*) )
{
	int error = 0;
	uint32_t bufsize = KPC_MAX_COUNTERS * sizeof(uint64_t); /* XXX? */
	uint32_t arg = 0;

	/* get the argument */
	error = SYSCTL_IN( req, &arg, sizeof(arg) );
	if(error)
	{
		printf( "kpc: no arg?\n" );
		return error;
	}

	/* get the wired buffer */
	error = kpc_sysctl_acquire_buffer();
	if (error)
		return error;

	/* atomically get the array into the wired buffer. We have a double
	 * copy, but this is better than page faulting / interrupting during
	 * a copy.
	 */
	error = get_fn( arg, &bufsize, sysctl_buffer );

	/* do the copy out */
	if( !error )
		error = SYSCTL_OUT( req, sysctl_buffer, bufsize );

	return error;
}

/* given a config word, how many bytes does it take? */
static int
sysctl_config_size( uint32_t config )
{
	return kpc_get_config_count(config) * sizeof(kpc_config_t);
}

static int
sysctl_counter_size( uint32_t classes )
{
	return kpc_get_counter_count(classes) * sizeof(uint64_t);
}

static int
sysctl_actionid_size( uint32_t classes )
{
	return kpc_get_counter_count(classes) * sizeof(int32_t);
}

static int
sysctl_getset_bigarray( struct sysctl_req *req, 
                        int (*size_fn)(uint32_t arg),
                        int (*get_fn)(uint32_t, void*),
                        int (*set_fn)(uint32_t, void*) )
{
	int error = 0;
	uint32_t bufsize = KPC_MAX_COUNTERS * sizeof(uint64_t); /* XXX? */
	uint32_t regsize = 0;
	uint64_t arg;

	/* get the config word */
	error = SYSCTL_IN( req, &arg, sizeof(arg) );
	if(error)
	{
		printf( "kpc: no arg?\n" );
		return error;
	}

	/* Work out size of registers */
	regsize = size_fn((uint32_t)arg);

	/* Ignore NULL requests */
	if(regsize == 0)
		return EINVAL;

	/* ensure not too big */
	if( regsize > bufsize )
		return EINVAL;

	/* get the wired buffer */
	error = kpc_sysctl_acquire_buffer();
	if (error)
		return error;

	// if writing...
	if(req->newptr)
	{
		// copy in the rest in -- sysctl remembers we did one already
		error = SYSCTL_IN( req, sysctl_buffer, 
		                   regsize );

		// if SYSCTL_IN fails it means we are only doing a read
		if(!error) {
			// set it
			error = set_fn( (uint32_t)arg, sysctl_buffer );
			if( error )
				goto fail;
		}
	}

	// if reading
	if(req->oldptr)
	{
		// read it
		error = get_fn( (uint32_t)arg, sysctl_buffer );
		if( error )
			goto fail;

		// copy out the full set
		error = SYSCTL_OUT( req, sysctl_buffer, regsize );
	}
   
fail:
	return error;
}


/*
 * #define SYSCTL_HANDLER_ARGS (struct sysctl_oid *oidp,         \
 *                                void *arg1, int arg2,                 \
 *                              struct sysctl_req *req )
 */
static int
kpc_sysctl SYSCTL_HANDLER_ARGS
{
	int ret;

	// __unused struct sysctl_oid *unused_oidp = oidp;
	(void)arg2;
    
	if( !kpc_initted )
		panic("kpc_init not called");

	lck_mtx_lock(&sysctl_buffer_lock);

	/* which request */
	switch( (uintptr_t) arg1 )
	{
	case REQ_CLASSES:
		ret = sysctl_get_int( oidp, req,
		                       kpc_get_classes() );
		break;
	case REQ_COUNTING:
		ret = sysctl_getset_int( oidp, req,
		                          (getint_t)kpc_get_running,
		                          (setint_t)kpc_set_running );
		break;
	case REQ_THREAD_COUNTING:
		ret = sysctl_getset_int( oidp, req,
		                          (getint_t)kpc_get_thread_counting,
		                          (setint_t)kpc_set_thread_counting );
		break;

	case REQ_CONFIG_COUNT:
		ret = sysctl_setget_int( req,
		                          (setget_func_t)kpc_get_config_count );
		break;

	case REQ_COUNTER_COUNT:
		ret = sysctl_setget_int( req,
		                          (setget_func_t)kpc_get_counter_count );
		break;


	case REQ_THREAD_COUNTERS:
		ret = sysctl_get_bigarray( req, sysctl_kpc_get_thread_counters );
		break;

	case REQ_COUNTERS:
		ret = sysctl_get_bigarray( req, sysctl_kpc_get_counters );
		break;

	case REQ_SHADOW_COUNTERS:
		ret = sysctl_get_bigarray( req, sysctl_kpc_get_shadow_counters );
		break;

	case REQ_CONFIG:
		ret = sysctl_getset_bigarray( req,
		                               sysctl_config_size,
		                               sysctl_kpc_get_config,
		                               sysctl_kpc_set_config );
		break;

	case REQ_PERIOD:
		ret = sysctl_getset_bigarray( req,
		                               sysctl_counter_size,
		                               sysctl_kpc_get_period,
		                               sysctl_kpc_set_period );
		break;

	case REQ_ACTIONID:
		ret = sysctl_getset_bigarray( req,
		                               sysctl_actionid_size,
		                               sysctl_kpc_get_actionid,
		                               sysctl_kpc_set_actionid );
		break;

	default:
		ret = ENOENT;
		break;
	}

	lck_mtx_unlock(&sysctl_buffer_lock);
 
	return ret;
}


/***  sysctl definitions  ***/

/* root kperf node */
SYSCTL_NODE(, OID_AUTO, kpc, CTLFLAG_RW|CTLFLAG_LOCKED, 0,
            "kpc");

/* values */
SYSCTL_PROC(_kpc, OID_AUTO, classes,
            CTLTYPE_INT|CTLFLAG_RD|CTLFLAG_ANYBODY,
            (void*)REQ_CLASSES, 
            sizeof(int), kpc_sysctl, "I", "Available classes");

SYSCTL_PROC(_kpc, OID_AUTO, counting,
            CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
            (void*)REQ_COUNTING, 
            sizeof(int), kpc_sysctl, "I", "PMCs counting");

SYSCTL_PROC(_kpc, OID_AUTO, thread_counting,
            CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
            (void*)REQ_THREAD_COUNTING, 
            sizeof(int), kpc_sysctl, "I", "Thread accumulation");

/* faux values */
SYSCTL_PROC(_kpc, OID_AUTO, config_count,
            CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
            (void*)REQ_CONFIG_COUNT, 
            sizeof(int), kpc_sysctl, "S", "Config count");

SYSCTL_PROC(_kpc, OID_AUTO, counter_count,
            CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
            (void*)REQ_COUNTER_COUNT, 
            sizeof(int), kpc_sysctl, "S", "Counter count");

/* arrays */
SYSCTL_PROC(_kpc, OID_AUTO, thread_counters,
            CTLFLAG_RD|CTLFLAG_WR|CTLFLAG_ANYBODY,
            (void*)REQ_THREAD_COUNTERS, 
            sizeof(uint64_t), kpc_sysctl, 
            "QU", "Current thread counters");

SYSCTL_PROC(_kpc, OID_AUTO, counters,
            CTLFLAG_RD|CTLFLAG_WR|CTLFLAG_ANYBODY,
            (void*)REQ_COUNTERS, 
            sizeof(uint64_t), kpc_sysctl, 
            "QU", "Current counters");

SYSCTL_PROC(_kpc, OID_AUTO, shadow_counters,
            CTLFLAG_RD|CTLFLAG_WR|CTLFLAG_ANYBODY,
            (void*)REQ_SHADOW_COUNTERS, 
            sizeof(uint64_t), kpc_sysctl, 
            "QU", "Current shadow counters");

SYSCTL_PROC(_kpc, OID_AUTO, config,
            CTLFLAG_RD|CTLFLAG_WR|CTLFLAG_ANYBODY,
            (void*)REQ_CONFIG, 
            sizeof(uint64_t), kpc_sysctl, 
            "QU", "Set counter configs");

SYSCTL_PROC(_kpc, OID_AUTO, period,
            CTLFLAG_RD|CTLFLAG_WR|CTLFLAG_ANYBODY,
            (void*)REQ_PERIOD, 
            sizeof(uint64_t), kpc_sysctl, 
            "QU", "Set counter periods");

SYSCTL_PROC(_kpc, OID_AUTO, actionid,
            CTLFLAG_RD|CTLFLAG_WR|CTLFLAG_ANYBODY,
            (void*)REQ_ACTIONID, 
            sizeof(uint32_t), kpc_sysctl, 
            "QU", "Set counter actionids");
Commit	Line	Data
39236c6e A	1	/*
	2	* Copyright (c) 2012 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
	29	#include <kern/debug.h>
	30	#include <sys/param.h>
	31	#include <sys/mman.h>
	32	#include <sys/stat.h>
	33	#include <sys/sysctl.h>
	34	#include <libkern/libkern.h>
	35	#include <kern/assert.h>
	36
	37	#include <kern/kpc.h>
	38
	39	#include <pexpert/pexpert.h>
	40
	41	/* Various sysctl requests */
	42	#define REQ_CLASSES (1)
	43	#define REQ_COUNTING (2)
	44	#define REQ_THREAD_COUNTING (3)
	45	#define REQ_CONFIG_COUNT (4)
	46	#define REQ_COUNTER_COUNT (5)
	47	#define REQ_THREAD_COUNTERS (6)
	48	#define REQ_COUNTERS (7)
	49	#define REQ_SHADOW_COUNTERS (8)
	50	#define REQ_CONFIG (9)
	51	#define REQ_PERIOD (10)
	52	#define REQ_ACTIONID (11)
	53	#define REQ_FORCE_ALL_CTRS (12)
	54	#define REQ_DISABLE_WHITELIST (13)
	55
	56	/* Type-munging casts */
	57	typedef int (*getint_t)(void);
	58	typedef int (*setint_t)(int);
	59
	60	/* safety */
	61	static int kpc_initted = 0;
	62
	63	/* locking and buffer for large data requests */
	64	static lck_grp_attr_t *sysctl_buffer_lckgrp_attr = NULL;
65	static lck_grp_t *sysctl_buffer_lckgrp = NULL;
66	static lck_mtx_t sysctl_buffer_lock;
67	static void *sysctl_buffer = NULL;
68
69	typedef int (*setget_func_t)(int);
70
71	/* init our stuff */
72	extern void kpc_thread_init(void); /* osfmk/kern/kpc_thread.c */
73	extern void kpc_arch_init(void);
74
75	void
76	kpc_init(void)
77	{
78	sysctl_buffer_lckgrp_attr = lck_grp_attr_alloc_init();
79	sysctl_buffer_lckgrp = lck_grp_alloc_init("kpc",
80	sysctl_buffer_lckgrp_attr);
81	lck_mtx_init(&sysctl_buffer_lock, sysctl_buffer_lckgrp, LCK_ATTR_NULL);
82
83	kpc_arch_init();
84	kpc_thread_init();
85
86	kpc_initted = 1;
87	}
88
89	/* abstract sysctl handlers */
90	static int
91	sysctl_get_int( struct sysctl_oid oidp, struct sysctl_req req,
92	uint32_t value )
93	{
94	int error = 0;
95
96	/* copy out the old value */
97	error = sysctl_handle_int(oidp, &value, 0, req);
98
99	return error;
100	}
101
102	static int
103	sysctl_getset_int( struct sysctl_oid oidp, struct sysctl_req req,
104	int (get_func)(void), int (set_func)(int) )
105	{
106	int error = 0;
107	uint32_t value = 0;
108
109	/* get the old value and process it */
110	value = get_func();
111
112	/* copy out the old value, get the new value */
113	error = sysctl_handle_int(oidp, &value, 0, req);
114	if (error \|\| !req->newptr)
115	return (error);
116
117	/* if that worked, and we're writing... */
118	error = set_func( value );
119
120	return error;
121	}
122
123	static int
124	sysctl_setget_int( struct sysctl_req *req,
125	int (*setget_func)(int) )
126	{
127	int error = 0;
128	int value = 0;
129
130	error = SYSCTL_IN( req, &value, sizeof(value) );
131	if( error )
132	return error;
133
134	value = setget_func(value);
135
136	error = SYSCTL_OUT( req, &value, sizeof(value) );
137
138	return error;
139	}
140
141	static int
142	kpc_sysctl_acquire_buffer(void)
143	{
144	if( sysctl_buffer == NULL )
145	sysctl_buffer = kpc_counterbuf_alloc();
146
147	if( !sysctl_buffer )
148	{
149	return ENOMEM;
150	}
151
152	return 0;
153	}
154
155	static int
156	sysctl_kpc_get_counters(uint32_t counters,
157	uint32_t size, void buf)
158	{
159	uint64_t ctr_buf = (uint64_t)buf;
160	int curcpu;
161	uint32_t count;
162
163	count = kpc_get_cpu_counters(counters & KPC_ALL_CPUS,
164	counters,
165	&curcpu, &ctr_buf[1]);
166	if (!count)
167	return EINVAL;
168
169	ctr_buf[0] = curcpu;
170
171	size = (count+1) sizeof(uint64_t);
172
173	return 0;
174	}
175
176	static int
177	sysctl_kpc_get_shadow_counters(uint32_t counters,
178	uint32_t size, void buf)
179	{
180	uint64_t ctr_buf = (uint64_t)buf;
181	int curcpu;
182	uint32_t count;
183
184	count = kpc_get_shadow_counters(counters & KPC_ALL_CPUS,
185	counters,
186	&curcpu, &ctr_buf[1]);
187
188	if (!count)
189	return EINVAL;
190
191	ctr_buf[0] = curcpu;
192
193	size = (count+1) sizeof(uint64_t);
194
195	return 0;
196	}
197
198	static int
199	sysctl_kpc_get_thread_counters(uint32_t tid,
200	uint32_t size, void buf)
201	{
202	uint32_t count = *size / sizeof(uint64_t);
203	int r;
204
205	if( tid != 0 )
206	return EINVAL;
207
208	r = kpc_get_curthread_counters(&count, buf);
209	if( !r )
210	size = count sizeof(uint64_t);
211
212	return r;
213	}
214
215	static int
216	sysctl_kpc_get_config(uint32_t classes, void* buf)
217	{
218	return kpc_get_config( classes, buf );
219	}
220
221	static int
222	sysctl_kpc_set_config(uint32_t classes, void* buf)
223	{
224	return kpc_set_config( classes, buf);
225	}
226
227	static int
228	sysctl_kpc_get_period(uint32_t classes, void* buf)
229	{
230	return kpc_get_period( classes, buf );
231	}
232
233	static int
234	sysctl_kpc_set_period(uint32_t classes, void* buf)
235	{
236	return kpc_set_period( classes, buf);
237	}
238
239	static int
240	sysctl_kpc_get_actionid(uint32_t classes, void* buf)
241	{
242	return kpc_get_actionid( classes, buf );
243	}
244
245	static int
246	sysctl_kpc_set_actionid(uint32_t classes, void* buf)
247	{
248	return kpc_set_actionid( classes, buf);
249	}
250
251
252	static int
253	sysctl_get_bigarray( struct sysctl_req *req,
254	int (get_fn)(uint32_t, uint32_t, void*) )
255	{
256	int error = 0;
257	uint32_t bufsize = KPC_MAX_COUNTERS * sizeof(uint64_t); /* XXX? */
258	uint32_t arg = 0;
259
260	/* get the argument */
261	error = SYSCTL_IN( req, &arg, sizeof(arg) );
262	if(error)
263	{
264	printf( "kpc: no arg?\n" );
265	return error;
266	}
267
268	/* get the wired buffer */
269	error = kpc_sysctl_acquire_buffer();
270	if (error)
271	return error;
272
273	/* atomically get the array into the wired buffer. We have a double
274	* copy, but this is better than page faulting / interrupting during
275	* a copy.
276	*/
277	error = get_fn( arg, &bufsize, sysctl_buffer );
278
279	/* do the copy out */
280	if( !error )
281	error = SYSCTL_OUT( req, sysctl_buffer, bufsize );
282
283	return error;
284	}
285
286	/* given a config word, how many bytes does it take? */
287	static int
288	sysctl_config_size( uint32_t config )
289	{
290	return kpc_get_config_count(config) * sizeof(kpc_config_t);
291	}
292
293	static int
294	sysctl_counter_size( uint32_t classes )
295	{
296	return kpc_get_counter_count(classes) * sizeof(uint64_t);
297	}
298
299	static int
300	sysctl_actionid_size( uint32_t classes )
301	{
302	return kpc_get_counter_count(classes) * sizeof(int32_t);
303	}
304
305	static int
306	sysctl_getset_bigarray( struct sysctl_req *req,
307	int (*size_fn)(uint32_t arg),
308	int (get_fn)(uint32_t, void),
309	int (set_fn)(uint32_t, void) )
310	{
311	int error = 0;
312	uint32_t bufsize = KPC_MAX_COUNTERS * sizeof(uint64_t); /* XXX? */
313	uint32_t regsize = 0;
314	uint64_t arg;
315
316	/* get the config word */
317	error = SYSCTL_IN( req, &arg, sizeof(arg) );
318	if(error)
319	{
320	printf( "kpc: no arg?\n" );
321	return error;
322	}
323
324	/* Work out size of registers */
325	regsize = size_fn((uint32_t)arg);
326
327	/* Ignore NULL requests */
328	if(regsize == 0)
329	return EINVAL;
330
331	/* ensure not too big */
332	if( regsize > bufsize )
333	return EINVAL;
334
335	/* get the wired buffer */
336	error = kpc_sysctl_acquire_buffer();
337	if (error)
338	return error;
339
340	// if writing...
341	if(req->newptr)
342	{
343	// copy in the rest in -- sysctl remembers we did one already
344	error = SYSCTL_IN( req, sysctl_buffer,
345	regsize );
346
347	// if SYSCTL_IN fails it means we are only doing a read
348	if(!error) {
349	// set it
350	error = set_fn( (uint32_t)arg, sysctl_buffer );
351	if( error )
352	goto fail;
353	}
354	}
355
356	// if reading
357	if(req->oldptr)
358	{
359	// read it
360	error = get_fn( (uint32_t)arg, sysctl_buffer );
361	if( error )
362	goto fail;
363
364	// copy out the full set
365	error = SYSCTL_OUT( req, sysctl_buffer, regsize );
366	}
367
368	fail:
369	return error;
370	}
371
372
373
374	/*
375	* #define SYSCTL_HANDLER_ARGS (struct sysctl_oid *oidp, \
376	* void *arg1, int arg2, \
377	* struct sysctl_req *req )
378	*/
379	static int
380	kpc_sysctl SYSCTL_HANDLER_ARGS
381	{
382	int ret;
383
384	// __unused struct sysctl_oid *unused_oidp = oidp;
385	(void)arg2;
386
387	if( !kpc_initted )
388	panic("kpc_init not called");
389
390	lck_mtx_lock(&sysctl_buffer_lock);
391
392	/* which request */
393	switch( (uintptr_t) arg1 )
394	{
395	case REQ_CLASSES:
396	ret = sysctl_get_int( oidp, req,
397	kpc_get_classes() );
398	break;
399	case REQ_COUNTING:
400	ret = sysctl_getset_int( oidp, req,
401	(getint_t)kpc_get_running,
402	(setint_t)kpc_set_running );
403	break;
404	case REQ_THREAD_COUNTING:
405	ret = sysctl_getset_int( oidp, req,
406	(getint_t)kpc_get_thread_counting,
407	(setint_t)kpc_set_thread_counting );
408	break;
409
410	case REQ_CONFIG_COUNT:
411	ret = sysctl_setget_int( req,
412	(setget_func_t)kpc_get_config_count );
413	break;
414
415	case REQ_COUNTER_COUNT:
416	ret = sysctl_setget_int( req,
417	(setget_func_t)kpc_get_counter_count );
418	break;
419
420
421	case REQ_THREAD_COUNTERS:
422	ret = sysctl_get_bigarray( req, sysctl_kpc_get_thread_counters );
423	break;
424
425	case REQ_COUNTERS:
426	ret = sysctl_get_bigarray( req, sysctl_kpc_get_counters );
427	break;
428
429	case REQ_SHADOW_COUNTERS:
430	ret = sysctl_get_bigarray( req, sysctl_kpc_get_shadow_counters );
431	break;
432
433	case REQ_CONFIG:
434	ret = sysctl_getset_bigarray( req,
435	sysctl_config_size,
436	sysctl_kpc_get_config,
437	sysctl_kpc_set_config );
438	break;
439
440	case REQ_PERIOD:
441	ret = sysctl_getset_bigarray( req,
442	sysctl_counter_size,
443	sysctl_kpc_get_period,
444	sysctl_kpc_set_period );
445	break;
446
447	case REQ_ACTIONID:
448	ret = sysctl_getset_bigarray( req,
449	sysctl_actionid_size,
450	sysctl_kpc_get_actionid,
451	sysctl_kpc_set_actionid );
452	break;
453
454	default:
455	ret = ENOENT;
456	break;
457	}
458
459	lck_mtx_unlock(&sysctl_buffer_lock);
460
461	return ret;
462	}
463
464
465	/* sysctl definitions */
466
467	/* root kperf node */
468	SYSCTL_NODE(, OID_AUTO, kpc, CTLFLAG_RW\|CTLFLAG_LOCKED, 0,
469	"kpc");
470
471	/* values */
472	SYSCTL_PROC(_kpc, OID_AUTO, classes,
473	CTLTYPE_INT\|CTLFLAG_RD\|CTLFLAG_ANYBODY,
474	(void*)REQ_CLASSES,
475	sizeof(int), kpc_sysctl, "I", "Available classes");
476
477	SYSCTL_PROC(_kpc, OID_AUTO, counting,
478	CTLTYPE_INT\|CTLFLAG_RW\|CTLFLAG_ANYBODY,
479	(void*)REQ_COUNTING,
480	sizeof(int), kpc_sysctl, "I", "PMCs counting");
481
482	SYSCTL_PROC(_kpc, OID_AUTO, thread_counting,
483	CTLTYPE_INT\|CTLFLAG_RW\|CTLFLAG_ANYBODY,
484	(void*)REQ_THREAD_COUNTING,
485	sizeof(int), kpc_sysctl, "I", "Thread accumulation");
486
487	/* faux values */
488	SYSCTL_PROC(_kpc, OID_AUTO, config_count,
489	CTLTYPE_INT\|CTLFLAG_RW\|CTLFLAG_ANYBODY,
490	(void*)REQ_CONFIG_COUNT,
491	sizeof(int), kpc_sysctl, "S", "Config count");
492
493	SYSCTL_PROC(_kpc, OID_AUTO, counter_count,
494	CTLTYPE_INT\|CTLFLAG_RW\|CTLFLAG_ANYBODY,
495	(void*)REQ_COUNTER_COUNT,
496	sizeof(int), kpc_sysctl, "S", "Counter count");
497
498	/* arrays */
499	SYSCTL_PROC(_kpc, OID_AUTO, thread_counters,
500	CTLFLAG_RD\|CTLFLAG_WR\|CTLFLAG_ANYBODY,
501	(void*)REQ_THREAD_COUNTERS,
502	sizeof(uint64_t), kpc_sysctl,
503	"QU", "Current thread counters");
504
505	SYSCTL_PROC(_kpc, OID_AUTO, counters,
506	CTLFLAG_RD\|CTLFLAG_WR\|CTLFLAG_ANYBODY,
507	(void*)REQ_COUNTERS,
508	sizeof(uint64_t), kpc_sysctl,
509	"QU", "Current counters");
510
511	SYSCTL_PROC(_kpc, OID_AUTO, shadow_counters,
512	CTLFLAG_RD\|CTLFLAG_WR\|CTLFLAG_ANYBODY,
513	(void*)REQ_SHADOW_COUNTERS,
514	sizeof(uint64_t), kpc_sysctl,
515	"QU", "Current shadow counters");
516
517	SYSCTL_PROC(_kpc, OID_AUTO, config,
518	CTLFLAG_RD\|CTLFLAG_WR\|CTLFLAG_ANYBODY,
519	(void*)REQ_CONFIG,
520	sizeof(uint64_t), kpc_sysctl,
521	"QU", "Set counter configs");
522
523	SYSCTL_PROC(_kpc, OID_AUTO, period,
524	CTLFLAG_RD\|CTLFLAG_WR\|CTLFLAG_ANYBODY,
525	(void*)REQ_PERIOD,
526	sizeof(uint64_t), kpc_sysctl,
527	"QU", "Set counter periods");
528
529	SYSCTL_PROC(_kpc, OID_AUTO, actionid,
530	CTLFLAG_RD\|CTLFLAG_WR\|CTLFLAG_ANYBODY,
531	(void*)REQ_ACTIONID,
532	sizeof(uint32_t), kpc_sysctl,
533	"QU", "Set counter actionids");