xnu-2782.30.5.tar.gz

[apple/xnu.git] / bsd / kern / kern_sysctl.c
diff --git a/bsd/kern/kern_sysctl.c b/bsd/kern/kern_sysctl.c

index 7303287c109272dfbb47ab896198fbe60360bd72..c7978d82e01270e2bf692e3fa9baf59fb9ccb55c 100644 (file)
--- a/bsd/kern/kern_sysctl.c
+++ b/bsd/kern/kern_sysctl.c
@@ -1,5 +1,5 @@
  /*
  /*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
   *
   * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   * 
   *
   * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   * 
@@ -107,11 +107,13 @@
  #include <kern/kalloc.h>
  
  #include <mach/machine.h>
  #include <kern/kalloc.h>
  
  #include <mach/machine.h>
+#include <mach/mach_host.h>
  #include <mach/mach_types.h>
  #include <mach/vm_param.h>
  #include <kern/mach_param.h>
  #include <kern/task.h>
  #include <mach/mach_types.h>
  #include <mach/vm_param.h>
  #include <kern/mach_param.h>
  #include <kern/task.h>
-#include <kern/lock.h>
+#include <kern/thread.h>
+#include <kern/processor.h>
  #include <kern/debug.h>
  #include <vm/vm_kern.h>
  #include <vm/vm_map.h>
  #include <kern/debug.h>
  #include <vm/vm_kern.h>
  #include <vm/vm_map.h>
@@ -119,7 +121,6 @@
  
  #include <sys/mount_internal.h>
  #include <sys/kdebug.h>
  
  #include <sys/mount_internal.h>
  #include <sys/kdebug.h>
-#include <sys/sysproto.h>
  
  #include <IOKit/IOPlatformExpert.h>
  #include <pexpert/pexpert.h>
  
  #include <IOKit/IOPlatformExpert.h>
  #include <pexpert/pexpert.h>
@@ -128,17 +129,32 @@
  #include <machine/exec.h>
  
  #include <vm/vm_protos.h>
  #include <machine/exec.h>
  
  #include <vm/vm_protos.h>
+#include <vm/vm_pageout.h>
+#include <sys/imgsrc.h>
+#include <kern/timer_call.h>
  
  #if defined(__i386__) || defined(__x86_64__)
  #include <i386/cpuid.h>
  #endif
  
  
  #if defined(__i386__) || defined(__x86_64__)
  #include <i386/cpuid.h>
  #endif
  
-sysctlfn kern_sysctl;
-#if DEBUG
-sysctlfn debug_sysctl;
+#if CONFIG_FREEZE
+#include <sys/kern_memorystatus.h>
+#endif
+
+#if KPERF
+#include <kperf/kperf.h>
  #endif
  #endif
-extern sysctlfn net_sysctl;
-extern sysctlfn cpu_sysctl;
+
+#if HYPERVISOR
+#include <kern/hv_support.h>
+#endif
+
+/*
+ * deliberately setting max requests to really high number
+ * so that runaway settings do not cause MALLOC overflows
+ */
+#define AIO_MAX_REQUESTS (128 * CONFIG_AIO_MAX)
+
  extern int aio_max_requests;                           
  extern int aio_max_requests_per_process;       
  extern int aio_worker_threads;                         
  extern int aio_max_requests;                           
  extern int aio_max_requests_per_process;       
  extern int aio_worker_threads;                         
@@ -146,25 +162,60 @@ extern int lowpri_IO_window_msecs;
  extern int lowpri_IO_delay_msecs;
  extern int nx_enabled;
  extern int speculative_reads_disabled;
  extern int lowpri_IO_delay_msecs;
  extern int nx_enabled;
  extern int speculative_reads_disabled;
-extern unsigned int preheat_pages_max;
-extern unsigned int preheat_pages_min;
-extern unsigned int preheat_pages_mult;
+extern int ignore_is_ssd;
+extern unsigned int speculative_prefetch_max;
+extern unsigned int speculative_prefetch_max_iosize;
+extern unsigned int preheat_max_bytes;
+extern unsigned int preheat_min_bytes;
  extern long numvnodes;
  
  extern long numvnodes;
  
-static void
-fill_user32_eproc(proc_t p, struct user32_eproc *ep);
-static void
-fill_user32_externproc(proc_t p, struct user32_extern_proc *exp);
-static void
-fill_user64_eproc(proc_t p, struct user64_eproc *ep);
-static void
-fill_user64_proc(proc_t p, struct user64_kinfo_proc *kp);
-static void
-fill_user64_externproc(proc_t p, struct user64_extern_proc *exp);
+extern uuid_string_t bootsessionuuid_string;
+
+extern unsigned int vm_max_delayed_work_limit;
+extern unsigned int vm_max_batch;
+
+extern unsigned int vm_page_free_min;
+extern unsigned int vm_page_free_target;
+extern unsigned int vm_page_free_reserved;
+extern unsigned int vm_page_speculative_percentage;
+extern unsigned int vm_page_speculative_q_age_ms;
+
+#if (DEVELOPMENT || DEBUG)
+extern uint32_t        vm_page_creation_throttled_hard;
+extern uint32_t        vm_page_creation_throttled_soft;
+#endif /* DEVELOPMENT || DEBUG */
+
+/*
+ * Conditionally allow dtrace to see these functions for debugging purposes.
+ */
+#ifdef STATIC
+#undef STATIC
+#endif
+#if 0
+#define STATIC
+#else
+#define STATIC static
+#endif
+
+extern boolean_t    mach_timer_coalescing_enabled;
+
+extern uint64_t timer_deadline_tracking_bin_1, timer_deadline_tracking_bin_2;
+
+STATIC void
+fill_user32_eproc(proc_t, struct user32_eproc *__restrict);
+STATIC void
+fill_user32_externproc(proc_t, struct user32_extern_proc *__restrict);
+STATIC void
+fill_user64_eproc(proc_t, struct user64_eproc *__restrict);
+STATIC void
+fill_user64_proc(proc_t, struct user64_kinfo_proc *__restrict);
+STATIC void
+fill_user64_externproc(proc_t, struct user64_extern_proc *__restrict);
+STATIC void
+fill_user32_proc(proc_t, struct user32_kinfo_proc *__restrict);
+
  extern int 
  kdbg_control(int *name, u_int namelen, user_addr_t where, size_t * sizep);
  extern int 
  kdbg_control(int *name, u_int namelen, user_addr_t where, size_t * sizep);
-int
-kdebug_ops(int *name, u_int namelen, user_addr_t where, size_t *sizep, proc_t p);
  #if NFSCLIENT
  extern int 
  netboot_root(void);
  #if NFSCLIENT
  extern int 
  netboot_root(void);
@@ -175,40 +226,80 @@ pcsamples_ops(int *name, u_int namelen, user_addr_t where, size_t *sizep,
  __private_extern__ kern_return_t
  reset_vmobjectcache(unsigned int val1, unsigned int val2);
  int
  __private_extern__ kern_return_t
  reset_vmobjectcache(unsigned int val1, unsigned int val2);
  int
-sysctl_doproc(int *name, u_int namelen, user_addr_t where, size_t *sizep);
-int 
-sysctl_doprof(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, 
-                         user_addr_t newp, size_t newlen);
-static void
-fill_user32_proc(proc_t p, struct user32_kinfo_proc *kp);
-int
  sysctl_procargs(int *name, u_int namelen, user_addr_t where, 
                                 size_t *sizep, proc_t cur_proc);
  sysctl_procargs(int *name, u_int namelen, user_addr_t where, 
                                 size_t *sizep, proc_t cur_proc);
-static int
-sysctl_procargs2(int *name, u_int namelen, user_addr_t where, size_t *sizep, 
-                 proc_t cur_proc);
-static int
+STATIC int
  sysctl_procargsx(int *name, u_int namelen, user_addr_t where, size_t *sizep, 
                   proc_t cur_proc, int argc_yes);
  int
  sysctl_struct(user_addr_t oldp, size_t *oldlenp, user_addr_t newp, 
                size_t newlen, void *sp, int len);
  
  sysctl_procargsx(int *name, u_int namelen, user_addr_t where, size_t *sizep, 
                   proc_t cur_proc, int argc_yes);
  int
  sysctl_struct(user_addr_t oldp, size_t *oldlenp, user_addr_t newp, 
                size_t newlen, void *sp, int len);
  
-static int sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg);
-static int sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg);
-static int sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg);
-static int  sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg);
-static int  sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg);
+STATIC int sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg);
+STATIC int sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg);
+STATIC int sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg);
+STATIC int  sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg);
+STATIC int  sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg);
  #if CONFIG_LCTX
  #if CONFIG_LCTX
-static int  sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg);
+STATIC int  sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg);
  #endif
  int sysdoproc_callback(proc_t p, void *arg);
  
  #endif
  int sysdoproc_callback(proc_t p, void *arg);
  
