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

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

/*
 * System Overrides syscall implementation
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/proc_internal.h>
#include <sys/proc.h>
#include <sys/kauth.h>
#include <sys/unistd.h>
#include <sys/priv.h>
#include <security/audit/audit.h>

#include <mach/mach_types.h>
#include <mach/vm_param.h>
#include <kern/task.h>
#include <kern/locks.h>
#include <kern/assert.h>
#include <kern/sched_prim.h>

#include <sys/kern_overrides.h>
#include <sys/bsdtask_info.h>
#include <sys/kdebug.h>
#include <sys/sysproto.h>
#include <sys/msgbuf.h>

/* Mutex for global system override state */
static lck_mtx_t	sys_override_lock;
static lck_grp_t        *sys_override_mtx_grp;
static lck_attr_t       *sys_override_mtx_attr;
static lck_grp_attr_t   *sys_override_mtx_grp_attr;

/* Assertion counts for system properties */
static int64_t		io_throttle_assert_cnt;
static int64_t		cpu_throttle_assert_cnt;

/* Wait Channel for system override */
static uint64_t		sys_override_wait;

/* Global variable to indicate if system_override is enabled */
int 			sys_override_enabled;

/* Sysctl definition for sys_override_enabled */
SYSCTL_INT(_debug, OID_AUTO, sys_override_enabled, CTLFLAG_RW | CTLFLAG_LOCKED, &sys_override_enabled, 0, "");

/* Forward Declarations */
static void enable_system_override(uint64_t flags);
static void disable_system_override(uint64_t flags);
static __attribute__((noinline)) void PROCESS_OVERRIDING_SYSTEM_DEFAULTS(uint64_t timeout);

/***************************** system_override ********************/
/*
 * int system_override(uint64_t timeout, uint64_t flags);
 */

void
init_system_override()
{
	sys_override_mtx_grp_attr = lck_grp_attr_alloc_init();
	sys_override_mtx_grp = lck_grp_alloc_init("system_override", sys_override_mtx_grp_attr);
	sys_override_mtx_attr = lck_attr_alloc_init();
	lck_mtx_init(&sys_override_lock, sys_override_mtx_grp, sys_override_mtx_attr);
	io_throttle_assert_cnt = cpu_throttle_assert_cnt = 0;
	sys_override_enabled = 1;
}

/* system call implementation */
int
system_override(__unused struct proc *p, struct system_override_args * uap, __unused int32_t *retval)
{
	uint64_t timeout = uap->timeout;
	uint64_t flags = uap->flags;
	int error = 0;

	/* Check credentials for caller. Only entitled processes are allowed to make this call. */
	if ((error = priv_check_cred(kauth_cred_get(), PRIV_SYSTEM_OVERRIDE, 0))) {
		goto out;
	}	

	/* Check to see if some flags are specified. */
	if ((flags & ~SYS_OVERRIDE_FLAGS_MASK) != 0) {
		error = EINVAL;
		goto out;
	}

	if (flags == SYS_OVERRIDE_DISABLE) {
		
		printf("Process %s [%d] disabling system_override()\n", current_proc()->p_comm, current_proc()->p_pid);

		lck_mtx_lock(&sys_override_lock);
		
		if (io_throttle_assert_cnt > 0)
			sys_override_io_throttle(THROTTLE_IO_ENABLE);
		if (cpu_throttle_assert_cnt > 0)
			sys_override_cpu_throttle(CPU_THROTTLE_ENABLE);

		sys_override_enabled = 0;
				
		lck_mtx_unlock(&sys_override_lock);

		goto out;
	}

	lck_mtx_lock(&sys_override_lock);

	enable_system_override(flags);

	PROCESS_OVERRIDING_SYSTEM_DEFAULTS(timeout);

	disable_system_override(flags);

	lck_mtx_unlock(&sys_override_lock);

out:
	return error;
}

/*
 * Call for enabling global system override.
 * This should be called only with the sys_override_lock held.
 */
static void
enable_system_override(uint64_t flags)
{
	
	if (flags & SYS_OVERRIDE_IO_THROTTLE) {
		if ((io_throttle_assert_cnt == 0) && sys_override_enabled) {
			/* Disable I/O Throttling */
			printf("Process %s [%d] disabling system-wide I/O Throttling\n", current_proc()->p_comm, current_proc()->p_pid);
			sys_override_io_throttle(THROTTLE_IO_DISABLE);
		}
		KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_START, current_proc()->p_pid, 0, 0, 0, 0);
		io_throttle_assert_cnt++;
	}
	
	if (flags & SYS_OVERRIDE_CPU_THROTTLE) {
		if ((cpu_throttle_assert_cnt == 0) && sys_override_enabled) {
			/* Disable CPU Throttling */
			printf("Process %s [%d] disabling system-wide CPU Throttling\n", current_proc()->p_comm, current_proc()->p_pid);
			sys_override_cpu_throttle(CPU_THROTTLE_DISABLE);
		}
		KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_START, current_proc()->p_pid, 0, 0, 0, 0);
		cpu_throttle_assert_cnt++;
	}

}

