bsd/kern/kern_overrides.c

   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>
  47 #include <kern/locks.h>
  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
  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
  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;
  94         sys_override_enabled = 1;
  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
 110         /* Check to see if some flags are specified. */
 111         if ((flags & ~SYS_OVERRIDE_FLAGS_MASK) != 0) {
 112                 error = EINVAL;
 113                 goto out;
 114         }
 115
 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
 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) {
 157                 if ((io_throttle_assert_cnt == 0) && sys_override_enabled) {
 158                         /* Disable I/O Throttling */
 159                         printf("Process %s [%d] disabling system-wide I/O Throttling\n", current_proc()->p_comm, current_proc()->p_pid);
 160                         sys_override_io_throttle(THROTTLE_IO_DISABLE);
 161                 }
 162                 KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_START, current_proc()->p_pid, 0, 0, 0, 0);
 163                 io_throttle_assert_cnt++;
 164         }
 165
 166         if (flags & SYS_OVERRIDE_CPU_THROTTLE) {
 167                 if ((cpu_throttle_assert_cnt == 0) && sys_override_enabled) {
 168                         /* Disable CPU Throttling */
 169                         printf("Process %s [%d] disabling system-wide CPU Throttling\n", current_proc()->p_comm, current_proc()->p_pid);
 170                         sys_override_cpu_throttle(CPU_THROTTLE_DISABLE);
 171                 }
 172                 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_START, current_proc()->p_pid, 0, 0, 0, 0);
 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--;
 189                 KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_THROTTLE, IO_THROTTLE_DISABLE) | DBG_FUNC_END, current_proc()->p_pid, 0, 0, 0, 0);
 190                 if ((io_throttle_assert_cnt == 0) && sys_override_enabled) {
 191                         /* Enable I/O Throttling */
 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--;
 199                 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CPU_THROTTLE_DISABLE) | DBG_FUNC_END, current_proc()->p_pid, 0, 0, 0, 0);
 200                 if ((cpu_throttle_assert_cnt == 0) && sys_override_enabled) {
 201                         /* Enable CPU Throttling */
 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