-static int __sysctl_funneled(proc_t p, struct __sysctl_args *uap, int32_t *retval);
+
+/* forward declarations for non-static STATIC */
+STATIC void fill_loadavg64(struct loadavg *la, struct user64_loadavg *la64);
+STATIC void fill_loadavg32(struct loadavg *la, struct user32_loadavg *la32);
+STATIC int sysctl_handle_kern_threadname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_sched_stats(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_sched_stats_enable(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_kdebug_ops SYSCTL_HANDLER_ARGS;
+#if COUNT_SYSCALLS
+STATIC int sysctl_docountsyscalls SYSCTL_HANDLER_ARGS;
+#endif /* COUNT_SYSCALLS */
+STATIC int sysctl_doprocargs SYSCTL_HANDLER_ARGS;
+STATIC int sysctl_doprocargs2 SYSCTL_HANDLER_ARGS;
+STATIC int sysctl_prochandle SYSCTL_HANDLER_ARGS;
+STATIC int sysctl_aiomax(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_aioprocmax(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_aiothreads(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_maxproc(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_osversion(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_sysctl_bootargs(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_maxvnodes(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_securelvl(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_domainname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_hostname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_procname(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_boottime(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_symfile(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+#if NFSCLIENT
+STATIC int sysctl_netboot(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+#endif
+#ifdef CONFIG_IMGSRC_ACCESS
+STATIC int sysctl_imgsrcdev(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+#endif
+STATIC int sysctl_usrstack(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_usrstack64(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_coredump(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_suid_coredump(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_delayterm(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_rage_vnode(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_kern_check_openevt(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_nx(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_loadavg(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_vm_toggle_address_reuse(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_swapusage(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int fetch_process_cputype( proc_t cur_proc, int *name, u_int namelen, cpu_type_t *cputype);
+STATIC int sysctl_sysctl_native(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_sysctl_cputype(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_safeboot(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_singleuser(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+STATIC int sysctl_slide(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
+
  
  extern void IORegistrySetOSBuildVersion(char * build_version); 
  
  
  extern void IORegistrySetOSBuildVersion(char * build_version); 
  
-static void
+STATIC void
  fill_loadavg64(struct loadavg *la, struct user64_loadavg *la64)
  {
         la64->ldavg[0]  = la->ldavg[0];
  fill_loadavg64(struct loadavg *la, struct user64_loadavg *la64)
  {
         la64->ldavg[0]  = la->ldavg[0];
@@ -217,7 +308,7 @@ fill_loadavg64(struct loadavg *la, struct user64_loadavg *la64)
         la64->fscale    = (user64_long_t)la->fscale;
  }
  
         la64->fscale    = (user64_long_t)la->fscale;
  }
  
-static void
+STATIC void
  fill_loadavg32(struct loadavg *la, struct user32_loadavg *la32)
  {
         la32->ldavg[0]  = la->ldavg[0];
  fill_loadavg32(struct loadavg *la, struct user32_loadavg *la32)
  {
         la32->ldavg[0]  = la->ldavg[0];
@@ -226,196 +317,15 @@ fill_loadavg32(struct loadavg *la, struct user32_loadavg *la32)
         la32->fscale    = (user32_long_t)la->fscale;
  }
  
         la32->fscale    = (user32_long_t)la->fscale;
  }
  
-/*
- * Locking and stats
- */
-static struct sysctl_lock memlock;
-
-/* sysctl() syscall */
-int
-__sysctl(proc_t p, struct __sysctl_args *uap, int32_t *retval)
-{
-       boolean_t funnel_state;
-       int error;
-
-       funnel_state = thread_funnel_set(kernel_flock, TRUE);
-       error = __sysctl_funneled(p, uap, retval);
-       thread_funnel_set(kernel_flock, funnel_state);
-       return(error);
-}
-
-static int
-__sysctl_funneled(proc_t p, struct __sysctl_args *uap, __unused int32_t *retval)
-{
-       int error, dolock = 1;
-       size_t savelen = 0, oldlen = 0, newlen;
-       sysctlfn *fnp = NULL;
-       int name[CTL_MAXNAME];
-       int error1;
-       boolean_t memlock_taken = FALSE;
-       boolean_t vslock_taken = FALSE;
-#if CONFIG_MACF
-       kauth_cred_t my_cred;
-#endif
-
-       /*
-        * all top-level sysctl names are non-terminal
-        */
-       if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
-               return (EINVAL);
-       error = copyin(uap->name, &name[0], uap->namelen * sizeof(int));
-       if (error)
-               return (error);
-               
-       AUDIT_ARG(ctlname, name, uap->namelen);
-
-       if (proc_is64bit(p)) {
-               /* uap->newlen is a size_t value which grows to 64 bits 
-                * when coming from a 64-bit process.  since it's doubtful we'll 
-                * have a sysctl newp buffer greater than 4GB we shrink it to size_t
-                */
-               newlen = CAST_DOWN(size_t, uap->newlen);
-       }
-       else {
-               newlen = uap->newlen;
-       }
-       
-       /* CTL_UNSPEC is used to get oid to AUTO_OID */
-       if (uap->new != USER_ADDR_NULL
-           && ((name[0] == CTL_KERN
-               && !(name[1] == KERN_IPC || name[1] == KERN_PANICINFO || name[1] == KERN_PROCDELAYTERM || 
-                    name[1] == KERN_PROCNAME || name[1] == KERN_RAGEVNODE || name[1] == KERN_CHECKOPENEVT || name[1] == KERN_THREADNAME))
-           || (name[0] == CTL_HW)
-           || (name[0] == CTL_VM))
-           && (error = suser(kauth_cred_get(), &p->p_acflag)))
-               return (error);
-
-/* XXX: KERN, VFS and DEBUG are handled by their respective functions,
- * but there is a fallback for all sysctls other than VFS to
- * userland_sysctl() - KILL THIS! */
-       switch (name[0]) {
-       case CTL_KERN:
-               fnp = kern_sysctl;
-               if ((name[1] != KERN_VNODE) && (name[1] != KERN_FILE) 
-                       && (name[1] != KERN_PROC))
-                       dolock = 0;
-               break;
-       case CTL_VFS:
-               fnp = vfs_sysctl;
-               break;
-#if DEBUG
-       case CTL_DEBUG:
-               fnp = debug_sysctl;
-               break;
-#endif
-       default:
-               fnp = NULL;
-       }
-
-       if (uap->oldlenp != USER_ADDR_NULL) {
-               uint64_t        oldlen64 = fuulong(uap->oldlenp);
-
-               oldlen = CAST_DOWN(size_t, oldlen64);
-               /*
-                * If more than 4G, clamp to 4G - useracc() below will catch
-                * with an EFAULT, if it's actually necessary.
-                */
-               if (oldlen64 > 0x00000000ffffffffULL)
-                       oldlen = 0xffffffffUL;
-       }
-
-       if (uap->old != USER_ADDR_NULL) {
-               if (!useracc(uap->old, (user_size_t)oldlen, B_WRITE))
-                       return (EFAULT);
-               /*
-                * The kernel debug mechanism does not need to take this lock, and
-                * we don't grab the memlock around calls to KERN_PROC because it is reentrant.
-                * Grabbing the lock for a KERN_PROC sysctl makes a deadlock possible 5024049.
-                */
-               if (!((name[1] == KERN_KDEBUG) && (name[2] == KERN_KDGETENTROPY)) &&
-                   !(name[1] == KERN_PROC)) {
-                       MEMLOCK_LOCK();
-                       memlock_taken = TRUE;
-                }
-
-               if (dolock && oldlen) {
-                       if ((error = vslock(uap->old, (user_size_t)oldlen))) {
-                               if (memlock_taken == TRUE)
-                                       MEMLOCK_UNLOCK();
-                               return(error);
-                       }
-                       savelen = oldlen;
-                       vslock_taken = TRUE;
-               }
-       }
-
-#if CONFIG_MACF
-       my_cred = kauth_cred_proc_ref(p);
-       error = mac_system_check_sysctl(
-           my_cred, 
-           (int *) name,
-           uap->namelen,
-           uap->old,
-           uap->oldlenp,
-           fnp == kern_sysctl ? 1 : 0,
-           uap->new,
-           newlen
-       );
-       kauth_cred_unref(&my_cred);
-       if (!error) {
-#endif
-       if (fnp) {
-               error = (*fnp)(name + 1, uap->namelen - 1, uap->old,
-                       &oldlen, uap->new, newlen, p);
-       }
-       else
-               error = ENOTSUP;
-#if CONFIG_MACF
-       }
-#endif
-
-       if (vslock_taken == TRUE) {
-               error1 = vsunlock(uap->old, (user_size_t)savelen, B_WRITE);
-               if (!error)
-                       error = error1;
-        }
-       if (memlock_taken == TRUE)
-               MEMLOCK_UNLOCK();
-
-       if ( (name[0] != CTL_VFS) && (error == ENOTSUP)) {
-               size_t  tmp = oldlen;
-               boolean_t funnel_state;
-
-               /*
-                * Drop the funnel when calling new sysctl code, which will conditionally
-                * grab the funnel if it really needs to.
-                */
-               funnel_state = thread_funnel_set(kernel_flock, FALSE);
-               
-               error = userland_sysctl(p, name, uap->namelen, uap->old, &tmp, 
-                                       uap->new, newlen, &oldlen);
-
-               thread_funnel_set(kernel_flock, funnel_state);
-       }
-
-       if ((error) && (error != ENOMEM))
-               return (error);
-
-       if (uap->oldlenp != USER_ADDR_NULL)
-               error = suulong(uap->oldlenp, oldlen);
-
-       return (error);
-}
-
  /*
   * Attributes stored in the kernel.
   */
  /*
   * Attributes stored in the kernel.
   */
-__private_extern__ char corefilename[MAXPATHLEN+1];
-__private_extern__ int do_coredump;
-__private_extern__ int sugid_coredump;
+extern char corefilename[MAXPATHLEN+1];
+extern int do_coredump;
+extern int sugid_coredump;
  
  #if COUNT_SYSCALLS
  
  #if COUNT_SYSCALLS
-__private_extern__ int do_count_syscalls;
+extern int do_count_syscalls;
  #endif
  
  #ifdef INSECURE
  #endif
  
  #ifdef INSECURE
@@ -424,183 +334,7 @@ int securelevel = -1;
  int securelevel;
  #endif
  
  int securelevel;
  #endif
  
-static int
-sysctl_affinity(
-       int *name,
-       u_int namelen,
-       user_addr_t oldBuf,
-       size_t *oldSize,
-       user_addr_t newBuf,
-       __unused size_t newSize,
-       proc_t cur_proc)
-{
-       if (namelen < 1)
-               return (ENOTSUP);
-
-       if (name[0] == 0 && 1 == namelen) {
-               return sysctl_rdint(oldBuf, oldSize, newBuf,
-                                       (cur_proc->p_flag & P_AFFINITY) ? 1 : 0);
-       } else if (name[0] == 1 && 2 == namelen) {
-               if (name[1] == 0) {
-                       OSBitAndAtomic(~((uint32_t)P_AFFINITY), &cur_proc->p_flag);
-               } else {
-                       OSBitOrAtomic(P_AFFINITY, &cur_proc->p_flag);
-               }
-               return 0;
-       }
-       return (ENOTSUP);
-}
-
-static int
-sysctl_translate(
-       int *name,
-       u_int namelen,
-       user_addr_t oldBuf,
-       size_t *oldSize,
-       user_addr_t newBuf,
-       __unused size_t newSize,
-       proc_t cur_proc)
-{
-       proc_t p;
-       int istranslated = 0;
-       kauth_cred_t my_cred;
-       uid_t uid;
-
-       if (namelen != 1)
-               return (ENOTSUP);
-
-       p = proc_find(name[0]);
-       if (p == NULL)
-               return (EINVAL);
-
-       my_cred = kauth_cred_proc_ref(p);
-       uid = kauth_cred_getuid(my_cred);
-       kauth_cred_unref(&my_cred);
-       if ((uid != kauth_cred_getuid(kauth_cred_get())) 
-               && suser(kauth_cred_get(), &cur_proc->p_acflag)) {
-               proc_rele(p);
-               return (EPERM);
-       }
-
-       istranslated = (p->p_flag & P_TRANSLATED);
-       proc_rele(p);
-       return sysctl_rdint(oldBuf, oldSize, newBuf,
-                               (istranslated != 0) ? 1 : 0);
-}
-
-int
-set_archhandler(__unused proc_t p, int arch)
-{
-       int error;
-       struct nameidata nd;
-       struct vnode_attr va;
-       vfs_context_t ctx = vfs_context_current();
-       struct exec_archhandler *archhandler;
-
-       switch(arch) {
-       case CPU_TYPE_POWERPC:
-               archhandler = &exec_archhandler_ppc;
-               break;
-       default:
-               return (EBADARCH);
-       }
-
-       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
-                  CAST_USER_ADDR_T(archhandler->path), ctx);
-       error = namei(&nd);
-       if (error)
-               return (error);
-       nameidone(&nd);
-       
-       /* Check mount point */
-       if ((nd.ni_vp->v_mount->mnt_flag & MNT_NOEXEC) ||
-               (nd.ni_vp->v_type != VREG)) {
-               vnode_put(nd.ni_vp);
-               return (EACCES);
-       }
-       
-       VATTR_INIT(&va);
-       VATTR_WANTED(&va, va_fsid);
-       VATTR_WANTED(&va, va_fileid);
-       error = vnode_getattr(nd.ni_vp, &va, ctx);
-       if (error) {
-               vnode_put(nd.ni_vp);
-               return (error);
-       }
-       vnode_put(nd.ni_vp);
-       
-       archhandler->fsid = va.va_fsid;
-       archhandler->fileid = (u_int32_t)va.va_fileid;
-       return 0;
-}
-
-/* XXX remove once Rosetta is rev'ed */
-/*****************************************************************************/
-static int
-sysctl_exec_archhandler_ppc(
-       __unused int *name,
-       __unused u_int namelen,
-       user_addr_t oldBuf,
-       size_t *oldSize,
-       user_addr_t newBuf,
-       size_t newSize,
-       proc_t p)
-{
-       int error;
-       size_t len;
-       char handler[sizeof(exec_archhandler_ppc.path)];
-       vfs_context_t ctx = vfs_context_current();
-
-       if (oldSize) {
-               len = strlen(exec_archhandler_ppc.path) + 1;
-               if (oldBuf) {
-                       if (*oldSize < len)
-                               return (ENOMEM);
-                       error = copyout(exec_archhandler_ppc.path, oldBuf, len);
-                       if (error)
-                               return (error);
-               }
-               *oldSize = len - 1;
-       }
-       if (newBuf) {
-               error = suser(vfs_context_ucred(ctx), &p->p_acflag);
-               if (error)
-                       return (error);
-               if (newSize >= sizeof(exec_archhandler_ppc.path))
-                       return (ENAMETOOLONG);
-               error = copyin(newBuf, handler, newSize);
-               if (error)
-                       return (error);
-               handler[newSize] = 0;
-               strlcpy(exec_archhandler_ppc.path, handler, MAXPATHLEN);
-               error = set_archhandler(p, CPU_TYPE_POWERPC);
-               if (error)
-                       return (error);
-       }
-       return 0;
-}
-/*****************************************************************************/
-
-static int
-sysctl_handle_exec_archhandler_ppc(struct sysctl_oid *oidp, void *arg1,
-               int arg2, struct sysctl_req *req)
-{
-       int error = 0;
-
-       error = sysctl_handle_string(oidp, arg1, arg2, req);
-
-       if (error)
-               goto done;
-
-       if (req->newptr)
-               error = set_archhandler(req->p, CPU_TYPE_POWERPC);
-
-done:
-       return error;
-
-}
-
-static int
+STATIC int
  sysctl_handle_kern_threadname( __unused struct sysctl_oid *oidp, __unused void *arg1,
               __unused int arg2, struct sysctl_req *req)
  {
  sysctl_handle_kern_threadname( __unused struct sysctl_oid *oidp, __unused void *arg1,
               __unused int arg2, struct sysctl_req *req)
  {
@@ -657,177 +391,143 @@ sysctl_handle_kern_threadname(  __unused struct sysctl_oid *oidp, __unused void *
         return 0;
  }
  
         return 0;
  }
  
-SYSCTL_PROC(_kern, KERN_THREADNAME, threadname, CTLFLAG_ANYBODY | CTLTYPE_STRING | CTLFLAG_RW, 0, 0, sysctl_handle_kern_threadname,"A","");
+SYSCTL_PROC(_kern, KERN_THREADNAME, threadname, CTLFLAG_ANYBODY | CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED, 0, 0, sysctl_handle_kern_threadname,"A","");
  
  
-SYSCTL_NODE(_kern, KERN_EXEC, exec, CTLFLAG_RD|CTLFLAG_LOCKED, 0, "");
+#define BSD_HOST 1
+STATIC int
+sysctl_sched_stats(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+       host_basic_info_data_t hinfo;
+       kern_return_t kret;
+       uint32_t size;
+       int changed;
+       mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
+       struct _processor_statistics_np *buf;
+       int error;
  
  
-SYSCTL_NODE(_kern_exec, OID_AUTO, archhandler, CTLFLAG_RD|CTLFLAG_LOCKED, 0, "");
+       kret = host_info((host_t)BSD_HOST, HOST_BASIC_INFO, (host_info_t)&hinfo, &count);
+       if (kret != KERN_SUCCESS) {
+               return EINVAL;
+       }
  
  
-SYSCTL_PROC(_kern_exec_archhandler, OID_AUTO, powerpc,
-           CTLTYPE_STRING | CTLFLAG_RW, exec_archhandler_ppc.path, 0,
-           sysctl_handle_exec_archhandler_ppc, "A", "");
+       size = sizeof(struct _processor_statistics_np) * (hinfo.logical_cpu_max + 2); /* One for RT Queue, One for Fair Share Queue */
+       
+       if (req->oldlen < size) {
+               return EINVAL;
+       }
+
+       MALLOC(buf, struct _processor_statistics_np*, size, M_TEMP, M_ZERO | M_WAITOK);
+       
+       kret = get_sched_statistics(buf, &size);
+       if (kret != KERN_SUCCESS) {
+               error = EINVAL;
+               goto out;
+       }
+
+       error = sysctl_io_opaque(req, buf, size, &changed);
+       if (error) {
+               goto out;
+       }
+
+       if (changed) {
+               panic("Sched info changed?!");
+       }
+out:
+       FREE(buf, M_TEMP);
+       return error;
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, sched_stats, CTLFLAG_LOCKED, 0, 0, sysctl_sched_stats, "-", "");
+
+STATIC int
+sysctl_sched_stats_enable(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, __unused struct sysctl_req *req)
+{
+       boolean_t active;
+       int res;
+
+       if (req->newlen != sizeof(active)) {
+               return EINVAL;
+       }
+
+       res = copyin(req->newptr, &active, sizeof(active));
+       if (res != 0) {
+               return res;
+       }
+
+       return set_sched_stats_active(active);
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, sched_stats_enable, CTLFLAG_LOCKED | CTLFLAG_WR, 0, 0, sysctl_sched_stats_enable, "-", "");
  
  extern int get_kernel_symfile(proc_t, char **);
  
  extern int get_kernel_symfile(proc_t, char **);
-__private_extern__ int 
-sysctl_dopanicinfo(int *, u_int, user_addr_t, size_t *, user_addr_t, 
-                   size_t, proc_t);
  
  
-/*
- * kernel related system variables.
- */
-int
-kern_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, 
-            user_addr_t newp, size_t newlen, proc_t p)
-{
-       /* all sysctl names not listed below are terminal at this level */
-       if (namelen != 1
-               && !(name[0] == KERN_PROC
-                       || name[0] == KERN_PROF 
-                       || name[0] == KERN_KDEBUG
-#if !CONFIG_EMBEDDED
-                       || name[0] == KERN_PROCARGS
-#endif
-                       || name[0] == KERN_PROCARGS2
-                       || name[0] == KERN_IPC
-                       || name[0] == KERN_SYSV
-                       || name[0] == KERN_AFFINITY
-                       || name[0] == KERN_TRANSLATE
-                       || name[0] == KERN_EXEC
-                       || name[0] == KERN_PANICINFO
-                       || name[0] == KERN_POSIX
-                       || name[0] == KERN_TFP
-                       || name[0] == KERN_TTY
-#if CONFIG_LCTX
-                       || name[0] == KERN_LCTX
-#endif
-                                               )
-               )
-               return (ENOTDIR);               /* overloaded */
-
-       switch (name[0]) {
-       case KERN_PROC:
-               return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp));
-#ifdef GPROF
-       case KERN_PROF:
-               return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp,
-                   newp, newlen));
-#endif
-       case KERN_KDEBUG:
-               return (kdebug_ops(name + 1, namelen - 1, oldp, oldlenp, p));
-#if !CONFIG_EMBEDDED
-       case KERN_PROCARGS:
-               /* new one as it does not use kinfo_proc */
-               return (sysctl_procargs(name + 1, namelen - 1, oldp, oldlenp, p));
-#endif
-       case KERN_PROCARGS2:
-               /* new one as it does not use kinfo_proc */
-               return (sysctl_procargs2(name + 1, namelen - 1, oldp, oldlenp, p));
-#if PANIC_INFO
-       case KERN_PANICINFO:
-               return(sysctl_dopanicinfo(name + 1, namelen - 1, oldp, oldlenp,
-                       newp, newlen, p));
-#endif
-       case KERN_AFFINITY:
-               return sysctl_affinity(name+1, namelen-1, oldp, oldlenp,
-                                                                       newp, newlen, p);
-       case KERN_TRANSLATE:
-               return sysctl_translate(name+1, namelen-1, oldp, oldlenp, newp,
-                                     newlen, p);
-
-               /* XXX remove once Rosetta has rev'ed */
-       case KERN_EXEC:
-               return sysctl_exec_archhandler_ppc(name+1, namelen-1, oldp,
-                                                  oldlenp, newp, newlen, p);
  #if COUNT_SYSCALLS
  #if COUNT_SYSCALLS
-       case KERN_COUNT_SYSCALLS:
-       {
-               /* valid values passed in:
-                * = 0 means don't keep called counts for each bsd syscall
-                * > 0 means keep called counts for each bsd syscall
-                * = 2 means dump current counts to the system log
-                * = 3 means reset all counts
-                * for example, to dump current counts:  
-                *              sysctl -w kern.count_calls=2
-                */
-               error = sysctl_int(oldp, oldlenp, newp, newlen, &tmp);
-               if ( error != 0 ) {
-                       return (error);
-               }
-                       
-               if ( tmp == 1 ) {
-                       do_count_syscalls = 1;
-               }
-               else if ( tmp == 0 || tmp == 2 || tmp == 3 ) {
-                       extern int                      nsysent;
-                       extern int                      syscalls_log[];
-                       extern const char *     syscallnames[];
-                       int                     i;
-                       for ( i = 0; i < nsysent; i++ ) {
-                               if ( syscalls_log[i] != 0 ) {
-                                       if ( tmp == 2 ) {
-                                               printf("%d calls - name %s \n", syscalls_log[i], syscallnames[i]);
-                                       }
-                                       else {
-                                               syscalls_log[i] = 0;
-                                       }
+#define KERN_COUNT_SYSCALLS (KERN_OSTYPE + 1000)
+
+extern int     nsysent;
+extern int syscalls_log[];
+extern const char *syscallnames[];
+
+STATIC int
+sysctl_docountsyscalls SYSCTL_HANDLER_ARGS
+{
+       __unused int cmd = oidp->oid_arg2;      /* subcommand*/
+       __unused int *name = arg1;      /* oid element argument vector */
+       __unused int namelen = arg2;    /* number of oid element arguments */
+       user_addr_t oldp = req->oldptr; /* user buffer copy out address */
+       size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
+       user_addr_t newp = req->newptr; /* user buffer copy in address */
+       size_t newlen = req->newlen;    /* user buffer copy in size */
+       int error;
+
+       int tmp;
+
+       /* valid values passed in:
+        * = 0 means don't keep called counts for each bsd syscall
+        * > 0 means keep called counts for each bsd syscall
+        * = 2 means dump current counts to the system log
+        * = 3 means reset all counts
+        * for example, to dump current counts:  
+        *              sysctl -w kern.count_calls=2
+        */
+       error = sysctl_int(oldp, oldlenp, newp, newlen, &tmp);
+       if ( error != 0 ) {
+               return (error);
+       }
+               
+       if ( tmp == 1 ) {
+               do_count_syscalls = 1;
+       }
+       else if ( tmp == 0 || tmp == 2 || tmp == 3 ) {
+               int                     i;
+               for ( i = 0; i < nsysent; i++ ) {
+                       if ( syscalls_log[i] != 0 ) {
+                               if ( tmp == 2 ) {
+                                       printf("%d calls - name %s \n", syscalls_log[i], syscallnames[i]);
+                               }
+                               else {
+                                       syscalls_log[i] = 0;
                                 }
                                 }
-                       }
-                       if ( tmp != 0 ) {
-                               do_count_syscalls = 1;
                         }
                 }
                         }
                 }
-               return (0);
-       }
-#endif
-       default:
-               return (ENOTSUP);
+               if ( tmp != 0 ) {
+                       do_count_syscalls = 1;
+               }
         }
         }
-       /* NOTREACHED */
-}
  
  
-#if DEBUG
-/*
- * Debugging related system variables.
- */
-#if DIAGNOSTIC
-extern
-#endif /* DIAGNOSTIC */
-struct ctldebug debug0, debug1;
-struct ctldebug debug2, debug3, debug4;
-struct ctldebug debug5, debug6, debug7, debug8, debug9;
-struct ctldebug debug10, debug11, debug12, debug13, debug14;
-struct ctldebug debug15, debug16, debug17, debug18, debug19;
-static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = {
-       &debug0, &debug1, &debug2, &debug3, &debug4,
-       &debug5, &debug6, &debug7, &debug8, &debug9,
-       &debug10, &debug11, &debug12, &debug13, &debug14,
-       &debug15, &debug16, &debug17, &debug18, &debug19,
-};
-int
-debug_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, 
-             user_addr_t newp, size_t newlen, __unused proc_t p)
-{
-       struct ctldebug *cdp;
-
-       /* all sysctl names at this level are name and field */
-       if (namelen != 2)
-               return (ENOTSUP);               /* overloaded */
-       if (name[0] < 0 || name[0] >= CTL_DEBUG_MAXID)
-               return (ENOTSUP);
-       cdp = debugvars[name[0]];
-       if (cdp->debugname == 0)
-               return (ENOTSUP);
-       switch (name[1]) {
-       case CTL_DEBUG_NAME:
-               return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
-       case CTL_DEBUG_VALUE:
-               return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
-       default:
-               return (ENOTSUP);
-       }
-       /* NOTREACHED */
+       /* adjust index so we return the right required/consumed amount */
+       if (!error)
+               req->oldidx += req->oldlen;
+
+       return (error);
  }
  }
-#endif /* DEBUG */
+SYSCTL_PROC(_kern, KERN_COUNT_SYSCALLS, count_syscalls, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       0,                      /* Integer argument (arg2) */
+       sysctl_docountsyscalls, /* Handler function */
+       NULL,                   /* Data pointer */
+       "");
+#endif /* COUNT_SYSCALLS */
  
  /*
   * The following sysctl_* functions should not be used
  
  /*
   * The following sysctl_* functions should not be used
@@ -865,26 +565,6 @@ sysctl_int(user_addr_t oldp, size_t *oldlenp,
         return (error);
  }
  
         return (error);
  }
  
-/*
- * As above, but read-only.
- */
-int
-sysctl_rdint(user_addr_t oldp, size_t *oldlenp, user_addr_t newp, int val)
-{
-       int error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       if (oldp && *oldlenp < sizeof(int))
-               return (ENOMEM);
-       if (newp)
-               return (EPERM);
-       *oldlenp = sizeof(int);
-       if (oldp)
-               error = copyout((caddr_t)&val, oldp, sizeof(int));
-       return (error);
-}
-
  /*
   * Validate parameters and get old / set new parameters
   * for an quad(64bit)-valued sysctl function.
  /*
   * Validate parameters and get old / set new parameters
   * for an quad(64bit)-valued sysctl function.
@@ -909,219 +589,7 @@ sysctl_quad(user_addr_t oldp, size_t *oldlenp,
         return (error);
  }
  
         return (error);
  }
  
-/*
- * As above, but read-only.
- */
-int
-sysctl_rdquad(user_addr_t oldp, size_t *oldlenp, user_addr_t newp, quad_t val)
-{
-       int error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       if (oldp && *oldlenp < sizeof(quad_t))
-               return (ENOMEM);
-       if (newp)
-               return (EPERM);
-       *oldlenp = sizeof(quad_t);
-       if (oldp)
-               error = copyout((caddr_t)&val, oldp, sizeof(quad_t));
-       return (error);
-}
-
-/*
- * Validate parameters and get old / set new parameters
- * for a string-valued sysctl function.  Unlike sysctl_string, if you
- * give it a too small (but larger than 0 bytes) buffer, instead of
- * returning ENOMEM, it truncates the returned string to the buffer
- * size.  This preserves the semantics of some library routines
- * implemented via sysctl, which truncate their returned data, rather
- * than simply returning an error. The returned string is always NUL
- * terminated.
- */
-int
-sysctl_trstring(user_addr_t oldp, size_t *oldlenp, 
-              user_addr_t newp, size_t newlen, char *str, int maxlen)
-{
-       int len, copylen, error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       copylen = len = strlen(str) + 1;
-       if (oldp && (len < 0 || *oldlenp < 1))
-               return (ENOMEM);
-       if (oldp && (*oldlenp < (size_t)len))
-               copylen = *oldlenp + 1;
-       if (newp && (maxlen < 0 || newlen >= (size_t)maxlen))
-               return (EINVAL);
-       *oldlenp = copylen - 1; /* deal with NULL strings correctly */
-       if (oldp) {
-               error = copyout(str, oldp, copylen);
-               if (!error) {
-                       unsigned char c = 0;
-                       /* NUL terminate */
-                       oldp += *oldlenp;
-                       error = copyout((void *)&c, oldp, sizeof(char));
-               }
-       }
-       if (error == 0 && newp) {
-               error = copyin(newp, str, newlen);
-               str[newlen] = 0;
-               AUDIT_ARG(text, (char *)str);
-       }
-       return (error);
-}
-
-/*
- * Validate parameters and get old / set new parameters
- * for a string-valued sysctl function.
- */
-int
-sysctl_string(user_addr_t oldp, size_t *oldlenp, 
-              user_addr_t newp, size_t newlen, char *str, int maxlen)
-{
-       int len, error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       len = strlen(str) + 1;
-       if (oldp && (len < 0 || *oldlenp < (size_t)len))
-               return (ENOMEM);
-       if (newp && (maxlen < 0 || newlen >= (size_t)maxlen))
-               return (EINVAL);
-       *oldlenp = len -1; /* deal with NULL strings correctly */
-       if (oldp) {
-               error = copyout(str, oldp, len);
-       }
-       if (error == 0 && newp) {
-               error = copyin(newp, str, newlen);
-               str[newlen] = 0;
-               AUDIT_ARG(text, (char *)str);
-       }
-       return (error);
-}
-
-/*
- * As above, but read-only.
- */
-int
-sysctl_rdstring(user_addr_t oldp, size_t *oldlenp, 
-                user_addr_t newp, char *str)
-{
-       int len, error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       len = strlen(str) + 1;
-       if (oldp && *oldlenp < (size_t)len)
-               return (ENOMEM);
-       if (newp)
-               return (EPERM);
-       *oldlenp = len;
-       if (oldp)
-               error = copyout(str, oldp, len);
-       return (error);
-}
-
-/*
- * Validate parameters and get old / set new parameters
- * for a structure oriented sysctl function.
- */
-int
-sysctl_struct(user_addr_t oldp, size_t *oldlenp, 
-              user_addr_t newp, size_t newlen, void *sp, int len)
-{
-       int error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       if (oldp && (len < 0 || *oldlenp < (size_t)len))
-               return (ENOMEM);
-       if (newp && (len < 0 || newlen > (size_t)len))
-               return (EINVAL);
-       if (oldp) {
-               *oldlenp = len;
-               error = copyout(sp, oldp, len);
-       }
-       if (error == 0 && newp)
-               error = copyin(newp, sp, len);
-       return (error);
-}
-
-/*
- * Validate parameters and get old parameters
- * for a structure oriented sysctl function.
- */
-int
-sysctl_rdstruct(user_addr_t oldp, size_t *oldlenp, 
-                user_addr_t newp, void *sp, int len)
-{
-       int error = 0;
-
-       if (oldp != USER_ADDR_NULL && oldlenp == NULL)
-               return (EFAULT);
-       if (oldp && (len < 0 || *oldlenp < (size_t)len))
-               return (ENOMEM);
-       if (newp)
-               return (EPERM);
-       *oldlenp = len;
-       if (oldp)
-               error = copyout(sp, oldp, len);
-       return (error);
-}
-
-/*
- * Get file structures.
- */
-static int
-sysctl_file
-(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
-{
-       int error;
-       struct fileglob *fg;
-       struct extern_file nef;
-
-       if (req->oldptr == USER_ADDR_NULL) {
-               /*
-                * overestimate by 10 files
-                */
-               req->oldidx = sizeof(filehead) + (nfiles + 10) * sizeof(struct extern_file);
-               return (0);
-       }
-
-       /*
-        * first copyout filehead
-        */
-       error = SYSCTL_OUT(req, &filehead, sizeof(filehead));
-       if (error)
-               return (error);
-
-       /*
-        * followed by an array of file structures
-        */
-       for (fg = filehead.lh_first; fg != 0; fg = fg->f_list.le_next) {
-        nef.f_list.le_next =  (struct extern_file *)fg->f_list.le_next;
-        nef.f_list.le_prev =  (struct extern_file **)fg->f_list.le_prev;
-               nef.f_flag = (fg->fg_flag & FMASK);
-               nef.f_type = fg->fg_type;
-               nef.f_count = fg->fg_count;
-               nef.f_msgcount = fg->fg_msgcount;
-               nef.f_cred = fg->fg_cred;
-               nef.f_ops = fg->fg_ops;
-               nef.f_offset = fg->fg_offset;
-               nef.f_data = fg->fg_data;
-               error = SYSCTL_OUT(req, &nef, sizeof(nef));
-               if (error)
-                       return (error);
-       }
-       return (0);
-}
-
-SYSCTL_PROC(_kern, KERN_FILE, file,
-               CTLTYPE_STRUCT | CTLFLAG_RW,
-               0, 0, sysctl_file, "S,filehead", "");
-
-static int
+STATIC int
  sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg)
  {
         if (p->p_pid != (pid_t)*(int*)arg)
  sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg)
  {
         if (p->p_pid != (pid_t)*(int*)arg)
@@ -1130,7 +598,7 @@ sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg)
                 return(1);
  }
  
                 return(1);
  }
  
-static int
+STATIC int
  sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg)
  {
         if (p->p_pgrpid != (pid_t)*(int*)arg)
  sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg)
  {
         if (p->p_pgrpid != (pid_t)*(int*)arg)
@@ -1139,15 +607,12 @@ sysdoproc_filt_KERN_PROC_PGRP(proc_t p, void * arg)
           return(1);
  }
  
           return(1);
  }
  
-static int
+STATIC int
  sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg)
  {
  sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg)
  {
-       boolean_t funnel_state;
         int retval;
         struct tty *tp;
  
         int retval;
         struct tty *tp;
  
-       
-       funnel_state = thread_funnel_set(kernel_flock, TRUE);
         /* This is very racy but list lock is held.. Hmmm. */
         if ((p->p_flag & P_CONTROLT) == 0 ||
                 (p->p_pgrp == NULL) || (p->p_pgrp->pg_session == NULL) ||
         /* This is very racy but list lock is held.. Hmmm. */
         if ((p->p_flag & P_CONTROLT) == 0 ||
                 (p->p_pgrp == NULL) || (p->p_pgrp->pg_session == NULL) ||
@@ -1157,12 +622,10 @@ sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg)
         else
                 retval = 1;
  
         else
                 retval = 1;
  
-       thread_funnel_set(kernel_flock, funnel_state);
-
         return(retval);
  }
  
         return(retval);
  }
  
-static int
+STATIC int
  sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg)
  {
         kauth_cred_t my_cred;
  sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg)
  {
         kauth_cred_t my_cred;
@@ -1181,7 +644,7 @@ sysdoproc_filt_KERN_PROC_UID(proc_t p, void * arg)
  }
  
  
  }
  
  
-static int
+STATIC int
  sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg)
  {
         kauth_cred_t my_cred;
  sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg)
  {
         kauth_cred_t my_cred;
@@ -1190,7 +653,7 @@ sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg)
         if (p->p_ucred == NULL)
                 return(0);
         my_cred = kauth_cred_proc_ref(p);
         if (p->p_ucred == NULL)
                 return(0);
         my_cred = kauth_cred_proc_ref(p);
-       ruid = my_cred->cr_ruid;
+       ruid = kauth_cred_getruid(my_cred);
         kauth_cred_unref(&my_cred);
  
         if (ruid != (uid_t)*(int*)arg)
         kauth_cred_unref(&my_cred);
  
         if (ruid != (uid_t)*(int*)arg)
@@ -1200,7 +663,7 @@ sysdoproc_filt_KERN_PROC_RUID(proc_t p, void * arg)
  }
  
  #if CONFIG_LCTX
  }
  
  #if CONFIG_LCTX
-static int
+STATIC int
  sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg)
  {
         if ((p->p_lctx == NULL) ||
  sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg)
  {
         if ((p->p_lctx == NULL) ||
@@ -1217,12 +680,12 @@ sysdoproc_filt_KERN_PROC_LCID(proc_t p, void * arg)
  #define KERN_PROCSLOP  (5 * sizeof (struct kinfo_proc))
  struct sysdoproc_args {
         int     buflen;
  #define KERN_PROCSLOP  (5 * sizeof (struct kinfo_proc))
  struct sysdoproc_args {
         int     buflen;
-       caddr_t kprocp;
+       void    *kprocp;
         boolean_t is_64_bit;
         user_addr_t     dp;
         size_t needed;
         int sizeof_kproc;
         boolean_t is_64_bit;
         user_addr_t     dp;
         size_t needed;
         int sizeof_kproc;
-       int * errorp;
+       int *errorp;
         int uidcheck;
         int ruidcheck;
         int ttycheck;
         int uidcheck;
         int ruidcheck;
         int ttycheck;
@@ -1230,71 +693,71 @@ struct sysdoproc_args {
  };
  
  int
  };
  
  int
-sysdoproc_callback(proc_t p, void * arg)
+sysdoproc_callback(proc_t p, void *arg)
  {
  {
-       struct sysdoproc_args * args = (struct sysdoproc_args *)arg;
-       int error=0;
+       struct sysdoproc_args *args = arg;
  
         if (args->buflen >= args->sizeof_kproc) {
  
         if (args->buflen >= args->sizeof_kproc) {
-               if ((args->ruidcheck != 0)  && (sysdoproc_filt_KERN_PROC_RUID(p, &args->uidval) == 0))
-                       return(PROC_RETURNED);
-               if ((args->uidcheck != 0)  && (sysdoproc_filt_KERN_PROC_UID(p, &args->uidval) == 0))
-                       return(PROC_RETURNED);
-               if ((args->ttycheck != 0)  && (sysdoproc_filt_KERN_PROC_TTY(p, &args->uidval) == 0))
-                       return(PROC_RETURNED);
+               if ((args->ruidcheck != 0) && (sysdoproc_filt_KERN_PROC_RUID(p, &args->uidval) == 0))
+                       return (PROC_RETURNED);
+               if ((args->uidcheck != 0) && (sysdoproc_filt_KERN_PROC_UID(p, &args->uidval) == 0))
+                       return (PROC_RETURNED);
+               if ((args->ttycheck != 0) && (sysdoproc_filt_KERN_PROC_TTY(p, &args->uidval) == 0))
+                       return (PROC_RETURNED);
  
                 bzero(args->kprocp, args->sizeof_kproc);
  
                 bzero(args->kprocp, args->sizeof_kproc);
-               if (args->is_64_bit) {
-                       fill_user64_proc(p, (struct user64_kinfo_proc *) args->kprocp);
-               }
-               else {
-                       fill_user32_proc(p, (struct user32_kinfo_proc *) args->kprocp);
-               }
-               error = copyout(args->kprocp, args->dp, args->sizeof_kproc);
+               if (args->is_64_bit)
+                       fill_user64_proc(p, args->kprocp);
+               else
+                       fill_user32_proc(p, args->kprocp);
+               int error = copyout(args->kprocp, args->dp, args->sizeof_kproc);
                 if (error) {
                         *args->errorp = error;
                 if (error) {
                         *args->errorp = error;
-                       return(PROC_RETURNED_DONE);
-                       return (error);
+                       return (PROC_RETURNED_DONE);
                 }
                 args->dp += args->sizeof_kproc;
                 args->buflen -= args->sizeof_kproc;
         }
         args->needed += args->sizeof_kproc;
                 }
                 args->dp += args->sizeof_kproc;
                 args->buflen -= args->sizeof_kproc;
         }
         args->needed += args->sizeof_kproc;
-       return(PROC_RETURNED);
+       return (PROC_RETURNED);
  }
  
  }
  
-int
-sysctl_doproc(int *name, u_int namelen, user_addr_t where, size_t *sizep)
+SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD | CTLFLAG_LOCKED, 0, "");
+STATIC int
+sysctl_prochandle SYSCTL_HANDLER_ARGS
  {
  {
+       int cmd = oidp->oid_arg2;       /* subcommand for multiple nodes */
+       int *name = arg1;               /* oid element argument vector */
+       int namelen = arg2;             /* number of oid element arguments */
+       user_addr_t where = req->oldptr;/* user buffer copy out address */
+
         user_addr_t dp = where;
         size_t needed = 0;
         user_addr_t dp = where;
         size_t needed = 0;
-       int buflen = where != USER_ADDR_NULL ? *sizep : 0;
+       int buflen = where != USER_ADDR_NULL ? req->oldlen : 0;
         int error = 0;
         int error = 0;
-       boolean_t is_64_bit = FALSE;
+       boolean_t is_64_bit = proc_is64bit(current_proc());
         struct user32_kinfo_proc  user32_kproc;
         struct user64_kinfo_proc  user_kproc;
         int sizeof_kproc;
         struct user32_kinfo_proc  user32_kproc;
         struct user64_kinfo_proc  user_kproc;
         int sizeof_kproc;
-       caddr_t kprocp;
+       void *kprocp;
         int (*filterfn)(proc_t, void *) = 0;
         struct sysdoproc_args args;
         int uidcheck = 0;
         int ruidcheck = 0;
         int ttycheck = 0;
  
         int (*filterfn)(proc_t, void *) = 0;
         struct sysdoproc_args args;
         int uidcheck = 0;
         int ruidcheck = 0;
         int ttycheck = 0;
  
-       if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
+       if (namelen != 1 && !(namelen == 0 && cmd == KERN_PROC_ALL))
                 return (EINVAL);
                 return (EINVAL);
-       is_64_bit = proc_is64bit(current_proc()); 
+
         if (is_64_bit) {
                 sizeof_kproc = sizeof(user_kproc);
         if (is_64_bit) {
                 sizeof_kproc = sizeof(user_kproc);
-               kprocp = (caddr_t) &user_kproc;
-       }
-       else {
+               kprocp = &user_kproc;
+       } else {
                 sizeof_kproc = sizeof(user32_kproc);
                 sizeof_kproc = sizeof(user32_kproc);
-               kprocp = (caddr_t) &user32_kproc;
+               kprocp = &user32_kproc;
         }
  
         }
  
-
-       switch (name[0]) {
+       switch (cmd) {
  
                 case KERN_PROC_PID:
                         filterfn = sysdoproc_filt_KERN_PROC_PID;
  
                 case KERN_PROC_PID:
                         filterfn = sysdoproc_filt_KERN_PROC_PID;
@@ -1321,6 +784,12 @@ sysctl_doproc(int *name, u_int namelen, user_addr_t where, size_t *sizep)
                         filterfn = sysdoproc_filt_KERN_PROC_LCID;
                         break;
  #endif
                         filterfn = sysdoproc_filt_KERN_PROC_LCID;
                         break;
  #endif
+               case KERN_PROC_ALL:
+                       break;
+
+               default:
+                       /* must be kern.proc.<unknown> */
+                       return (ENOTSUP);
         }
  
         error = 0;
         }
  
         error = 0;
@@ -1334,346 +803,354 @@ sysctl_doproc(int *name, u_int namelen, user_addr_t where, size_t *sizep)
         args.ruidcheck = ruidcheck;
         args.ttycheck = ttycheck;
         args.sizeof_kproc = sizeof_kproc;
         args.ruidcheck = ruidcheck;
         args.ttycheck = ttycheck;
         args.sizeof_kproc = sizeof_kproc;
-       args.uidval = name[1];
+       if (namelen)
+               args.uidval = name[0];
  
  
-       proc_iterate((PROC_ALLPROCLIST | PROC_ZOMBPROCLIST), sysdoproc_callback, &args, filterfn, &name[1]);
+       proc_iterate((PROC_ALLPROCLIST | PROC_ZOMBPROCLIST),
+           sysdoproc_callback, &args, filterfn, name);
  
         if (error)
  
         if (error)
-               return(error);
+               return (error);
  
         dp = args.dp;
         needed = args.needed;
         
         if (where != USER_ADDR_NULL) {
  
         dp = args.dp;
         needed = args.needed;
         
         if (where != USER_ADDR_NULL) {
-               *sizep = dp - where;
-               if (needed > *sizep)
+               req->oldlen = dp - where;
+               if (needed > req->oldlen)
                         return (ENOMEM);
         } else {
                 needed += KERN_PROCSLOP;
                         return (ENOMEM);
         } else {
                 needed += KERN_PROCSLOP;
-               *sizep = needed;
+               req->oldlen = needed;
         }
         }
+       /* adjust index so we return the right required/consumed amount */
+       req->oldidx += req->oldlen;
         return (0);
  }
  
  /*
         return (0);
  }
  
  /*
- * Fill in an eproc structure for the specified process.
+ * We specify the subcommand code for multiple nodes as the 'req->arg2' value
+ * in the sysctl declaration itself, which comes into the handler function
+ * as 'oidp->oid_arg2'.
+ *
+ * For these particular sysctls, since they have well known OIDs, we could
+ * have just obtained it from the '((int *)arg1)[0]' parameter, but that would
+ * not demonstrate how to handle multiple sysctls that used OID_AUTO instead
+ * of a well known value with a common handler function.  This is desirable,
+ * because we want well known values to "go away" at some future date.
+ *
+ * It should be noted that the value of '((int *)arg1)[1]' is used for many
+ * an integer parameter to the subcommand for many of these sysctls; we'd
+ * rather have used '((int *)arg1)[0]' for that, or even better, an element
+ * in a structure passed in as the the 'newp' argument to sysctlbyname(3),
+ * and then use leaf-node permissions enforcement, but that would have
+ * necessitated modifying user space code to correspond to the interface
+ * change, and we are striving for binary backward compatibility here; even
+ * though these are SPI, and not intended for use by user space applications
+ * which are not themselves system tools or libraries, some applications
+ * have erroneously used them.
   */
   */
-static void
-fill_user32_eproc(proc_t p, struct user32_eproc *ep)
+SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_ALL,          /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+SYSCTL_PROC(_kern_proc, KERN_PROC_PID, pid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_PID,          /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+SYSCTL_PROC(_kern_proc, KERN_PROC_TTY, tty, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_TTY,          /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+SYSCTL_PROC(_kern_proc, KERN_PROC_PGRP, pgrp, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_PGRP,         /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+SYSCTL_PROC(_kern_proc, KERN_PROC_UID, uid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_UID,          /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+SYSCTL_PROC(_kern_proc, KERN_PROC_RUID, ruid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_RUID,         /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+SYSCTL_PROC(_kern_proc, KERN_PROC_LCID, lcid, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       KERN_PROC_LCID,         /* Integer argument (arg2) */
+       sysctl_prochandle,      /* Handler function */
+       NULL,                   /* Data is size variant on ILP32/LP64 */
+       "");
+
+
+/*
+ * Fill in non-zero fields of an eproc structure for the specified process.
+ */
+STATIC void
+fill_user32_eproc(proc_t p, struct user32_eproc *__restrict ep)
  {
         struct tty *tp;
  {
         struct tty *tp;
+       struct pgrp *pg;
+       struct session *sessp;
         kauth_cred_t my_cred;
         kauth_cred_t my_cred;
-       struct pgrp * pg;
-       struct session * sessp;
  
         pg = proc_pgrp(p);
         sessp = proc_session(p);
  
  
         pg = proc_pgrp(p);
         sessp = proc_session(p);
  
-       ep->e_paddr = CAST_DOWN_EXPLICIT(uint32_t,p);
-
         if (pg != PGRP_NULL) {
         if (pg != PGRP_NULL) {
-               ep->e_sess = CAST_DOWN_EXPLICIT(uint32_t,sessp);
                 ep->e_pgid = p->p_pgrpid;
                 ep->e_jobc = pg->pg_jobc;
                 ep->e_pgid = p->p_pgrpid;
                 ep->e_jobc = pg->pg_jobc;
-               if ((sessp != SESSION_NULL) && sessp->s_ttyvp)
+               if (sessp != SESSION_NULL && sessp->s_ttyvp)
                         ep->e_flag = EPROC_CTTY;
                         ep->e_flag = EPROC_CTTY;
-       } else {
-               ep->e_sess = 0;
-               ep->e_pgid = 0;
-               ep->e_jobc = 0;
         }
  #if CONFIG_LCTX
         }
  #if CONFIG_LCTX
-       if (p->p_lctx) {
+       if (p->p_lctx)
                 ep->e_lcid = p->p_lctx->lc_id;
                 ep->e_lcid = p->p_lctx->lc_id;
-       } else {
-               ep->e_lcid = 0;
-       }
  #endif
         ep->e_ppid = p->p_ppid;
  #endif
         ep->e_ppid = p->p_ppid;
-       /* Pre-zero the fake historical pcred */
-       bzero(&ep->e_pcred, sizeof(ep->e_pcred));
         if (p->p_ucred) {
                 my_cred = kauth_cred_proc_ref(p);
  
                 /* A fake historical pcred */
         if (p->p_ucred) {
                 my_cred = kauth_cred_proc_ref(p);
  
                 /* A fake historical pcred */
-               ep->e_pcred.p_ruid = my_cred->cr_ruid;
-               ep->e_pcred.p_svuid = my_cred->cr_svuid;
-               ep->e_pcred.p_rgid = my_cred->cr_rgid;
-               ep->e_pcred.p_svgid = my_cred->cr_svgid;
+               ep->e_pcred.p_ruid = kauth_cred_getruid(my_cred);
+               ep->e_pcred.p_svuid = kauth_cred_getsvuid(my_cred);
+               ep->e_pcred.p_rgid = kauth_cred_getrgid(my_cred);
+               ep->e_pcred.p_svgid = kauth_cred_getsvgid(my_cred);
+
                 /* A fake historical *kauth_cred_t */
                 ep->e_ucred.cr_ref = my_cred->cr_ref;
                 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
                 /* A fake historical *kauth_cred_t */
                 ep->e_ucred.cr_ref = my_cred->cr_ref;
                 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
-               ep->e_ucred.cr_ngroups = my_cred->cr_ngroups;
-               bcopy(my_cred->cr_groups, ep->e_ucred.cr_groups, NGROUPS*sizeof(gid_t));
+               ep->e_ucred.cr_ngroups = posix_cred_get(my_cred)->cr_ngroups;
+               bcopy(posix_cred_get(my_cred)->cr_groups,
+                       ep->e_ucred.cr_groups, NGROUPS * sizeof (gid_t));
  
                 kauth_cred_unref(&my_cred);
         }
  
                 kauth_cred_unref(&my_cred);
         }
-       if (p->p_stat == SIDL || p->p_stat == SZOMB) {
-               ep->e_vm.vm_tsize = 0;
-               ep->e_vm.vm_dsize = 0;
-               ep->e_vm.vm_ssize = 0;
-       }
-       ep->e_vm.vm_rssize = 0;
  
         if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
              (tp = SESSION_TP(sessp))) {
                 ep->e_tdev = tp->t_dev;
                 ep->e_tpgid = sessp->s_ttypgrpid;
  
         if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
              (tp = SESSION_TP(sessp))) {
                 ep->e_tdev = tp->t_dev;
                 ep->e_tpgid = sessp->s_ttypgrpid;
-               ep->e_tsess = CAST_DOWN_EXPLICIT(uint32_t,tp->t_session);
         } else
                 ep->e_tdev = NODEV;
  
         } else
                 ep->e_tdev = NODEV;
  
-       if (SESS_LEADER(p, sessp))
-               ep->e_flag |= EPROC_SLEADER;
-       bzero(&ep->e_wmesg[0], WMESGLEN+1);
-       ep->e_xsize = ep->e_xrssize = 0;
-       ep->e_xccount = ep->e_xswrss = 0;
-       if (sessp != SESSION_NULL)
+       if (sessp != SESSION_NULL) {
+               if (SESS_LEADER(p, sessp))
+                       ep->e_flag |= EPROC_SLEADER;
                 session_rele(sessp);
                 session_rele(sessp);
-       if(pg != PGRP_NULL)
+       }
+       if (pg != PGRP_NULL)
                 pg_rele(pg);
  }
  
  /*
                 pg_rele(pg);
  }
  
  /*
- * Fill in an LP64 version of eproc structure for the specified process.
+ * Fill in non-zero fields of an LP64 eproc structure for the specified process.
   */
   */
-static void
-fill_user64_eproc(proc_t p, struct user64_eproc *ep)
+STATIC void
+fill_user64_eproc(proc_t p, struct user64_eproc *__restrict ep)
  {
         struct tty *tp;
  {
         struct tty *tp;
-       struct  session *sessp = NULL;
-       struct pgrp * pg;
+       struct pgrp *pg;
+       struct session *sessp;
         kauth_cred_t my_cred;
         
         pg = proc_pgrp(p);
         sessp = proc_session(p);
  
         kauth_cred_t my_cred;
         
         pg = proc_pgrp(p);
         sessp = proc_session(p);
  
-       ep->e_paddr = CAST_USER_ADDR_T(p);
         if (pg != PGRP_NULL) {
         if (pg != PGRP_NULL) {
-               ep->e_sess = CAST_USER_ADDR_T(sessp);
                 ep->e_pgid = p->p_pgrpid;
                 ep->e_jobc = pg->pg_jobc;
                 ep->e_pgid = p->p_pgrpid;
                 ep->e_jobc = pg->pg_jobc;
-               if (sessp != SESSION_NULL) {
-                       if (sessp->s_ttyvp)
-                           ep->e_flag = EPROC_CTTY;
-               }
-       } else {
-               ep->e_sess = USER_ADDR_NULL;
-               ep->e_pgid = 0;
-               ep->e_jobc = 0;
+               if (sessp != SESSION_NULL && sessp->s_ttyvp)
+                       ep->e_flag = EPROC_CTTY;
         }
  #if CONFIG_LCTX
         }
  #if CONFIG_LCTX
-       if (p->p_lctx) {
+       if (p->p_lctx)
                 ep->e_lcid = p->p_lctx->lc_id;
                 ep->e_lcid = p->p_lctx->lc_id;
-       } else {
-               ep->e_lcid = 0;
-       }
  #endif
         ep->e_ppid = p->p_ppid;
  #endif
         ep->e_ppid = p->p_ppid;
-       /* Pre-zero the fake historical pcred */
-       bzero(&ep->e_pcred, sizeof(ep->e_pcred));
         if (p->p_ucred) {
                 my_cred = kauth_cred_proc_ref(p);
  
                 /* A fake historical pcred */
         if (p->p_ucred) {
                 my_cred = kauth_cred_proc_ref(p);
  
                 /* A fake historical pcred */
-               ep->e_pcred.p_ruid = my_cred->cr_ruid;
-               ep->e_pcred.p_svuid = my_cred->cr_svuid;
-               ep->e_pcred.p_rgid = my_cred->cr_rgid;
-               ep->e_pcred.p_svgid = my_cred->cr_svgid;
+               ep->e_pcred.p_ruid = kauth_cred_getruid(my_cred);
+               ep->e_pcred.p_svuid = kauth_cred_getsvuid(my_cred);
+               ep->e_pcred.p_rgid = kauth_cred_getrgid(my_cred);
+               ep->e_pcred.p_svgid = kauth_cred_getsvgid(my_cred);
  
                 /* A fake historical *kauth_cred_t */
                 ep->e_ucred.cr_ref = my_cred->cr_ref;
                 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
  
                 /* A fake historical *kauth_cred_t */
                 ep->e_ucred.cr_ref = my_cred->cr_ref;
                 ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
-               ep->e_ucred.cr_ngroups = my_cred->cr_ngroups;
-               bcopy(my_cred->cr_groups, ep->e_ucred.cr_groups, NGROUPS*sizeof(gid_t));
+               ep->e_ucred.cr_ngroups = posix_cred_get(my_cred)->cr_ngroups;
+               bcopy(posix_cred_get(my_cred)->cr_groups,
+                       ep->e_ucred.cr_groups, NGROUPS * sizeof (gid_t));
  
                 kauth_cred_unref(&my_cred);
         }
  
                 kauth_cred_unref(&my_cred);
         }
-       if (p->p_stat == SIDL || p->p_stat == SZOMB) {
-               ep->e_vm.vm_tsize = 0;
-               ep->e_vm.vm_dsize = 0;
-               ep->e_vm.vm_ssize = 0;
-       }
-       ep->e_vm.vm_rssize = 0;
  
         if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
              (tp = SESSION_TP(sessp))) {
                 ep->e_tdev = tp->t_dev;
                 ep->e_tpgid = sessp->s_ttypgrpid;
  
         if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) &&
              (tp = SESSION_TP(sessp))) {
                 ep->e_tdev = tp->t_dev;
                 ep->e_tpgid = sessp->s_ttypgrpid;
-               ep->e_tsess = CAST_USER_ADDR_T(tp->t_session);
         } else
                 ep->e_tdev = NODEV;
  
         } else
                 ep->e_tdev = NODEV;
  
-       if (SESS_LEADER(p, sessp))
-               ep->e_flag |= EPROC_SLEADER;
-       bzero(&ep->e_wmesg[0], WMESGLEN+1);
-       ep->e_xsize = ep->e_xrssize = 0;
-       ep->e_xccount = ep->e_xswrss = 0;
-       if (sessp != SESSION_NULL)
+       if (sessp != SESSION_NULL) {
+               if (SESS_LEADER(p, sessp))
+                       ep->e_flag |= EPROC_SLEADER;
                 session_rele(sessp);
                 session_rele(sessp);
+       }
         if (pg != PGRP_NULL)
                 pg_rele(pg);
  }
  
  /*
   * Fill in an eproc structure for the specified process.
         if (pg != PGRP_NULL)
                 pg_rele(pg);
  }
  
  /*
   * Fill in an eproc structure for the specified process.
+ * bzeroed by our caller, so only set non-zero fields.
   */
   */
-static void
-fill_user32_externproc(proc_t p, struct user32_extern_proc *exp)
+STATIC void
+fill_user32_externproc(proc_t p, struct user32_extern_proc *__restrict exp)
  {
  {
-       exp->p_forw = exp->p_back = 0;
         exp->p_starttime.tv_sec = p->p_start.tv_sec;
         exp->p_starttime.tv_usec = p->p_start.tv_usec;
         exp->p_starttime.tv_sec = p->p_start.tv_sec;
         exp->p_starttime.tv_usec = p->p_start.tv_usec;
-       exp->p_vmspace = 0;
-       exp->p_sigacts = CAST_DOWN_EXPLICIT(uint32_t,p->p_sigacts);
-       exp->p_flag  = p->p_flag;
+       exp->p_flag = p->p_flag;
         if (p->p_lflag & P_LTRACED)
                 exp->p_flag |= P_TRACED;
         if (p->p_lflag & P_LPPWAIT)
                 exp->p_flag |= P_PPWAIT;
         if (p->p_lflag & P_LEXIT)
                 exp->p_flag |= P_WEXIT;
         if (p->p_lflag & P_LTRACED)
                 exp->p_flag |= P_TRACED;
         if (p->p_lflag & P_LPPWAIT)
                 exp->p_flag |= P_PPWAIT;
         if (p->p_lflag & P_LEXIT)
                 exp->p_flag |= P_WEXIT;
-       exp->p_stat  = p->p_stat ;
-       exp->p_pid  = p->p_pid ;
-       exp->p_oppid  = p->p_oppid ;
+       exp->p_stat = p->p_stat;
+       exp->p_pid = p->p_pid;
+       exp->p_oppid = p->p_oppid;
         /* Mach related  */
         /* Mach related  */
-       exp->user_stack  = p->user_stack;
-       exp->exit_thread  = CAST_DOWN_EXPLICIT(uint32_t,p->exit_thread);
-       exp->p_debugger  = p->p_debugger ;
-       exp->sigwait  = p->sigwait ;
+       exp->user_stack = p->user_stack;
+       exp->p_debugger = p->p_debugger;
+       exp->sigwait = p->sigwait;
         /* scheduling */
  #ifdef _PROC_HAS_SCHEDINFO_
         /* scheduling */
  #ifdef _PROC_HAS_SCHEDINFO_
-       exp->p_estcpu  = p->p_estcpu ;
-       exp->p_pctcpu  = p->p_pctcpu ;
-       exp->p_slptime  = p->p_slptime ;
-#else
-       exp->p_estcpu  = 0 ;
-       exp->p_pctcpu  = 0 ;
-       exp->p_slptime = 0 ;
+       exp->p_estcpu = p->p_estcpu;
+       exp->p_pctcpu = p->p_pctcpu;
+       exp->p_slptime = p->p_slptime;
  #endif
  #endif
-       exp->p_cpticks  = 0 ;
-       exp->p_wchan  = 0 ;
-       exp->p_wmesg  = 0 ;
-       exp->p_swtime  = 0 ;
-       bcopy(&p->p_realtimer, &exp->p_realtimer,sizeof(struct itimerval));
-       bcopy(&p->p_rtime, &exp->p_rtime,sizeof(struct timeval));
-       exp->p_uticks  = 0 ;
-       exp->p_sticks  = 0 ;
-       exp->p_iticks  = 0 ;
-       exp->p_traceflag  = 0;
-       exp->p_tracep  = 0 ;
-       exp->p_siglist  = 0 ;   /* No longer relevant */
-       exp->p_textvp  = CAST_DOWN_EXPLICIT(uint32_t,p->p_textvp) ;
-       exp->p_holdcnt = 0 ;
-       exp->p_sigmask  = 0 ;   /* no longer avaialable */
-       exp->p_sigignore  = p->p_sigignore ;
-       exp->p_sigcatch  = p->p_sigcatch ;
-       exp->p_priority  = p->p_priority ;
-       exp->p_usrpri  = 0 ;
-       exp->p_nice  = p->p_nice ;
-       bcopy(&p->p_comm, &exp->p_comm,MAXCOMLEN);
-       exp->p_comm[MAXCOMLEN] = '\0';
-       exp->p_pgrp  = CAST_DOWN_EXPLICIT(uint32_t,p->p_pgrp) ;
-       exp->p_addr  = 0;
-       exp->p_xstat  = p->p_xstat ;
-       exp->p_acflag  = p->p_acflag ;
-       exp->p_ru  = CAST_DOWN_EXPLICIT(uint32_t,p->p_ru) ;             /* XXX may be NULL */
+       exp->p_realtimer.it_interval.tv_sec =
+               (user32_time_t)p->p_realtimer.it_interval.tv_sec;
+       exp->p_realtimer.it_interval.tv_usec =
+               (__int32_t)p->p_realtimer.it_interval.tv_usec;
+
+       exp->p_realtimer.it_value.tv_sec =
+               (user32_time_t)p->p_realtimer.it_value.tv_sec;
+       exp->p_realtimer.it_value.tv_usec =
+               (__int32_t)p->p_realtimer.it_value.tv_usec;
+
+       exp->p_rtime.tv_sec = (user32_time_t)p->p_rtime.tv_sec;
+       exp->p_rtime.tv_usec = (__int32_t)p->p_rtime.tv_usec;
+
+       exp->p_sigignore = p->p_sigignore;
+       exp->p_sigcatch = p->p_sigcatch;
+       exp->p_priority = p->p_priority;
+       exp->p_nice = p->p_nice;
+       bcopy(&p->p_comm, &exp->p_comm, MAXCOMLEN);
+       exp->p_xstat = p->p_xstat;
+       exp->p_acflag = p->p_acflag;
  }
  
  /*
   * Fill in an LP64 version of extern_proc structure for the specified process.
   */
  }
  
  /*
   * Fill in an LP64 version of extern_proc structure for the specified process.
   */
-static void
-fill_user64_externproc(proc_t p, struct user64_extern_proc *exp)
+STATIC void
+fill_user64_externproc(proc_t p, struct user64_extern_proc *__restrict exp)
  {
  {
-       exp->p_forw = exp->p_back = USER_ADDR_NULL;
         exp->p_starttime.tv_sec = p->p_start.tv_sec;
         exp->p_starttime.tv_usec = p->p_start.tv_usec;
         exp->p_starttime.tv_sec = p->p_start.tv_sec;
         exp->p_starttime.tv_usec = p->p_start.tv_usec;
-       exp->p_vmspace = USER_ADDR_NULL;
-       exp->p_sigacts = CAST_USER_ADDR_T(p->p_sigacts);
-       exp->p_flag  = p->p_flag;
+       exp->p_flag = p->p_flag;
         if (p->p_lflag & P_LTRACED)
                 exp->p_flag |= P_TRACED;
         if (p->p_lflag & P_LPPWAIT)
                 exp->p_flag |= P_PPWAIT;
         if (p->p_lflag & P_LEXIT)
                 exp->p_flag |= P_WEXIT;
         if (p->p_lflag & P_LTRACED)
                 exp->p_flag |= P_TRACED;
         if (p->p_lflag & P_LPPWAIT)
                 exp->p_flag |= P_PPWAIT;
         if (p->p_lflag & P_LEXIT)
                 exp->p_flag |= P_WEXIT;
-       exp->p_stat  = p->p_stat ;
-       exp->p_pid  = p->p_pid ;
-       exp->p_oppid  = p->p_oppid ;
+       exp->p_stat = p->p_stat;
+       exp->p_pid = p->p_pid;
+       exp->p_oppid = p->p_oppid;
         /* Mach related  */
         /* Mach related  */
-       exp->user_stack  = p->user_stack;
-       exp->exit_thread  = CAST_USER_ADDR_T(p->exit_thread);
-       exp->p_debugger  = p->p_debugger ;
-       exp->sigwait  = p->sigwait ;
+       exp->user_stack = p->user_stack;
+       exp->p_debugger = p->p_debugger;
+       exp->sigwait = p->sigwait;
         /* scheduling */
  #ifdef _PROC_HAS_SCHEDINFO_
         /* scheduling */
  #ifdef _PROC_HAS_SCHEDINFO_
-       exp->p_estcpu  = p->p_estcpu ;
-       exp->p_pctcpu  = p->p_pctcpu ;
-       exp->p_slptime  = p->p_slptime ;
-#else
-       exp->p_estcpu  = 0 ;
-       exp->p_pctcpu  = 0 ;
-       exp->p_slptime = 0 ;
+       exp->p_estcpu = p->p_estcpu;
+       exp->p_pctcpu = p->p_pctcpu;
+       exp->p_slptime = p->p_slptime;
  #endif
  #endif
-       exp->p_cpticks  = 0 ;
-       exp->p_wchan  = 0;
-       exp->p_wmesg  = 0;
-       exp->p_swtime  = 0 ;
         exp->p_realtimer.it_interval.tv_sec = p->p_realtimer.it_interval.tv_sec;
         exp->p_realtimer.it_interval.tv_usec = p->p_realtimer.it_interval.tv_usec;
         exp->p_realtimer.it_interval.tv_sec = p->p_realtimer.it_interval.tv_sec;
         exp->p_realtimer.it_interval.tv_usec = p->p_realtimer.it_interval.tv_usec;
+
         exp->p_realtimer.it_value.tv_sec = p->p_realtimer.it_value.tv_sec;
         exp->p_realtimer.it_value.tv_usec = p->p_realtimer.it_value.tv_usec;
         exp->p_realtimer.it_value.tv_sec = p->p_realtimer.it_value.tv_sec;
         exp->p_realtimer.it_value.tv_usec = p->p_realtimer.it_value.tv_usec;
+
         exp->p_rtime.tv_sec = p->p_rtime.tv_sec;
         exp->p_rtime.tv_usec = p->p_rtime.tv_usec;
         exp->p_rtime.tv_sec = p->p_rtime.tv_sec;
         exp->p_rtime.tv_usec = p->p_rtime.tv_usec;
-       exp->p_uticks  = 0 ;
-       exp->p_sticks  = 0 ;
-       exp->p_iticks  = 0 ;
-       exp->p_traceflag  = 0 ;
-       exp->p_tracep  = 0;
-       exp->p_siglist  = 0 ;   /* No longer relevant */
-       exp->p_textvp  = CAST_USER_ADDR_T(p->p_textvp);
-       exp->p_holdcnt = 0 ;
-       exp->p_sigmask  = 0 ;   /* no longer avaialable */
-       exp->p_sigignore  = p->p_sigignore ;
-       exp->p_sigcatch  = p->p_sigcatch ;
-       exp->p_priority  = p->p_priority ;
-       exp->p_usrpri  = 0 ;
-       exp->p_nice  = p->p_nice ;
-       bcopy(&p->p_comm, &exp->p_comm,MAXCOMLEN);
-       exp->p_comm[MAXCOMLEN] = '\0';
-       exp->p_pgrp  = CAST_USER_ADDR_T(p->p_pgrp);
-       exp->p_addr  = USER_ADDR_NULL;
-       exp->p_xstat  = p->p_xstat ;
-       exp->p_acflag  = p->p_acflag ;
-       exp->p_ru  = CAST_USER_ADDR_T(p->p_ru);         /* XXX may be NULL */
-}
-
-static void
-fill_user32_proc(proc_t p, struct user32_kinfo_proc *kp)
-{
-       /* on a 64 bit kernel, 32 bit users will get some truncated information */
+
+       exp->p_sigignore = p->p_sigignore;
+       exp->p_sigcatch = p->p_sigcatch;
+       exp->p_priority = p->p_priority;
+       exp->p_nice = p->p_nice;
+       bcopy(&p->p_comm, &exp->p_comm, MAXCOMLEN);
+       exp->p_xstat = p->p_xstat;
+       exp->p_acflag = p->p_acflag;
+}
+
+STATIC void
+fill_user32_proc(proc_t p, struct user32_kinfo_proc *__restrict kp)
+{
+       /* on a 64 bit kernel, 32 bit users get some truncated information */
         fill_user32_externproc(p, &kp->kp_proc);
         fill_user32_eproc(p, &kp->kp_eproc);
  }
  
         fill_user32_externproc(p, &kp->kp_proc);
         fill_user32_eproc(p, &kp->kp_eproc);
  }
  
-static void
-fill_user64_proc(proc_t p, struct user64_kinfo_proc *kp)
+STATIC void
+fill_user64_proc(proc_t p, struct user64_kinfo_proc *__restrict kp)
  {
         fill_user64_externproc(p, &kp->kp_proc);
         fill_user64_eproc(p, &kp->kp_eproc);
  }
  
  {
         fill_user64_externproc(p, &kp->kp_proc);
         fill_user64_eproc(p, &kp->kp_eproc);
  }
  
-int
-kdebug_ops(int *name, u_int namelen, user_addr_t where, 
-           size_t *sizep, proc_t p)
+STATIC int
+sysctl_kdebug_ops SYSCTL_HANDLER_ARGS
  {
  {
+       __unused int cmd = oidp->oid_arg2;      /* subcommand*/
+       int *name = arg1;               /* oid element argument vector */
+       int namelen = arg2;             /* number of oid element arguments */
+       user_addr_t oldp = req->oldptr; /* user buffer copy out address */
+       size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
+//     user_addr_t newp = req->newptr; /* user buffer copy in address */
+//     size_t newlen = req->newlen;    /* user buffer copy in size */
+
+       proc_t p = current_proc();
         int ret=0;
  
         if (namelen == 0)
                 return(ENOTSUP);
         
         int ret=0;
  
         if (namelen == 0)
                 return(ENOTSUP);
         
-    ret = suser(kauth_cred_get(), &p->p_acflag);
+       ret = suser(kauth_cred_get(), &p->p_acflag);
+#if KPERF
+       /* Non-root processes may be blessed by kperf to access data
+        * logged into trace.
+        */
+       if (ret)
+               ret = kperf_access_check();
+#endif /* KPERF */
         if (ret)
                 return(ret);
         
         if (ret)
                 return(ret);
         
@@ -1687,41 +1164,101 @@ kdebug_ops(int *name, u_int namelen, user_addr_t where,
         case KERN_KDSETREG:
         case KERN_KDGETREG:
         case KERN_KDREADTR:
         case KERN_KDSETREG:
         case KERN_KDGETREG:
         case KERN_KDREADTR:
+        case KERN_KDWRITETR:
+        case KERN_KDWRITEMAP:
         case KERN_KDPIDTR:
         case KERN_KDTHRMAP:
         case KERN_KDPIDEX:
         case KERN_KDSETRTCDEC:
         case KERN_KDSETBUF:
         case KERN_KDGETENTROPY:
         case KERN_KDPIDTR:
         case KERN_KDTHRMAP:
         case KERN_KDPIDEX:
         case KERN_KDSETRTCDEC:
         case KERN_KDSETBUF:
         case KERN_KDGETENTROPY:
-               ret = kdbg_control(name, namelen, where, sizep);
+       case KERN_KDENABLE_BG_TRACE:
+       case KERN_KDDISABLE_BG_TRACE:
+       case KERN_KDREADCURTHRMAP:
+       case KERN_KDSET_TYPEFILTER:
+        case KERN_KDBUFWAIT:
+       case KERN_KDCPUMAP:
+
+               ret = kdbg_control(name, namelen, oldp, oldlenp);
                 break;
         default:
                 ret= ENOTSUP;
                 break;
         }
                 break;
         default:
                 ret= ENOTSUP;
                 break;
         }
-       return(ret);
+
+       /* adjust index so we return the right required/consumed amount */
+       if (!ret)
+               req->oldidx += req->oldlen;
+
+       return (ret);
  }
  }
+SYSCTL_PROC(_kern, KERN_KDEBUG, kdebug, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       0,                      /* Integer argument (arg2) */
+       sysctl_kdebug_ops,      /* Handler function */
+       NULL,                   /* Data pointer */
+       "");
  
  
  /*
   * Return the top *sizep bytes of the user stack, or the entire area of the
   * user stack down through the saved exec_path, whichever is smaller.
   */
  
  
  /*
   * Return the top *sizep bytes of the user stack, or the entire area of the
   * user stack down through the saved exec_path, whichever is smaller.
   */
-int
-sysctl_procargs(int *name, u_int namelen, user_addr_t where, 
-                size_t *sizep, proc_t cur_proc)
-{
-       return sysctl_procargsx( name, namelen, where, sizep, cur_proc, 0);
+STATIC int
+sysctl_doprocargs SYSCTL_HANDLER_ARGS
+{
+       __unused int cmd = oidp->oid_arg2;      /* subcommand*/
+       int *name = arg1;               /* oid element argument vector */
+       int namelen = arg2;             /* number of oid element arguments */
+       user_addr_t oldp = req->oldptr; /* user buffer copy out address */
+       size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
+//     user_addr_t newp = req->newptr; /* user buffer copy in address */
+//     size_t newlen = req->newlen;    /* user buffer copy in size */
+       int error;
+
+       error =  sysctl_procargsx( name, namelen, oldp, oldlenp, current_proc(), 0);
+
+       /* adjust index so we return the right required/consumed amount */
+       if (!error)
+               req->oldidx += req->oldlen;
+
+       return (error);
  }
  }
+SYSCTL_PROC(_kern, KERN_PROCARGS, procargs, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       0,                      /* Integer argument (arg2) */
+       sysctl_doprocargs,      /* Handler function */
+       NULL,                   /* Data pointer */
+       "");
+
+STATIC int
+sysctl_doprocargs2 SYSCTL_HANDLER_ARGS
+{
+       __unused int cmd = oidp->oid_arg2;      /* subcommand*/
+       int *name = arg1;               /* oid element argument vector */
+       int namelen = arg2;             /* number of oid element arguments */
+       user_addr_t oldp = req->oldptr; /* user buffer copy out address */
+       size_t *oldlenp = &req->oldlen; /* user buffer copy out size */
+//     user_addr_t newp = req->newptr; /* user buffer copy in address */
+//     size_t newlen = req->newlen;    /* user buffer copy in size */
+       int error;
  
  
-static int
-sysctl_procargs2(int *name, u_int namelen, user_addr_t where, 
-                 size_t *sizep, proc_t cur_proc)
-{
-       return sysctl_procargsx( name, namelen, where, sizep, cur_proc, 1);
+       error = sysctl_procargsx( name, namelen, oldp, oldlenp, current_proc(), 1);
+
+       /* adjust index so we return the right required/consumed amount */
+       if (!error)
+               req->oldidx += req->oldlen;
+
+       return (error);
  }
  }
+SYSCTL_PROC(_kern, KERN_PROCARGS2, procargs2, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
+       0,                      /* Pointer argument (arg1) */
+       0,                      /* Integer argument (arg2) */
+       sysctl_doprocargs2,     /* Handler function */
+       NULL,                   /* Data pointer */
+       "");
  
  
-static int
+STATIC int
  sysctl_procargsx(int *name, u_int namelen, user_addr_t where, 
                   size_t *sizep, proc_t cur_proc, int argc_yes)
  {
  sysctl_procargsx(int *name, u_int namelen, user_addr_t where, 
                   size_t *sizep, proc_t cur_proc, int argc_yes)
  {
@@ -1977,7 +1514,7 @@ sysctl_procargsx(int *name, u_int namelen, user_addr_t where,
  /*
   * Max number of concurrent aio requests
   */
  /*
   * Max number of concurrent aio requests
   */
-static int
+STATIC int
  sysctl_aiomax
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_aiomax
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -1985,7 +1522,7 @@ sysctl_aiomax
         int error = sysctl_io_number(req, aio_max_requests, sizeof(int), &new_value, &changed);
         if (changed) {
                  /* make sure the system-wide limit is greater than the per process limit */
         int error = sysctl_io_number(req, aio_max_requests, sizeof(int), &new_value, &changed);
         if (changed) {
                  /* make sure the system-wide limit is greater than the per process limit */
-               if (new_value >= aio_max_requests_per_process)
+               if (new_value >= aio_max_requests_per_process && new_value <= AIO_MAX_REQUESTS)
                         aio_max_requests = new_value;
                 else
                         error = EINVAL;
                         aio_max_requests = new_value;
                 else
                         error = EINVAL;
@@ -1997,7 +1534,7 @@ sysctl_aiomax
  /*
   * Max number of concurrent aio requests per process
   */
  /*
   * Max number of concurrent aio requests per process
   */
-static int
+STATIC int
  sysctl_aioprocmax
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_aioprocmax
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2017,7 +1554,7 @@ sysctl_aioprocmax
  /*
   * Max number of async IO worker threads
   */
  /*
   * Max number of async IO worker threads
   */
-static int
+STATIC int
  sysctl_aiothreads
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_aiothreads
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2039,7 +1576,7 @@ sysctl_aiothreads
  /*
   * System-wide limit on the max number of processes
   */
  /*
   * System-wide limit on the max number of processes
   */
-static int
+STATIC int
  sysctl_maxproc
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_maxproc
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2058,26 +1595,30 @@ sysctl_maxproc
  }
  
  SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, 
  }
  
  SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 ostype, 0, "");
  SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, 
                 ostype, 0, "");
  SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 osrelease, 0, "");
  SYSCTL_INT(_kern, KERN_OSREV, osrevision, 
                 osrelease, 0, "");
  SYSCTL_INT(_kern, KERN_OSREV, osrevision, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 (int *)NULL, BSD, "");
  SYSCTL_STRING(_kern, KERN_VERSION, version, 
                 (int *)NULL, BSD, "");
  SYSCTL_STRING(_kern, KERN_VERSION, version, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 version, 0, "");
                 version, 0, "");
+SYSCTL_STRING(_kern, OID_AUTO, uuid, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
+               &kernel_uuid_string[0], 0, "");
  
  #if DEBUG
  int debug_kprint_syscall = 0;
  char debug_kprint_syscall_process[MAXCOMLEN+1];
  
  
  #if DEBUG
  int debug_kprint_syscall = 0;
  char debug_kprint_syscall_process[MAXCOMLEN+1];
  
+/* Thread safe: bits and string value are not used to reclaim state */
  SYSCTL_INT (_debug, OID_AUTO, kprint_syscall,
  SYSCTL_INT (_debug, OID_AUTO, kprint_syscall,
-           CTLFLAG_RW, &debug_kprint_syscall, 0, "kprintf syscall tracing");
+           CTLFLAG_RW | CTLFLAG_LOCKED, &debug_kprint_syscall, 0, "kprintf syscall tracing");
  SYSCTL_STRING(_debug, OID_AUTO, kprint_syscall_process, 
  SYSCTL_STRING(_debug, OID_AUTO, kprint_syscall_process, 
-                         CTLFLAG_RW, debug_kprint_syscall_process, sizeof(debug_kprint_syscall_process),
+                         CTLFLAG_RW | CTLFLAG_LOCKED, debug_kprint_syscall_process, sizeof(debug_kprint_syscall_process),
                           "name of process for kprintf syscall tracing");
  
  int debug_kprint_current_process(const char **namep)
                           "name of process for kprintf syscall tracing");
  
  int debug_kprint_current_process(const char **namep)
@@ -2113,7 +1654,7 @@ int debug_kprint_current_process(const char **namep)
  /* PR-5293665: need to use a callback function for kern.osversion to set
   * osversion in IORegistry */
  
  /* PR-5293665: need to use a callback function for kern.osversion to set
   * osversion in IORegistry */
  
-static int
+STATIC int
  sysctl_osversion(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
  {
      int rval = 0;
  sysctl_osversion(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req)
  {
      int rval = 0;
@@ -2128,11 +1669,11 @@ sysctl_osversion(__unused struct sysctl_oid *oidp, void *arg1, int arg2, struct
  }
  
  SYSCTL_PROC(_kern, KERN_OSVERSION, osversion,
  }
  
  SYSCTL_PROC(_kern, KERN_OSVERSION, osversion,
-        CTLFLAG_RW | CTLFLAG_KERN | CTLTYPE_STRING,
+        CTLFLAG_RW | CTLFLAG_KERN | CTLTYPE_STRING | CTLFLAG_LOCKED,
          osversion, 256 /* OSVERSIZE*/, 
          sysctl_osversion, "A", "");
  
          osversion, 256 /* OSVERSIZE*/, 
          sysctl_osversion, "A", "");
  
-static int
+STATIC int
  sysctl_sysctl_bootargs
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_sysctl_bootargs
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2150,46 +1691,46 @@ SYSCTL_PROC(_kern, OID_AUTO, bootargs,
         sysctl_sysctl_bootargs, "A", "bootargs");
  
  SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles, 
         sysctl_sysctl_bootargs, "A", "bootargs");
  
  SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
                 &maxfiles, 0, "");
  SYSCTL_INT(_kern, KERN_ARGMAX, argmax, 
                 &maxfiles, 0, "");
  SYSCTL_INT(_kern, KERN_ARGMAX, argmax, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 (int *)NULL, ARG_MAX, "");
  SYSCTL_INT(_kern, KERN_POSIX1, posix1version, 
                 (int *)NULL, ARG_MAX, "");
  SYSCTL_INT(_kern, KERN_POSIX1, posix1version, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 (int *)NULL, _POSIX_VERSION, "");
  SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, 
                 (int *)NULL, _POSIX_VERSION, "");
  SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 (int *)NULL, NGROUPS_MAX, "");
  SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, 
                 (int *)NULL, NGROUPS_MAX, "");
  SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 (int *)NULL, 1, "");
  #if 1  /* _POSIX_SAVED_IDS from <unistd.h> */
  SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, 
                 (int *)NULL, 1, "");
  #if 1  /* _POSIX_SAVED_IDS from <unistd.h> */
  SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 (int *)NULL, 1, "");
  #else
  SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, 
                 (int *)NULL, 1, "");
  #else
  SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, 
-               CTLFLAG_RD | CTLFLAG_KERN, 
+               CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED, 
                 NULL, 0, "");
  #endif
  SYSCTL_INT(_kern, OID_AUTO, num_files, 
                 NULL, 0, "");
  #endif
  SYSCTL_INT(_kern, OID_AUTO, num_files, 
-               CTLFLAG_RD, 
+               CTLFLAG_RD | CTLFLAG_LOCKED, 
                 &nfiles, 0, "");
  SYSCTL_COMPAT_INT(_kern, OID_AUTO, num_vnodes, 
                 &nfiles, 0, "");
  SYSCTL_COMPAT_INT(_kern, OID_AUTO, num_vnodes, 
-               CTLFLAG_RD, 
+               CTLFLAG_RD | CTLFLAG_LOCKED, 
                 &numvnodes, 0, "");
  SYSCTL_INT(_kern, OID_AUTO, num_tasks, 
                 &numvnodes, 0, "");
  SYSCTL_INT(_kern, OID_AUTO, num_tasks, 
-               CTLFLAG_RD, 
+               CTLFLAG_RD | CTLFLAG_LOCKED, 
                 &task_max, 0, "");
  SYSCTL_INT(_kern, OID_AUTO, num_threads, 
                 &task_max, 0, "");
  SYSCTL_INT(_kern, OID_AUTO, num_threads, 
-               CTLFLAG_RD, 
+               CTLFLAG_RD | CTLFLAG_LOCKED, 
                 &thread_max, 0, "");
  SYSCTL_INT(_kern, OID_AUTO, num_taskthreads, 
                 &thread_max, 0, "");
  SYSCTL_INT(_kern, OID_AUTO, num_taskthreads, 
-               CTLFLAG_RD, 
+               CTLFLAG_RD | CTLFLAG_LOCKED, 
                 &task_threadmax, 0, "");
  
                 &task_threadmax, 0, "");
  
-static int
+STATIC int
  sysctl_maxvnodes (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
         int oldval = desiredvnodes;
  sysctl_maxvnodes (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
         int oldval = desiredvnodes;
@@ -2203,27 +1744,38 @@ sysctl_maxvnodes (__unused struct sysctl_oid *oidp, __unused void *arg1, __unuse
         return(error);
  }
  
         return(error);
  }
  
+SYSCTL_INT(_kern, OID_AUTO, namecache_disabled, 
+               CTLFLAG_RW | CTLFLAG_LOCKED, 
+               &nc_disabled, 0, ""); 
+
  SYSCTL_PROC(_kern, KERN_MAXVNODES, maxvnodes,
  SYSCTL_PROC(_kern, KERN_MAXVNODES, maxvnodes,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_maxvnodes, "I", "");
  
  SYSCTL_PROC(_kern, KERN_MAXPROC, maxproc,
                 0, 0, sysctl_maxvnodes, "I", "");
  
  SYSCTL_PROC(_kern, KERN_MAXPROC, maxproc,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_maxproc, "I", "");
  
  SYSCTL_PROC(_kern, KERN_AIOMAX, aiomax,
                 0, 0, sysctl_maxproc, "I", "");
  
  SYSCTL_PROC(_kern, KERN_AIOMAX, aiomax,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_aiomax, "I", "");
  
  SYSCTL_PROC(_kern, KERN_AIOPROCMAX, aioprocmax,
                 0, 0, sysctl_aiomax, "I", "");
  
  SYSCTL_PROC(_kern, KERN_AIOPROCMAX, aioprocmax,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_aioprocmax, "I", "");
  
  SYSCTL_PROC(_kern, KERN_AIOTHREADS, aiothreads,
                 0, 0, sysctl_aioprocmax, "I", "");
  
  SYSCTL_PROC(_kern, KERN_AIOTHREADS, aiothreads,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_aiothreads, "I", "");
  
                 0, 0, sysctl_aiothreads, "I", "");
  
-static int
+#if (DEVELOPMENT || DEBUG)
+extern int sched_smt_balance;
+SYSCTL_INT(_kern, OID_AUTO, sched_smt_balance, 
+               CTLFLAG_KERN| CTLFLAG_RW| CTLFLAG_LOCKED, 
+               &sched_smt_balance, 0, "");
+#endif
+
+STATIC int
  sysctl_securelvl
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_securelvl
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2242,11 +1794,11 @@ sysctl_securelvl
  }
  
  SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
  }
  
  SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_securelvl, "I", "");
  
  
                 0, 0, sysctl_securelvl, "I", "");
  
  
-static int
+STATIC int
  sysctl_domainname
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_domainname
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2259,14 +1811,14 @@ sysctl_domainname
  }
  
  SYSCTL_PROC(_kern, KERN_DOMAINNAME, nisdomainname,
  }
  
  SYSCTL_PROC(_kern, KERN_DOMAINNAME, nisdomainname,
-               CTLTYPE_STRING | CTLFLAG_RW,
+               CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_domainname, "A", "");
  
  SYSCTL_COMPAT_INT(_kern, KERN_HOSTID, hostid, 
                 0, 0, sysctl_domainname, "A", "");
  
  SYSCTL_COMPAT_INT(_kern, KERN_HOSTID, hostid, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
                 &hostid, 0, "");
  
                 &hostid, 0, "");
  
-static int
+STATIC int
  sysctl_hostname
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_hostname
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2280,10 +1832,10 @@ sysctl_hostname
  
  
  SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname,
  
  
  SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname,
-               CTLTYPE_STRING | CTLFLAG_RW,
+               CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_hostname, "A", "");
  
                 0, 0, sysctl_hostname, "A", "");
  
-static int
+STATIC int
  sysctl_procname
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_procname
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2293,26 +1845,66 @@ sysctl_procname
  }
  
  SYSCTL_PROC(_kern, KERN_PROCNAME, procname,
  }
  
  SYSCTL_PROC(_kern, KERN_PROCNAME, procname,
-               CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_ANYBODY,
+               CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
                 0, 0, sysctl_procname, "A", "");
  
  SYSCTL_INT(_kern, KERN_SPECULATIVE_READS, speculative_reads_disabled, 
                 0, 0, sysctl_procname, "A", "");
  
  SYSCTL_INT(_kern, KERN_SPECULATIVE_READS, speculative_reads_disabled, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
                 &speculative_reads_disabled, 0, "");
  
                 &speculative_reads_disabled, 0, "");
  