/*
 * Call for disabling global system override.
 * This should be called only with the sys_override_lock held.
 */
static void
disable_system_override(uint64_t flags)
{

	if (flags & SYS_OVERRIDE_IO_THROTTLE) {
		assert(io_throttle_assert_cnt > 0);
		io_throttle_assert_cnt--;
		KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_END, current_proc()->p_pid, 0, 0, 0, 0);
		if ((io_throttle_assert_cnt == 0) && sys_override_enabled) {
			/* Enable I/O Throttling */
			sys_override_io_throttle(THROTTLE_IO_ENABLE);
		}
	}

	if (flags & SYS_OVERRIDE_CPU_THROTTLE) {
		assert(cpu_throttle_assert_cnt > 0);
		cpu_throttle_assert_cnt--;
		KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_END, current_proc()->p_pid, 0, 0, 0, 0);
		if ((cpu_throttle_assert_cnt == 0) && sys_override_enabled) {
			/* Enable CPU Throttling */
			sys_override_cpu_throttle(CPU_THROTTLE_ENABLE);
		}
	}
}

static __attribute__((noinline)) void
PROCESS_OVERRIDING_SYSTEM_DEFAULTS(uint64_t timeout)
{
	struct timespec ts;
	ts.tv_sec = timeout / NSEC_PER_SEC;
	ts.tv_nsec = timeout - ((long)ts.tv_sec * NSEC_PER_SEC);
	msleep((caddr_t)&sys_override_wait, &sys_override_lock, PRIBIO | PCATCH, "system_override", &ts);
}
Commit	Line	Data
39236c6e A	1	/*
	2	* Copyright (c) 2013 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	/*
	30	* System Overrides syscall implementation
	31	*/
	32
	33	#include <sys/param.h>
	34	#include <sys/systm.h>
	35	#include <sys/kernel.h>
	36	#include <sys/malloc.h>
	37	#include <sys/proc_internal.h>
	38	#include <sys/proc.h>
	39	#include <sys/kauth.h>
	40	#include <sys/unistd.h>
	41	#include <sys/priv.h>
	42	#include <security/audit/audit.h>
	43
	44	#include <mach/mach_types.h>
	45	#include <mach/vm_param.h>
	46	#include <kern/task.h>
fe8ab488	47	#include <kern/locks.h>
39236c6e A	48	#include <kern/assert.h>
	49	#include <kern/sched_prim.h>
	50
	51	#include <sys/kern_overrides.h>
	52	#include <sys/bsdtask_info.h>
	53	#include <sys/kdebug.h>
	54	#include <sys/sysproto.h>
	55	#include <sys/msgbuf.h>
	56
	57	/* Mutex for global system override state */
	58	static lck_mtx_t sys_override_lock;
	59	static lck_grp_t *sys_override_mtx_grp;
	60	static lck_attr_t *sys_override_mtx_attr;
	61	static lck_grp_attr_t *sys_override_mtx_grp_attr;
	62
	63	/* Assertion counts for system properties */
	64	static int64_t io_throttle_assert_cnt;
	65	static int64_t cpu_throttle_assert_cnt;
	66
	67	/* Wait Channel for system override */
	68	static uint64_t sys_override_wait;
	69
fe8ab488 A	70	/* Global variable to indicate if system_override is enabled */
	71	int sys_override_enabled;
	72
	73	/* Sysctl definition for sys_override_enabled */
	74	SYSCTL_INT(_debug, OID_AUTO, sys_override_enabled, CTLFLAG_RW \| CTLFLAG_LOCKED, &sys_override_enabled, 0, "");
	75
