[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 <kern/kalloc.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>
#include <kperf/kperf.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_SW_INC              (14)

/* 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 */
#define SYSCTL_BUFFER_SIZE (33 * sizeof(uint64_t))
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_arch_init(void);
extern void kpc_common_init(void);
extern void kpc_thread_init(void); /* osfmk/kern/kpc_thread.c */

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_common_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_set_int( struct sysctl_req *req, int (*set_func)(int))
{
	int error = 0;
	int value = 0;
    
	error = SYSCTL_IN( req, &value, sizeof(value) );
	if( error )
		return error;
    
	error = set_func( value );

	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 = kalloc(SYSCTL_BUFFER_SIZE);
		if( sysctl_buffer )
		{
			bzero( sysctl_buffer, SYSCTL_BUFFER_SIZE );
		}
	}

	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 = SYSCTL_BUFFER_SIZE;
	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 = SYSCTL_BUFFER_SIZE;
	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");

	// Most sysctls require an access check, but a few are public.
	switch( (uintptr_t) arg1 ) {
	case REQ_CLASSES:
	case REQ_CONFIG_COUNT:
	case REQ_COUNTER_COUNT:
		// These read-only sysctls are public.
		break;

	default:
		// Require kperf access to read or write anything else.
		// This is either root or the blessed pid.
		ret = kperf_access_check();
		if (ret) {
			return ret;
		}
		break;
	}

	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;


	case REQ_SW_INC:
		ret = sysctl_set_int( req, (setget_func_t)kpc_set_sw_inc );
		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");

SYSCTL_PROC(_kpc, OID_AUTO, sw_inc,
            CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
            (void*)REQ_SW_INC, 
            sizeof(int), kpc_sysctl, "S", "Software increment");

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