-SYSCTL_UINT(_kern, OID_AUTO, preheat_pages_max, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
-               &preheat_pages_max, 0, "");
+SYSCTL_INT(_kern, OID_AUTO, ignore_is_ssd, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &ignore_is_ssd, 0, "");
  
  
-SYSCTL_UINT(_kern, OID_AUTO, preheat_pages_min, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
-               &preheat_pages_min, 0, "");
+SYSCTL_UINT(_kern, OID_AUTO, preheat_max_bytes, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &preheat_max_bytes, 0, "");
  
  
-SYSCTL_UINT(_kern, OID_AUTO, preheat_pages_mult, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
-               &preheat_pages_mult, 0, "");
+SYSCTL_UINT(_kern, OID_AUTO, preheat_min_bytes, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &preheat_min_bytes, 0, "");
  
  
-static int
+SYSCTL_UINT(_kern, OID_AUTO, speculative_prefetch_max, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &speculative_prefetch_max, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, speculative_prefetch_max_iosize, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &speculative_prefetch_max_iosize, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_page_free_target,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_page_free_target, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_page_free_min,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_page_free_min, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_page_free_reserved,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_page_free_reserved, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_page_speculative_percentage,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_page_speculative_percentage, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_page_speculative_q_age_ms,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_page_speculative_q_age_ms, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_max_delayed_work_limit,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_max_delayed_work_limit, 0, "");
+
+SYSCTL_UINT(_kern, OID_AUTO, vm_max_batch,
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &vm_max_batch, 0, "");
+
+SYSCTL_STRING(_kern, OID_AUTO, bootsessionuuid,
+               CTLFLAG_RD | CTLFLAG_LOCKED,
+               &bootsessionuuid_string, sizeof(bootsessionuuid_string) , ""); 
+
+STATIC int
  sysctl_boottime
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_boottime
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2333,10 +1925,10 @@ sysctl_boottime
  }
  
  SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime,
  }
  
  SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime,