39236c6e A	76	/* Forward Declarations */
	77	static void enable_system_override(uint64_t flags);
	78	static void disable_system_override(uint64_t flags);
	79	static __attribute__((noinline)) void PROCESS_OVERRIDING_SYSTEM_DEFAULTS(uint64_t timeout);
	80
	81	/*************************** system_override ******************/
	82	/*
	83	* int system_override(uint64_t timeout, uint64_t flags);
	84	*/
	85
	86	void
	87	init_system_override()
	88	{
	89	sys_override_mtx_grp_attr = lck_grp_attr_alloc_init();
	90	sys_override_mtx_grp = lck_grp_alloc_init("system_override", sys_override_mtx_grp_attr);
	91	sys_override_mtx_attr = lck_attr_alloc_init();
	92	lck_mtx_init(&sys_override_lock, sys_override_mtx_grp, sys_override_mtx_attr);
	93	io_throttle_assert_cnt = cpu_throttle_assert_cnt = 0;
fe8ab488	94	sys_override_enabled = 1;
39236c6e A	95	}
	96
	97	/* system call implementation */
	98	int
	99	system_override(__unused struct proc p, struct system_override_args uap, __unused int32_t *retval)
	100	{
	101	uint64_t timeout = uap->timeout;
	102	uint64_t flags = uap->flags;
	103	int error = 0;
	104
	105	/* Check credentials for caller. Only entitled processes are allowed to make this call. */
	106	if ((error = priv_check_cred(kauth_cred_get(), PRIV_SYSTEM_OVERRIDE, 0))) {
	107	goto out;
	108	}
	109
fe8ab488 A	110	/* Check to see if some flags are specified. */
fe8ab488 A	111	if ((flags & ~SYS_OVERRIDE_FLAGS_MASK) != 0) {
39236c6e A	112	error = EINVAL;
	113	goto out;
	114	}
	115
fe8ab488 A	116	if (flags == SYS_OVERRIDE_DISABLE) {
	117
	118	printf("Process %s [%d] disabling system_override()\n", current_proc()->p_comm, current_proc()->p_pid);
	119
	120	lck_mtx_lock(&sys_override_lock);
	121
	122	if (io_throttle_assert_cnt > 0)
	123	sys_override_io_throttle(THROTTLE_IO_ENABLE);
	124	if (cpu_throttle_assert_cnt > 0)
	125	sys_override_cpu_throttle(CPU_THROTTLE_ENABLE);
	126
	127	sys_override_enabled = 0;
	128
	129	lck_mtx_unlock(&sys_override_lock);
	130
	131	goto out;
	132	}
	133
39236c6e A	134	lck_mtx_lock(&sys_override_lock);
	135
	136	enable_system_override(flags);
	137
	138	PROCESS_OVERRIDING_SYSTEM_DEFAULTS(timeout);
	139
	140	disable_system_override(flags);
	141
	142	lck_mtx_unlock(&sys_override_lock);
	143
	144	out:
	145	return error;
	146	}
	147
	148	/*
	149	* Call for enabling global system override.
	150	* This should be called only with the sys_override_lock held.
	151	*/
	152	static void
	153	enable_system_override(uint64_t flags)
	154	{
	155
	156	if (flags & SYS_OVERRIDE_IO_THROTTLE) {
fe8ab488	157	if ((io_throttle_assert_cnt == 0) && sys_override_enabled) {
39236c6e A	158	/* Disable I/O Throttling */
39236c6e A	159	printf("Process %s [%d] disabling system-wide I/O Throttling\n", current_proc()->p_comm, current_proc()->p_pid);
39236c6e A	160	sys_override_io_throttle(THROTTLE_IO_DISABLE);
39236c6e A	161	}
fe8ab488	162	KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) \| DBG_FUNC_START, current_proc()->p_pid, 0, 0, 0, 0);
39236c6e A	163	io_throttle_assert_cnt++;
	164	}
	165
	166	if (flags & SYS_OVERRIDE_CPU_THROTTLE) {
fe8ab488	167	if ((cpu_throttle_assert_cnt == 0) && sys_override_enabled) {
39236c6e A	168	/* Disable CPU Throttling */
39236c6e A	169	printf("Process %s [%d] disabling system-wide CPU Throttling\n", current_proc()->p_comm, current_proc()->p_pid);
39236c6e A	170	sys_override_cpu_throttle(CPU_THROTTLE_DISABLE);
39236c6e A	171	}
fe8ab488	172	KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) \| DBG_FUNC_START, current_proc()->p_pid, 0, 0, 0, 0);
39236c6e A	173	cpu_throttle_assert_cnt++;
	174	}
	175
	176	}
	177
	178	/*
	179	* Call for disabling global system override.
	180	* This should be called only with the sys_override_lock held.
	181	*/
	182	static void
	183	disable_system_override(uint64_t flags)
	184	{
	185
	186	if (flags & SYS_OVERRIDE_IO_THROTTLE) {
	187	assert(io_throttle_assert_cnt > 0);
	188	io_throttle_assert_cnt--;
fe8ab488 A	189	KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) \| DBG_FUNC_END, current_proc()->p_pid, 0, 0, 0, 0);
fe8ab488 A	190	if ((io_throttle_assert_cnt == 0) && sys_override_enabled) {
39236c6e	191	/* Enable I/O Throttling */
39236c6e A	192	sys_override_io_throttle(THROTTLE_IO_ENABLE);
	193	}
	194	}
	195
	196	if (flags & SYS_OVERRIDE_CPU_THROTTLE) {
	197	assert(cpu_throttle_assert_cnt > 0);
	198	cpu_throttle_assert_cnt--;
fe8ab488 A	199	KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) \| DBG_FUNC_END, current_proc()->p_pid, 0, 0, 0, 0);
fe8ab488 A	200	if ((cpu_throttle_assert_cnt == 0) && sys_override_enabled) {
39236c6e	201	/* Enable CPU Throttling */
39236c6e A	202	sys_override_cpu_throttle(CPU_THROTTLE_ENABLE);
	203	}
	204	}
	205	}
	206
	207	static __attribute__((noinline)) void
	208	PROCESS_OVERRIDING_SYSTEM_DEFAULTS(uint64_t timeout)
	209	{
	210	struct timespec ts;
	211	ts.tv_sec = timeout / NSEC_PER_SEC;
	212	ts.tv_nsec = timeout - ((long)ts.tv_sec * NSEC_PER_SEC);
	213	msleep((caddr_t)&sys_override_wait, &sys_override_lock, PRIBIO \| PCATCH, "system_override", &ts);
	214	}
	215