X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d9a64523371fa019c4575bb400cbbc3a50ac9903..cb3231590a3c94ab4375e2228bd5e86b0cf1ad7e:/bsd/kern/kern_overrides.c diff --git a/bsd/kern/kern_overrides.c b/bsd/kern/kern_overrides.c index 0d7ece73d..04c70d47a 100644 --- a/bsd/kern/kern_overrides.c +++ b/bsd/kern/kern_overrides.c @@ -2,7 +2,7 @@ * 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 @@ -11,10 +11,10 @@ * 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, @@ -22,7 +22,7 @@ * 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@ */ @@ -51,44 +51,44 @@ #include /* Mutex for global system override state */ -static lck_mtx_t sys_override_lock; +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 (add new ones for each new mechanism) * * The assertion count management for system overrides is as follows: * * - All assertion counts are protected by the sys_override_lock. * - * - Each caller of system_override() increments the assertion count for the - * mechanism it specified in the flags. The caller then blocks for the - * timeout specified in the system call. + * - Each caller of system_override() increments the assertion count for the + * mechanism it specified in the flags. The caller then blocks for the + * timeout specified in the system call. * - * - At the end of the timeout, the caller thread wakes up and decrements the + * - At the end of the timeout, the caller thread wakes up and decrements the * assertion count for the mechanism it originally took an assertion on. * - * - If another caller calls the system_override() to disable the override - * for a mechanism, it simply disables the mechanism without changing any - * assertion counts. That way, the assertion counts are properly balanced. + * - If another caller calls the system_override() to disable the override + * for a mechanism, it simply disables the mechanism without changing any + * assertion counts. That way, the assertion counts are properly balanced. * - * One thing to note is that a SYS_OVERRIDE_DISABLE disables the overrides + * One thing to note is that a SYS_OVERRIDE_DISABLE disables the overrides * for a mechanism irrespective of how many clients requested that override. - * That makes the implementation simpler and avoids keeping a lot of process + * That makes the implementation simpler and avoids keeping a lot of process * specific state in the kernel. * */ -static int64_t io_throttle_assert_cnt; -static int64_t cpu_throttle_assert_cnt; -static int64_t fast_jetsam_assert_cnt; +static int64_t io_throttle_assert_cnt; +static int64_t cpu_throttle_assert_cnt; +static int64_t fast_jetsam_assert_cnt; /* Wait Channel for system override */ -static uint64_t sys_override_wait; +static uint64_t sys_override_wait; /* Global variable to indicate if system_override is enabled */ -int sys_override_enabled; +int sys_override_enabled; /* Helper routines */ static void system_override_begin(uint64_t flags); @@ -119,7 +119,7 @@ system_override(__unused struct proc *p, struct system_override_args * uap, __un /* 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 sane flags are specified. */ if ((flags & ~SYS_OVERRIDE_FLAGS_MASK) != 0) { @@ -152,20 +152,20 @@ out: /* * Helper routines for enabling/disabling system overrides for various mechanisms. - * These routines should be called with the sys_override_lock held. Each subsystem + * These routines should be called with the sys_override_lock held. Each subsystem * which is hooked into the override service provides two routines: - * + * * - void sys_override_foo_init(void); * Routine to initialize the subsystem or the data needed for the override to work. - * This routine is optional and if a subsystem needs it, it should be invoked from + * This routine is optional and if a subsystem needs it, it should be invoked from * init_system_override(). - * + * * - void sys_override_foo(boolean_t enable_override); - * Routine to enable/disable the override mechanism for that subsystem. A value of - * true indicates that the mechanism should be overridden and the special behavior - * should begin. A false value indicates that the subsystem should return to default - * behavior. This routine is mandatory and should be invoked as part of the helper - * routines if the flags passed in the syscall match the subsystem. Also, this + * Routine to enable/disable the override mechanism for that subsystem. A value of + * true indicates that the mechanism should be overridden and the special behavior + * should begin. A false value indicates that the subsystem should return to default + * behavior. This routine is mandatory and should be invoked as part of the helper + * routines if the flags passed in the syscall match the subsystem. Also, this * routine should preferably be idempotent. */ @@ -173,92 +173,90 @@ static void system_override_callouts(uint64_t flags, boolean_t enable_override) { switch (flags) { - case SYS_OVERRIDE_IO_THROTTLE: - if (enable_override) { - KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_START, - current_proc()->p_pid, 0, 0, 0, 0); - } else { - KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_END, - current_proc()->p_pid, 0, 0, 0, 0); - } - sys_override_io_throttle(enable_override); - break; - - case SYS_OVERRIDE_CPU_THROTTLE: - if (enable_override) { - KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_START, - current_proc()->p_pid, 0, 0, 0, 0); - } else { - KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_END, - current_proc()->p_pid, 0, 0, 0, 0); - } - sys_override_cpu_throttle(enable_override); - break; - - case SYS_OVERRIDE_FAST_JETSAM: - if (enable_override) { - KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_FAST_JETSAM) | DBG_FUNC_START, - current_proc()->p_pid, 0, 0, 0, 0); - } else { - KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_FAST_JETSAM) | DBG_FUNC_END, - current_proc()->p_pid, 0, 0, 0, 0); - } + case SYS_OVERRIDE_IO_THROTTLE: + if (enable_override) { + KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_START, + current_proc()->p_pid, 0, 0, 0, 0); + } else { + KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_END, + current_proc()->p_pid, 0, 0, 0, 0); + } + sys_override_io_throttle(enable_override); + break; + + case SYS_OVERRIDE_CPU_THROTTLE: + if (enable_override) { + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_START, + current_proc()->p_pid, 0, 0, 0, 0); + } else { + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_END, + current_proc()->p_pid, 0, 0, 0, 0); + } + sys_override_cpu_throttle(enable_override); + break; + + case SYS_OVERRIDE_FAST_JETSAM: + if (enable_override) { + KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_FAST_JETSAM) | DBG_FUNC_START, + current_proc()->p_pid, 0, 0, 0, 0); + } else { + KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_FAST_JETSAM) | DBG_FUNC_END, + current_proc()->p_pid, 0, 0, 0, 0); + } #if CONFIG_JETSAM - memorystatus_fast_jetsam_override(enable_override); + memorystatus_fast_jetsam_override(enable_override); #endif /* CONFIG_JETSAM */ - break; + break; - default: - panic("Unknown option to system_override_callouts(): %llu\n", flags); + default: + panic("Unknown option to system_override_callouts(): %llu\n", flags); } } /* * system_override_begin(uint64_t flags) * - * Routine to start a system override if the assertion count + * Routine to start a system override if the assertion count * transitions from 0->1 for a specified mechanism. */ static void system_override_begin(uint64_t flags) { lck_mtx_assert(&sys_override_lock, LCK_MTX_ASSERT_OWNED); - + if (flags & SYS_OVERRIDE_IO_THROTTLE) { if (io_throttle_assert_cnt == 0) { system_override_callouts(SYS_OVERRIDE_IO_THROTTLE, true); } io_throttle_assert_cnt++; } - + if (flags & SYS_OVERRIDE_CPU_THROTTLE) { if (cpu_throttle_assert_cnt == 0) { system_override_callouts(SYS_OVERRIDE_CPU_THROTTLE, true); } cpu_throttle_assert_cnt++; } - + if (flags & SYS_OVERRIDE_FAST_JETSAM) { if (fast_jetsam_assert_cnt == 0) { system_override_callouts(SYS_OVERRIDE_FAST_JETSAM, true); } fast_jetsam_assert_cnt++; } - } /* * system_override_end(uint64_t flags) * - * Routine to end a system override if the assertion count + * Routine to end a system override if the assertion count * transitions from 1->0 for a specified mechanism. */ static void system_override_end(uint64_t flags) { - lck_mtx_assert(&sys_override_lock, LCK_MTX_ASSERT_OWNED); - + if (flags & SYS_OVERRIDE_IO_THROTTLE) { assert(io_throttle_assert_cnt > 0); io_throttle_assert_cnt--; @@ -282,31 +280,29 @@ system_override_end(uint64_t flags) system_override_callouts(SYS_OVERRIDE_FAST_JETSAM, false); } } - } /* * system_override_abort(uint64_t flags) * - * Routine to abort a system override (if one was active) - * irrespective of the assertion counts and number of blocked + * Routine to abort a system override (if one was active) + * irrespective of the assertion counts and number of blocked * requestors. */ static void system_override_abort(uint64_t flags) { - lck_mtx_assert(&sys_override_lock, LCK_MTX_ASSERT_OWNED); - + if ((flags & SYS_OVERRIDE_IO_THROTTLE) && (io_throttle_assert_cnt > 0)) { system_override_callouts(SYS_OVERRIDE_IO_THROTTLE, false); } - if ((flags & SYS_OVERRIDE_CPU_THROTTLE) && (cpu_throttle_assert_cnt > 0)) { + if ((flags & SYS_OVERRIDE_CPU_THROTTLE) && (cpu_throttle_assert_cnt > 0)) { system_override_callouts(SYS_OVERRIDE_CPU_THROTTLE, false); } - if ((flags & SYS_OVERRIDE_FAST_JETSAM) && (fast_jetsam_assert_cnt > 0)) { + if ((flags & SYS_OVERRIDE_FAST_JETSAM) && (fast_jetsam_assert_cnt > 0)) { system_override_callouts(SYS_OVERRIDE_FAST_JETSAM, false); } } @@ -319,4 +315,3 @@ PROCESS_OVERRIDING_SYSTEM_DEFAULTS(uint64_t timeout) 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); } -