-               CTLTYPE_STRUCT | CTLFLAG_RD,
+               CTLTYPE_STRUCT | CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_boottime, "S,timeval", "");
  
                 0, 0, sysctl_boottime, "S,timeval", "");
  
-static int
+STATIC int
  sysctl_symfile
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_symfile
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2349,11 +1941,11 @@ sysctl_symfile
  
  
  SYSCTL_PROC(_kern, KERN_SYMFILE, symfile,
  
  
  SYSCTL_PROC(_kern, KERN_SYMFILE, symfile,
-               CTLTYPE_STRING | CTLFLAG_RD,
+               CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_symfile, "A", "");
  
  #if NFSCLIENT
                 0, 0, sysctl_symfile, "A", "");
  
  #if NFSCLIENT
-static int
+STATIC int
  sysctl_netboot
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_netboot
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2361,11 +1953,196 @@ sysctl_netboot
  }
  
  SYSCTL_PROC(_kern, KERN_NETBOOT, netboot,
  }
  
  SYSCTL_PROC(_kern, KERN_NETBOOT, netboot,
-               CTLTYPE_INT | CTLFLAG_RD,
+               CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_netboot, "I", "");
  #endif
  
                 0, 0, sysctl_netboot, "I", "");
  #endif
  
-static int
+#ifdef CONFIG_IMGSRC_ACCESS
+/*
+ * Legacy--act as if only one layer of nesting is possible.
+ */
+STATIC int
+sysctl_imgsrcdev 
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+       vfs_context_t ctx = vfs_context_current();
+       vnode_t devvp;
+       int result;
+
+       if (!vfs_context_issuser(ctx)) {
+               return EPERM;
+       }    
+
+       if (imgsrc_rootvnodes[0] == NULL) {
+               return ENOENT;
+       }    
+
+       result = vnode_getwithref(imgsrc_rootvnodes[0]);
+       if (result != 0) {
+               return result;
+       }
+       
+       devvp = vnode_mount(imgsrc_rootvnodes[0])->mnt_devvp;
+       result = vnode_getwithref(devvp);
+       if (result != 0) {
+               goto out;
+       }
+
+       result = sysctl_io_number(req, vnode_specrdev(devvp), sizeof(dev_t), NULL, NULL);
+
+       vnode_put(devvp);
+out:
+       vnode_put(imgsrc_rootvnodes[0]);
+       return result;
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, imgsrcdev,
+               CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
+               0, 0, sysctl_imgsrcdev, "I", ""); 
+
+STATIC int
+sysctl_imgsrcinfo
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+       int error;
+       struct imgsrc_info info[MAX_IMAGEBOOT_NESTING]; /* 2 for now, no problem */
+       uint32_t i;
+       vnode_t rvp, devvp;
+
+       if (imgsrc_rootvnodes[0] == NULLVP) {
+               return ENXIO;
+       }
+
+       for (i = 0; i < MAX_IMAGEBOOT_NESTING; i++) {
+               /*
+                * Go get the root vnode.
+                */
+               rvp = imgsrc_rootvnodes[i];
+               if (rvp == NULLVP) {
+                       break;
+               }
+
+               error = vnode_get(rvp);
+               if (error != 0) {
+                       return error;
+               }
+
+               /* 
+                * For now, no getting at a non-local volume.
+                */
+               devvp = vnode_mount(rvp)->mnt_devvp;
+               if (devvp == NULL) {
+                       vnode_put(rvp);
+                       return EINVAL;  
+               }
+
+               error = vnode_getwithref(devvp);
+               if (error != 0) {
+                       vnode_put(rvp);
+                       return error;
+               }
+
+               /*
+                * Fill in info.
+                */
+               info[i].ii_dev = vnode_specrdev(devvp);
+               info[i].ii_flags = 0;
+               info[i].ii_height = i;
+               bzero(info[i].ii_reserved, sizeof(info[i].ii_reserved));
+
+               vnode_put(devvp);
+               vnode_put(rvp);
+       }
+
+       return sysctl_io_opaque(req, info, i * sizeof(info[0]), NULL);
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, imgsrcinfo,
+               CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_LOCKED,
+               0, 0, sysctl_imgsrcinfo, "I", ""); 
+
+#endif /* CONFIG_IMGSRC_ACCESS */
+
+
+SYSCTL_DECL(_kern_timer);
+SYSCTL_NODE(_kern, OID_AUTO, timer, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "timer");
+
+
+SYSCTL_INT(_kern_timer, OID_AUTO, coalescing_enabled, 
+               CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+               &mach_timer_coalescing_enabled, 0, "");
+
+SYSCTL_QUAD(_kern_timer, OID_AUTO, deadline_tracking_bin_1,
+               CTLFLAG_RW | CTLFLAG_LOCKED,
+               &timer_deadline_tracking_bin_1, "");
+SYSCTL_QUAD(_kern_timer, OID_AUTO, deadline_tracking_bin_2,
+               CTLFLAG_RW | CTLFLAG_LOCKED,
+               &timer_deadline_tracking_bin_2, "");
+
+SYSCTL_DECL(_kern_timer_longterm);
+SYSCTL_NODE(_kern_timer, OID_AUTO, longterm, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "longterm");
+
+
+/* Must match definition in osfmk/kern/timer_call.c */
+enum {
+       THRESHOLD, QCOUNT,
+       ENQUEUES, DEQUEUES, ESCALATES, SCANS, PREEMPTS,
+       LATENCY, LATENCY_MIN, LATENCY_MAX
+};
+extern uint64_t        timer_sysctl_get(int);
+extern int      timer_sysctl_set(int, uint64_t);
+
+STATIC int
+sysctl_timer
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+       int             oid = (int)arg1;
+       uint64_t        value = timer_sysctl_get(oid);
+       uint64_t        new_value;
+       int             error;
+       int             changed;
+
+       error = sysctl_io_number(req, value, sizeof(value), &new_value, &changed);
+       if (changed)
+               error = timer_sysctl_set(oid, new_value);
+
+       return error;
+}
+
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, threshold,
+               CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
+               (void *) THRESHOLD, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, qlen,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) QCOUNT, 0, sysctl_timer, "Q", "");
+#if DEBUG
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, enqueues,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) ENQUEUES, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, dequeues,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) DEQUEUES, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, escalates,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) ESCALATES, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, scans,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) SCANS, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, preempts,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) PREEMPTS, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, latency,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) LATENCY, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, latency_min,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) LATENCY_MIN, 0, sysctl_timer, "Q", "");
+SYSCTL_PROC(_kern_timer_longterm, OID_AUTO, latency_max,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
+               (void *) LATENCY_MAX, 0, sysctl_timer, "Q", "");
+#endif /* DEBUG */
+
+STATIC int
  sysctl_usrstack
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_usrstack
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2373,10 +2150,10 @@ sysctl_usrstack
  }
  
  SYSCTL_PROC(_kern, KERN_USRSTACK32, usrstack,
  }
  
  SYSCTL_PROC(_kern, KERN_USRSTACK32, usrstack,
-               CTLTYPE_INT | CTLFLAG_RD,
+               CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_usrstack, "I", "");
  
                 0, 0, sysctl_usrstack, "I", "");
  
-static int
+STATIC int
  sysctl_usrstack64
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_usrstack64
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2384,20 +2161,21 @@ sysctl_usrstack64
  }
  
  SYSCTL_PROC(_kern, KERN_USRSTACK64, usrstack64,
  }
  
  SYSCTL_PROC(_kern, KERN_USRSTACK64, usrstack64,
-               CTLTYPE_QUAD | CTLFLAG_RD,
+               CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_usrstack64, "Q", "");
  
  SYSCTL_STRING(_kern, KERN_COREFILE, corefile, 
                 0, 0, sysctl_usrstack64, "Q", "");
  
  SYSCTL_STRING(_kern, KERN_COREFILE, corefile, 
-               CTLFLAG_RW | CTLFLAG_KERN, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
                 corefilename, sizeof(corefilename), "");
  
                 corefilename, sizeof(corefilename), "");
  
-static int
+STATIC int
  sysctl_coredump
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  #ifdef SECURE_KERNEL
  sysctl_coredump
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  #ifdef SECURE_KERNEL
+       (void)req;
         return (ENOTSUP);
         return (ENOTSUP);
-#endif
+#else
         int new_value, changed;
         int error = sysctl_io_number(req, do_coredump, sizeof(int), &new_value, &changed);
         if (changed) {
         int new_value, changed;
         int error = sysctl_io_number(req, do_coredump, sizeof(int), &new_value, &changed);
         if (changed) {
@@ -2407,19 +2185,21 @@ sysctl_coredump
                         error = EINVAL;
         }
         return(error);
                         error = EINVAL;
         }
         return(error);
+#endif
  }
  
  SYSCTL_PROC(_kern, KERN_COREDUMP, coredump,
  }
  
  SYSCTL_PROC(_kern, KERN_COREDUMP, coredump,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_coredump, "I", "");
  
                 0, 0, sysctl_coredump, "I", "");
  
-static int
+STATIC int
  sysctl_suid_coredump
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  #ifdef SECURE_KERNEL
  sysctl_suid_coredump
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  #ifdef SECURE_KERNEL
+       (void)req;
         return (ENOTSUP);
         return (ENOTSUP);
-#endif
+#else
         int new_value, changed;
         int error = sysctl_io_number(req, sugid_coredump, sizeof(int), &new_value, &changed);
         if (changed) {
         int new_value, changed;
         int error = sysctl_io_number(req, sugid_coredump, sizeof(int), &new_value, &changed);
         if (changed) {
@@ -2429,13 +2209,14 @@ sysctl_suid_coredump
                         error = EINVAL;
         }
         return(error);
                         error = EINVAL;
         }
         return(error);
+#endif
  }
  
  SYSCTL_PROC(_kern, KERN_SUGID_COREDUMP, sugid_coredump,
  }
  
  SYSCTL_PROC(_kern, KERN_SUGID_COREDUMP, sugid_coredump,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_suid_coredump, "I", "");
  
                 0, 0, sysctl_suid_coredump, "I", "");
  
-static int
+STATIC int
  sysctl_delayterm
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_delayterm
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2454,11 +2235,11 @@ sysctl_delayterm
  }
  
  SYSCTL_PROC(_kern, KERN_PROCDELAYTERM, delayterm,
  }
  
  SYSCTL_PROC(_kern, KERN_PROCDELAYTERM, delayterm,
-               CTLTYPE_INT | CTLFLAG_RW,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
                 0, 0, sysctl_delayterm, "I", "");
  
  
                 0, 0, sysctl_delayterm, "I", "");
  
  
-static int
+STATIC int
  sysctl_rage_vnode
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_rage_vnode
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2504,11 +2285,48 @@ sysctl_rage_vnode
  }
  
  SYSCTL_PROC(_kern, KERN_RAGEVNODE, rage_vnode,
  }
  
  SYSCTL_PROC(_kern, KERN_RAGEVNODE, rage_vnode,
-               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
                 0, 0, sysctl_rage_vnode, "I", "");
  
                 0, 0, sysctl_rage_vnode, "I", "");
  
+/* XXX move this interface into libproc and remove this sysctl */
+STATIC int
+sysctl_setthread_cpupercent
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+       int new_value, old_value;
+       int error = 0;
+       kern_return_t kret = KERN_SUCCESS;
+       uint8_t percent = 0;
+       int ms_refill = 0;
  
  
-static int
+       if (!req->newptr)
+               return (0);
+
+       old_value = 0;
+
+       if ((error = sysctl_io_number(req, old_value, sizeof(old_value), &new_value, NULL)) != 0)
+               return (error);
+
+       percent = new_value & 0xff;                     /* low 8 bytes for perent */
+       ms_refill = (new_value >> 8) & 0xffffff;        /* upper 24bytes represent ms refill value */
+       if (percent > 100)
+               return (EINVAL);
+
+       /*
+        * If the caller is specifying a percentage of 0, this will unset the CPU limit, if present.
+        */
+       if ((kret = thread_set_cpulimit(THREAD_CPULIMIT_BLOCK, percent, ms_refill * (int)NSEC_PER_MSEC)) != 0)
+               return (EIO);
+       
+       return (0);
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, setthread_cpupercent,
+               CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_ANYBODY,
+               0, 0, sysctl_setthread_cpupercent, "I", "set thread cpu percentage limit");
+
+
+STATIC int
  sysctl_kern_check_openevt
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_kern_check_openevt
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2541,18 +2359,19 @@ sysctl_kern_check_openevt
         return(error);
  }
  
         return(error);
  }
  
-SYSCTL_PROC(_kern, KERN_CHECKOPENEVT, check_openevt, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
+SYSCTL_PROC(_kern, KERN_CHECKOPENEVT, check_openevt, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
              0, 0, sysctl_kern_check_openevt, "I", "set the per-process check-open-evt flag");
  
  
  
              0, 0, sysctl_kern_check_openevt, "I", "set the per-process check-open-evt flag");
  
  
  
-static int
+STATIC int
  sysctl_nx
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  #ifdef SECURE_KERNEL
  sysctl_nx
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  #ifdef SECURE_KERNEL
+       (void)req;
         return ENOTSUP;
         return ENOTSUP;
-#endif
+#else
         int new_value, changed;
         int error;
  
         int new_value, changed;
         int error;
  
@@ -2571,15 +2390,16 @@ sysctl_nx
                 nx_enabled = new_value;
         }
         return(error);
                 nx_enabled = new_value;
         }
         return(error);
+#endif /* SECURE_KERNEL */
  }
  
  
  
  SYSCTL_PROC(_kern, KERN_NX_PROTECTION, nx, 
  }
  
  
  
  SYSCTL_PROC(_kern, KERN_NX_PROTECTION, nx, 
-               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN, 
+               CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
                 0, 0, sysctl_nx, "I", "");
  
                 0, 0, sysctl_nx, "I", "");
  
-static int
+STATIC int
  sysctl_loadavg
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_loadavg
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2595,10 +2415,30 @@ sysctl_loadavg
  }
  
  SYSCTL_PROC(_vm, VM_LOADAVG, loadavg,
  }
  
  SYSCTL_PROC(_vm, VM_LOADAVG, loadavg,
-               CTLTYPE_STRUCT | CTLFLAG_RD,
+               CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_loadavg, "S,loadavg", "");
  
                 0, 0, sysctl_loadavg, "S,loadavg", "");
  
-static int
+/*
+ * Note:       Thread safe; vm_map_lock protects in  vm_toggle_entry_reuse()
+ */
+STATIC int
+sysctl_vm_toggle_address_reuse(__unused struct sysctl_oid *oidp, __unused void *arg1,
+             __unused int arg2, struct sysctl_req *req)
+{
+       int old_value=0, new_value=0, error=0;
+       
+       if(vm_toggle_entry_reuse( VM_TOGGLE_GETVALUE, &old_value ))
+               return(error);
+       error = sysctl_io_number(req, old_value, sizeof(int), &new_value, NULL);
+       if (!error) {
+               return (vm_toggle_entry_reuse(new_value, NULL));
+       }
+       return(error);
+}
+
+SYSCTL_PROC(_debug, OID_AUTO, toggle_address_reuse, CTLFLAG_ANYBODY | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, 0, 0, sysctl_vm_toggle_address_reuse,"I","");
+
+STATIC int
  sysctl_swapusage
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_swapusage
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2627,48 +2467,52 @@ sysctl_swapusage
  
  
  SYSCTL_PROC(_vm, VM_SWAPUSAGE, swapusage,
  
  
  SYSCTL_PROC(_vm, VM_SWAPUSAGE, swapusage,
-               CTLTYPE_STRUCT | CTLFLAG_RD,
+               CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_swapusage, "S,xsw_usage", "");
  
                 0, 0, sysctl_swapusage, "S,xsw_usage", "");
  
+#if CONFIG_FREEZE
+extern void vm_page_reactivate_all_throttled(void);
  
  
-/* this kernel does NOT implement shared_region_make_private_np() */
-SYSCTL_INT(_kern, KERN_SHREG_PRIVATIZABLE, shreg_private, 
-               CTLFLAG_RD, 
-               (int *)NULL, 0, "");
-
-#if defined(__i386__) || defined(__x86_64__)
  static int
  static int
-sysctl_sysctl_exec_affinity(__unused struct sysctl_oid *oidp,
-                          __unused void *arg1, __unused int arg2,
-                          struct sysctl_req *req)
+sysctl_freeze_enabled SYSCTL_HANDLER_ARGS
  {
  {
-       proc_t cur_proc = req->p;
-       int error;
+#pragma unused(arg1, arg2)
+       int error, val = memorystatus_freeze_enabled ? 1 : 0;
+       boolean_t disabled;
+
+       error = sysctl_handle_int(oidp, &val, 0, req);
+       if (error || !req->newptr)
+               return (error);
         
         
-       if (req->oldptr != USER_ADDR_NULL) {
-               cpu_type_t oldcputype = (cur_proc->p_flag & P_AFFINITY) ? CPU_TYPE_POWERPC : CPU_TYPE_I386;
-               if ((error = SYSCTL_OUT(req, &oldcputype, sizeof(oldcputype))))
-                       return error;
+       if (COMPRESSED_PAGER_IS_ACTIVE || DEFAULT_FREEZER_COMPRESSED_PAGER_IS_ACTIVE) {
+               //assert(req->newptr);
+               printf("Failed attempt to set vm.freeze_enabled sysctl\n");
+               return EINVAL;
         }
  
         }
  
-       if (req->newptr != USER_ADDR_NULL) {
-               cpu_type_t newcputype;
-               if ((error = SYSCTL_IN(req, &newcputype, sizeof(newcputype))))
-                       return error;
-               if (newcputype == CPU_TYPE_I386)
-                       OSBitAndAtomic(~((uint32_t)P_AFFINITY), &cur_proc->p_flag);
-               else if (newcputype == CPU_TYPE_POWERPC)
-                       OSBitOrAtomic(P_AFFINITY, &cur_proc->p_flag);
-               else
-                       return (EINVAL);
+       /* 
+        * If freeze is being disabled, we need to move dirty pages out from the throttle to the active queue. 
+        */
+       disabled = (!val && memorystatus_freeze_enabled);
+       
+       memorystatus_freeze_enabled = val ? TRUE : FALSE;
+       
+       if (disabled) {
+               vm_page_reactivate_all_throttled();
         }
         
         }
         
-       return 0;
+       return (0);
  }
  }
-SYSCTL_PROC(_sysctl, OID_AUTO, proc_exec_affinity, CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0, sysctl_sysctl_exec_affinity ,"I","proc_exec_affinity");
-#endif
  
  
-static int
+SYSCTL_PROC(_vm, OID_AUTO, freeze_enabled, CTLTYPE_INT|CTLFLAG_RW, &memorystatus_freeze_enabled, 0, sysctl_freeze_enabled, "I", "");
+#endif /* CONFIG_FREEZE */
+
+/* this kernel does NOT implement shared_region_make_private_np() */
+SYSCTL_INT(_kern, KERN_SHREG_PRIVATIZABLE, shreg_private, 
+               CTLFLAG_RD | CTLFLAG_LOCKED, 
+               (int *)NULL, 0, "");
+
+STATIC int
  fetch_process_cputype(
         proc_t cur_proc,
         int *name,
  fetch_process_cputype(
         proc_t cur_proc,
         int *name,
@@ -2692,17 +2536,10 @@ fetch_process_cputype(
                 goto out;
         }
  
                 goto out;
         }
  
-#if defined(__i386__) || defined(__x86_64__)
-       if (p->p_flag & P_TRANSLATED) {
-               ret = CPU_TYPE_POWERPC;
-       }
-       else
-#endif
-       {
-               ret = cpu_type();
-               if (IS_64BIT_PROCESS(p))
-                       ret |= CPU_ARCH_ABI64;
-       }
+       ret = cpu_type() & ~CPU_ARCH_MASK;
+       if (IS_64BIT_PROCESS(p))
+               ret |= CPU_ARCH_ABI64;
+
         *cputype = ret;
         
         if (refheld != 0)
         *cputype = ret;
         
         if (refheld != 0)
@@ -2711,7 +2548,7 @@ out:
         return (error);
  }
  
         return (error);
  }
  
-static int
+STATIC int
  sysctl_sysctl_native(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
                     struct sysctl_req *req)
  {
  sysctl_sysctl_native(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
                     struct sysctl_req *req)
  {
@@ -2724,9 +2561,9 @@ sysctl_sysctl_native(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
                 res = 0;
         return SYSCTL_OUT(req, &res, sizeof(res));
  }      
                 res = 0;
         return SYSCTL_OUT(req, &res, sizeof(res));
  }      
-SYSCTL_PROC(_sysctl, OID_AUTO, proc_native, CTLTYPE_NODE|CTLFLAG_RD, 0, 0, sysctl_sysctl_native ,"I","proc_native");
+SYSCTL_PROC(_sysctl, OID_AUTO, proc_native, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, sysctl_sysctl_native ,"I","proc_native");
  
  
-static int
+STATIC int
  sysctl_sysctl_cputype(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
                      struct sysctl_req *req)
  {
  sysctl_sysctl_cputype(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
                      struct sysctl_req *req)
  {
@@ -2736,9 +2573,9 @@ sysctl_sysctl_cputype(__unused struct sysctl_oid *oidp, void *arg1, int arg2,
                 return error;
         return SYSCTL_OUT(req, &proc_cputype, sizeof(proc_cputype));
  }
                 return error;
         return SYSCTL_OUT(req, &proc_cputype, sizeof(proc_cputype));
  }
-SYSCTL_PROC(_sysctl, OID_AUTO, proc_cputype, CTLTYPE_NODE|CTLFLAG_RD, 0, 0, sysctl_sysctl_cputype ,"I","proc_cputype");
+SYSCTL_PROC(_sysctl, OID_AUTO, proc_cputype, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, sysctl_sysctl_cputype ,"I","proc_cputype");
  
  
-static int
+STATIC int
  sysctl_safeboot
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_safeboot
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2746,10 +2583,10 @@ sysctl_safeboot
  }
  
  SYSCTL_PROC(_kern, KERN_SAFEBOOT, safeboot,
  }
  
  SYSCTL_PROC(_kern, KERN_SAFEBOOT, safeboot,
-               CTLTYPE_INT | CTLFLAG_RD,
+               CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_safeboot, "I", "");
  
                 0, 0, sysctl_safeboot, "I", "");
  
-static int
+STATIC int
  sysctl_singleuser
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
  sysctl_singleuser
  (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
  {
@@ -2757,7 +2594,7 @@ sysctl_singleuser
  }
  
  SYSCTL_PROC(_kern, OID_AUTO, singleuser,
  }
  
  SYSCTL_PROC(_kern, OID_AUTO, singleuser,
-               CTLTYPE_INT | CTLFLAG_RD,
+               CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
                 0, 0, sysctl_singleuser, "I", "");
  
  /*
                 0, 0, sysctl_singleuser, "I", "");
  
  /*
@@ -2767,9 +2604,27 @@ extern boolean_t affinity_sets_enabled;
  extern int             affinity_sets_mapping;
  
  SYSCTL_INT (_kern, OID_AUTO, affinity_sets_enabled,
  extern int             affinity_sets_mapping;
  
  SYSCTL_INT (_kern, OID_AUTO, affinity_sets_enabled,
-           CTLFLAG_RW, (int *) &affinity_sets_enabled, 0, "hinting enabled");
+           CTLFLAG_RW | CTLFLAG_LOCKED, (int *) &affinity_sets_enabled, 0, "hinting enabled");
  SYSCTL_INT (_kern, OID_AUTO, affinity_sets_mapping,
  SYSCTL_INT (_kern, OID_AUTO, affinity_sets_mapping,
-           CTLFLAG_RW, &affinity_sets_mapping, 0, "mapping policy");
+           CTLFLAG_RW | CTLFLAG_LOCKED, &affinity_sets_mapping, 0, "mapping policy");
+
+/*
+ * Boolean indicating if KASLR is active.
+ */
+STATIC int
+sysctl_slide
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+       uint32_t        slide;
+
+       slide = vm_kernel_slide ? 1 : 0;
+
+       return sysctl_io_number( req, slide, sizeof(int), NULL, NULL);
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, slide,
+               CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_LOCKED,
+               0, 0, sysctl_slide, "I", "");
  
  /*
   * Limit on total memory users can wire.
  
  /*
   * Limit on total memory users can wire.
@@ -2791,27 +2646,301 @@ vm_map_size_t  vm_user_wire_limit;
  /*
   * There needs to be a more automatic/elegant way to do this
   */
  /*
   * There needs to be a more automatic/elegant way to do this
   */
+SYSCTL_QUAD(_vm, OID_AUTO, global_no_user_wire_amount, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_global_no_user_wire_amount, "");
+SYSCTL_QUAD(_vm, OID_AUTO, global_user_wire_limit, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_global_user_wire_limit, "");
+SYSCTL_QUAD(_vm, OID_AUTO, user_wire_limit, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_user_wire_limit, "");
+
+extern int vm_map_copy_overwrite_aligned_src_not_internal;
+extern int vm_map_copy_overwrite_aligned_src_not_symmetric;
+extern int vm_map_copy_overwrite_aligned_src_large;
+SYSCTL_INT(_vm, OID_AUTO, vm_copy_src_not_internal, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_copy_overwrite_aligned_src_not_internal, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, vm_copy_src_not_symmetric, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_copy_overwrite_aligned_src_not_symmetric, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, vm_copy_src_large, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_map_copy_overwrite_aligned_src_large, 0, "");
+
+
+extern uint32_t        vm_page_external_count;
+extern uint32_t        vm_page_filecache_min;
+
+SYSCTL_INT(_vm, OID_AUTO, vm_page_external_count, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_page_external_count, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, vm_page_filecache_min, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_page_filecache_min, 0, "");
+
+extern int     vm_compressor_mode;
+extern int     vm_compressor_is_active;
+extern uint32_t        swapout_target_age;
+extern int64_t  compressor_bytes_used;
+extern uint32_t        compressor_eval_period_in_msecs;
+extern uint32_t        compressor_sample_min_in_msecs;
+extern uint32_t        compressor_sample_max_in_msecs;
+extern uint32_t        compressor_thrashing_threshold_per_10msecs;
+extern uint32_t        compressor_thrashing_min_per_10msecs;
+extern uint32_t        vm_compressor_minorcompact_threshold_divisor;
+extern uint32_t        vm_compressor_majorcompact_threshold_divisor;
+extern uint32_t        vm_compressor_unthrottle_threshold_divisor;
+extern uint32_t        vm_compressor_catchup_threshold_divisor;
+
+SYSCTL_INT(_vm, OID_AUTO, compressor_mode, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_compressor_mode, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_is_active, CTLFLAG_RD | CTLFLAG_LOCKED, &vm_compressor_is_active, 0, "");
+SYSCTL_QUAD(_vm, OID_AUTO, compressor_bytes_used, CTLFLAG_RD | CTLFLAG_LOCKED, &compressor_bytes_used, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_swapout_target_age, CTLFLAG_RD | CTLFLAG_LOCKED, &swapout_target_age, 0, "");
+
+SYSCTL_INT(_vm, OID_AUTO, compressor_eval_period_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_eval_period_in_msecs, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_sample_min_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_sample_min_in_msecs, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_sample_max_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_sample_max_in_msecs, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_thrashing_threshold_per_10msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_thrashing_threshold_per_10msecs, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_thrashing_min_per_10msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &compressor_thrashing_min_per_10msecs, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_minorcompact_threshold_divisor, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_minorcompact_threshold_divisor, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_majorcompact_threshold_divisor, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_majorcompact_threshold_divisor, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_unthrottle_threshold_divisor, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_unthrottle_threshold_divisor, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, compressor_catchup_threshold_divisor, CTLFLAG_RW | CTLFLAG_LOCKED, &vm_compressor_catchup_threshold_divisor, 0, "");
+
+SYSCTL_STRING(_vm, OID_AUTO, swapfileprefix, CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED, swapfilename, sizeof(swapfilename) - SWAPFILENAME_INDEX_LEN, "");
+
+#if CONFIG_PHANTOM_CACHE
+extern uint32_t phantom_cache_thrashing_threshold;
+extern uint32_t phantom_cache_eval_period_in_msecs;
+extern uint32_t phantom_cache_thrashing_threshold_ssd;
+
+
+SYSCTL_INT(_vm, OID_AUTO, phantom_cache_eval_period_in_msecs, CTLFLAG_RW | CTLFLAG_LOCKED, &phantom_cache_eval_period_in_msecs, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, phantom_cache_thrashing_threshold, CTLFLAG_RW | CTLFLAG_LOCKED, &phantom_cache_thrashing_threshold, 0, "");
+SYSCTL_INT(_vm, OID_AUTO, phantom_cache_thrashing_threshold_ssd, CTLFLAG_RW | CTLFLAG_LOCKED, &phantom_cache_thrashing_threshold_ssd, 0, "");
+#endif
  
  
-SYSCTL_QUAD(_vm, OID_AUTO, global_no_user_wire_amount, CTLFLAG_RW, &vm_global_no_user_wire_amount, "");
-SYSCTL_QUAD(_vm, OID_AUTO, global_user_wire_limit, CTLFLAG_RW, &vm_global_user_wire_limit, "");
-SYSCTL_QUAD(_vm, OID_AUTO, user_wire_limit, CTLFLAG_RW, &vm_user_wire_limit, "");
+#if (DEVELOPMENT || DEBUG)
  
  
+SYSCTL_UINT(_vm, OID_AUTO, vm_page_creation_throttled_hard,
+           CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+           &vm_page_creation_throttled_hard, 0, "");
  
  
+SYSCTL_UINT(_vm, OID_AUTO, vm_page_creation_throttled_soft,
+           CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+           &vm_page_creation_throttled_soft, 0, "");
+
+#endif /* DEVELOPMENT || DEBUG */
  
  /*
  
  /*
- * enable back trace events for thread blocks
+ * Enable tracing of voucher contents
   */
   */
+extern uint32_t ipc_voucher_trace_contents;
  
  
-extern uint32_t        kdebug_thread_block;
-
-SYSCTL_INT (_kern, OID_AUTO, kdebug_thread_block,
-           CTLFLAG_RW, &kdebug_thread_block, 0, "kdebug thread_block");
+SYSCTL_INT (_kern, OID_AUTO, ipc_voucher_trace_contents,
+           CTLFLAG_RW | CTLFLAG_LOCKED, &ipc_voucher_trace_contents, 0, "Enable tracing voucher contents");
  
  /*
   * Kernel stack size and depth
   */
  SYSCTL_INT (_kern, OID_AUTO, stack_size,
  
  /*
   * Kernel stack size and depth
   */
  SYSCTL_INT (_kern, OID_AUTO, stack_size,
-           CTLFLAG_RD, (int *) &kernel_stack_size, 0, "Kernel stack size");
+           CTLFLAG_RD | CTLFLAG_LOCKED, (int *) &kernel_stack_size, 0, "Kernel stack size");
  SYSCTL_INT (_kern, OID_AUTO, stack_depth_max,
  SYSCTL_INT (_kern, OID_AUTO, stack_depth_max,
-           CTLFLAG_RD, (int *) &kernel_stack_depth_max, 0, "Max kernel stack depth at interrupt or context switch");
+           CTLFLAG_RD | CTLFLAG_LOCKED, (int *) &kernel_stack_depth_max, 0, "Max kernel stack depth at interrupt or context switch");
+
+/*
+ * enable back trace for port allocations
+ */
+extern int ipc_portbt;
+
+SYSCTL_INT(_kern, OID_AUTO, ipc_portbt, 
+               CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+               &ipc_portbt, 0, "");
+
+/*
+ * Scheduler sysctls
+ */
+
+/*
+ * See osfmk/kern/sched_prim.c for the corresponding definition
+ * in osfmk/. If either version changes, update the other.
+ */
+#define SCHED_STRING_MAX_LENGTH (48)
+
+extern char sched_string[SCHED_STRING_MAX_LENGTH];
+SYSCTL_STRING(_kern, OID_AUTO, sched,
+                         CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+                         sched_string, sizeof(sched_string),
+                         "Timeshare scheduler implementation");
+
+/*
+ * Only support runtime modification on embedded platforms
+ * with development config enabled
+ */
+
+
+/* Parameters related to timer coalescing tuning, to be replaced
+ * with a dedicated systemcall in the future.
+ */
+/* Enable processing pending timers in the context of any other interrupt
+ * Coalescing tuning parameters for various thread/task attributes */
+STATIC int
+sysctl_timer_user_us_kernel_abstime SYSCTL_HANDLER_ARGS
+{
+#pragma unused(oidp)
+       int size = arg2;        /* subcommand*/
+       int error;
+       int changed = 0;
+       uint64_t old_value_ns;
+       uint64_t new_value_ns;
+       uint64_t value_abstime;
+       if (size == sizeof(uint32_t))
+               value_abstime = *((uint32_t *)arg1);
+       else if (size == sizeof(uint64_t))
+               value_abstime = *((uint64_t *)arg1);
+       else return ENOTSUP;
+
+       absolutetime_to_nanoseconds(value_abstime, &old_value_ns);
+       error = sysctl_io_number(req, old_value_ns, sizeof(old_value_ns), &new_value_ns, &changed);
+       if ((error) || (!changed))
+               return error;
+
+       nanoseconds_to_absolutetime(new_value_ns, &value_abstime);
+       if (size == sizeof(uint32_t))
+               *((uint32_t *)arg1) = (uint32_t)value_abstime;
+       else
+               *((uint64_t *)arg1) = value_abstime;
+       return error;
+}
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_bg_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_bg_shift, 0, "");
+SYSCTL_PROC(_kern, OID_AUTO, timer_resort_threshold_ns,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_resort_threshold_abstime,
+    sizeof(tcoal_prio_params.timer_resort_threshold_abstime),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_bg_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_bg_abstime_max,
+    sizeof(tcoal_prio_params.timer_coalesce_bg_abstime_max),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_kt_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_kt_shift, 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_kt_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_kt_abstime_max,
+    sizeof(tcoal_prio_params.timer_coalesce_kt_abstime_max),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_fp_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_fp_shift, 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_fp_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_fp_abstime_max,
+    sizeof(tcoal_prio_params.timer_coalesce_fp_abstime_max), 
+   sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_ts_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_ts_shift, 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_ts_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.timer_coalesce_ts_abstime_max,
+    sizeof(tcoal_prio_params.timer_coalesce_ts_abstime_max),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier0_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_scale[0], 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier0_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_abstime_max[0],
+    sizeof(tcoal_prio_params.latency_qos_abstime_max[0]),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier1_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_scale[1], 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier1_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_abstime_max[1],
+    sizeof(tcoal_prio_params.latency_qos_abstime_max[1]),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier2_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_scale[2], 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier2_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_abstime_max[2],
+    sizeof(tcoal_prio_params.latency_qos_abstime_max[2]),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier3_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_scale[3], 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier3_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_abstime_max[3],
+    sizeof(tcoal_prio_params.latency_qos_abstime_max[3]),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier4_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_scale[4], 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier4_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_abstime_max[4],
+    sizeof(tcoal_prio_params.latency_qos_abstime_max[4]),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+SYSCTL_INT(_kern, OID_AUTO, timer_coalesce_tier5_scale,
+    CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_scale[5], 0, "");
+
+SYSCTL_PROC(_kern, OID_AUTO, timer_coalesce_tier5_ns_max,
+    CTLTYPE_QUAD | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED,
+    &tcoal_prio_params.latency_qos_abstime_max[5],
+    sizeof(tcoal_prio_params.latency_qos_abstime_max[5]),
+    sysctl_timer_user_us_kernel_abstime,
+    "Q", "");
+
+/* Communicate the "user idle level" heuristic to the timer layer, and
+ * potentially other layers in the future.
+ */
+
+static int
+timer_user_idle_level(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req) {
+       int new_value = 0, old_value = 0, changed = 0, error;
+
+       old_value = timer_get_user_idle_level();
+
+       error = sysctl_io_number(req, old_value, sizeof(int), &new_value, &changed);
+
+       if (error == 0 && changed) {
+               if (timer_set_user_idle_level(new_value) != KERN_SUCCESS)
+                       error = ERANGE;
+       }
+
+       return error;
+}
  
  
+SYSCTL_PROC(_machdep, OID_AUTO, user_idle_level,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
+    0, 0,
+    timer_user_idle_level, "I", "User idle level heuristic, 0-128");
+
+#if HYPERVISOR
+SYSCTL_INT(_kern, OID_AUTO, hv_support, 
+               CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED, 
+               &hv_support_available, 0, "");
+#endif