/*
- * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#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 <sys/mount_internal.h>
#include <sys/kdebug.h>
-#include <sys/sysproto.h>
#include <IOKit/IOPlatformExpert.h>
#include <pexpert/pexpert.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
-extern sysctlfn net_sysctl;
-extern sysctlfn cpu_sysctl;
+#if CONFIG_FREEZE
+#include <sys/kern_memorystatus.h>
+#endif
+
+#if KPERF
+#include <kperf/kperf.h>
+#endif
+
+#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 speculative_reads_disabled;
extern int ignore_is_ssd;
extern unsigned int speculative_prefetch_max;
-extern unsigned int preheat_pages_max;
-extern unsigned int preheat_pages_min;
+extern unsigned int speculative_prefetch_max_iosize;
+extern unsigned int preheat_max_bytes;
+extern unsigned int preheat_min_bytes;
extern long numvnodes;
+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_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.
*/
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 p, struct user32_eproc *ep);
+fill_user32_eproc(proc_t, struct user32_eproc *__restrict);
STATIC void
-fill_user32_externproc(proc_t p, struct user32_extern_proc *exp);
+fill_user32_externproc(proc_t, struct user32_extern_proc *__restrict);
STATIC void
-fill_user64_eproc(proc_t p, struct user64_eproc *ep);
+fill_user64_eproc(proc_t, struct user64_eproc *__restrict);
STATIC void
-fill_user64_proc(proc_t p, struct user64_kinfo_proc *kp);
+fill_user64_proc(proc_t, struct user64_kinfo_proc *__restrict);
STATIC void
-fill_user64_externproc(proc_t p, struct user64_extern_proc *exp);
+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);
#if NFSCLIENT
proc_t p);
__private_extern__ kern_return_t
reset_vmobjectcache(unsigned int val1, unsigned int val2);
-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);
/* 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_exec_archhandler_ppc(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
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_file(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
STATIC int sysctl_kdebug_ops SYSCTL_HANDLER_ARGS;
-STATIC int sysctl_dotranslate SYSCTL_HANDLER_ARGS;
-STATIC int sysctl_doaffinity SYSCTL_HANDLER_ARGS;
#if COUNT_SYSCALLS
STATIC int sysctl_docountsyscalls SYSCTL_HANDLER_ARGS;
#endif /* COUNT_SYSCALLS */
-#if !CONFIG_EMBEDDED
STATIC int sysctl_doprocargs SYSCTL_HANDLER_ARGS;
-#endif /* !CONFIG_EMBEDDED */
STATIC int sysctl_doprocargs2 SYSCTL_HANDLER_ARGS;
STATIC int sysctl_prochandle SYSCTL_HANDLER_ARGS;
-#if DEBUG
-STATIC int sysctl_dodebug SYSCTL_HANDLER_ARGS;
-#endif
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_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);
-#if defined(__i386__) || defined(__x86_64__)
-STATIC int sysctl_sysctl_exec_affinity(struct sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req);
-#endif
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);
la32->fscale = (user32_long_t)la->fscale;
}
-/*
- * sysctl_mem_hold
- *
- * Description: Wire down the callers address map on behalf of sysctl's
- * that perform their own copy operations while holding
- * locks e.g. in the paging path, which could lead to a
- * deadlock, or while holding a spinlock.
- *
- * Parameters: addr User buffer address
- * len User buffer length
- *
- * Returns: 0 Success
- * vslock:ENOMEM Insufficient physical pages to wire
- * vslock:EACCES Bad protection mode
- * vslock:EINVAL Invalid parameters
- *
- * Notes: This code is invoked for the first OID element where the
- * CTLFLAG_LOCKED is not specified for a given OID node
- * element durng OID traversal, and is held for all
- * subsequent node traversals, and only released after the
- * leaf node handler invocation is complete.
- *
- * Legacy: For legacy scyctl's provided by third party code which
- * expect funnel protection for calls into their code, this
- * routine will also take the funnel, which will also only
- * be released after the leaf node handler is complete.
- *
- * This is to support legacy 32 bit BSD KEXTs and legacy 32
- * bit single threaded filesystem KEXTs and similar code
- * which relies on funnel protection, e.g. for things like
- * FSID based sysctl's.
- *
- * NEW CODE SHOULD NOT RELY ON THIS BEHAVIOUR! IT WILL BE
- * REMOVED IN A FUTURE RELASE OF Mac OS X!
- *
- * Bugs: This routine does nothing with the new_addr and new_len
- * at present, but it should, since read from the user space
- * process adddress space which could potentially trigger
- * paging may also be occurring deep down. This is due to
- * a current limitation of the vslock() routine, which will
- * always request a wired mapping be read/write, due to not
- * taking an access mode parameter. Note that this could
- * also cause problems for output on architectures where
- * write access does not require read acccess if the current
- * mapping lacks read access.
- *
- * XXX: To be moved to kern_newsysctl.c to avoid __private_extern__
- */
-int sysctl_mem_lock(user_addr_t old_addr, user_size_t old_len, user_addr_t new_addr, user_size_t new_len);
-int
-sysctl_mem_lock(__unused user_addr_t old_addr, __unused user_size_t old_len, __unused user_addr_t new_addr, __unused user_size_t new_len)
-{
- return 0;
-}
-
-/*
- * Locking and stats
- */
-
-/* sysctl() syscall */
-int
-__sysctl(proc_t p, struct __sysctl_args *uap, __unused int32_t *retval)
-{
- boolean_t funnel_state = FALSE; /* not held if unknown */
- int error;
- size_t savelen = 0, oldlen = 0, newlen;
- int name[CTL_MAXNAME];
- int error1;
- boolean_t vslock_taken = FALSE;
- boolean_t funnel_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;
- }
-
-/*
- * XXX TODO: push down rights check for CTL_HW OIDs; most duplicate
- * XXX it anyway, which is a performance sink, and requires use
- * XXX of SUID root programs (see <rdar://3915692>).
- *
- * Note: Opt out of non-leaf node enforcement by removing this
- * check for the top level OID value, and then adding
- * CTLFLAG_ANYBODY to the leaf nodes in question. Enforce as
- * suser for writed in leaf nodes by omitting this flag.
- * Enforce with a higher granularity by making the leaf node
- * of type SYSCTL_PROC() in order to provide a procedural
- * enforcement call site.
- *
- * NOTE: This function is called prior to any subfunctions being
- * called with a fallback to userland_sysctl(); as such, this
- * permissions check here will veto the fallback operation.
- */
- /* CTL_UNSPEC is used to get oid to AUTO_OID */
- if (uap->new != USER_ADDR_NULL
- && ((name[0] == CTL_HW)
- || (name[0] == CTL_VM))
- && (error = suser(kauth_cred_get(), &p->p_acflag)))
- return (error);
-
-// XXX need to relocate into each terminal instead of leaving this here...
-// XXX macf preemptory check.
-#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,
- 0, /* XXX 1 for CTL_KERN checks */
- uap->new,
- newlen
- );
- kauth_cred_unref(&my_cred);
- if (error)
- return (error);
-#endif
-
- 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 ((name[0] == CTL_VFS || name[0] == CTL_VM)) {
- /*
- * Always take the funnel for CTL_VFS and CTL_VM
- *
- * XXX We should also take it for any OID without the
- * XXX CTLFLAG_LOCKED set on it; fix this later!
- */
- funnel_state = thread_funnel_set(kernel_flock, TRUE);
- funnel_taken = TRUE;
-
- /*
- * XXX Take the vslock() only when we are copying out; this
- * XXX erroneously assumes that the copy in will not cause
- * XXX a fault if caled from the paging path due to the
- * XXX having been recently touched in order to establish
- * XXX the input data. This is a bad assumption.
- *
- * Note: This is overkill, but third parties might
- * already call sysctl internally in KEXTs that
- * implement mass storage drivers. If you are
- * writing a new KEXT, don't do that.
- */
- if(uap->old != USER_ADDR_NULL) {
- if (!useracc(uap->old, (user_size_t)oldlen, B_WRITE)) {
- thread_funnel_set(kernel_flock, funnel_state);
- return (EFAULT);
- }
-
- if (oldlen) {
- if ((error = vslock(uap->old, (user_size_t)oldlen))) {
- thread_funnel_set(kernel_flock, funnel_state);
- return(error);
- }
- savelen = oldlen;
- vslock_taken = TRUE;
- }
- }
- }
-
- /*
- * XXX convert vfs_sysctl subelements to newsysctl; this is hard
- * XXX because of VFS_NUMMNTOPS being top level.
- */
- error = ENOTSUP;
- if (name[0] == CTL_VFS) {
- error = vfs_sysctl(name + 1, uap->namelen - 1, uap->old,
- &oldlen, uap->new, newlen, p);
- }
-
- if (vslock_taken == TRUE) {
- error1 = vsunlock(uap->old, (user_size_t)savelen, B_WRITE);
- if (!error)
- error = error1;
- }
-
- if ( (name[0] != CTL_VFS) && (error == ENOTSUP) ) {
- size_t tmp = oldlen;
- error = userland_sysctl(p, name, uap->namelen, uap->old, &tmp,
- uap->new, newlen, &oldlen);
- }
-
- /*
- * If we took the funnel, which we only do for CTL_VFS and CTL_VM on
- * 32 bit architectures, then drop it.
- *
- * XXX the grabbing and dropping need to move into the leaf nodes,
- * XXX for sysctl's that are not marked CTLFLAG_LOCKED, but this is
- * XXX true for the vslock, as well. We have a start at a routine
- * to wrapper this (above), but it's not turned on. The current code
- * removed the funnel and the vslock() from all but these two top
- * level OIDs. Note that VFS only needs to take the funnel if the FS
- * against which it's operating is not thread safe (but since an FS
- * can be in the paging path, it still needs to take the vslock()).
- */
- if (funnel_taken)
- 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.
*/
-__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
-__private_extern__ int do_count_syscalls;
+extern int do_count_syscalls;
#endif
#ifdef INSECURE
int securelevel;
#endif
-STATIC int
-sysctl_doaffinity 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 = ENOTSUP; /* Default to failure */
-
- proc_t cur_proc = current_proc();
-
- if (namelen < 1)
- return (ENOTSUP);
-
- if (name[0] == 0 && 1 == namelen) {
- error = sysctl_rdint(oldp, oldlenp, newp,
- (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);
- }
- error = 0;
- }
-
- /* adjust index so we return the right required/consumed amount */
- if (!error)
- req->oldidx += req->oldlen;
-
- return (error);
-}
-SYSCTL_PROC(_kern, KERN_AFFINITY, affinity, CTLTYPE_NODE|CTLFLAG_RD | CTLFLAG_LOCKED,
- 0, /* Pointer argument (arg1) */
- 0, /* Integer argument (arg2) */
- sysctl_doaffinity, /* Handler function */
- NULL, /* Data pointer */
- "");
-
-STATIC int
-sysctl_dotranslate 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;
-
- proc_t cur_proc = current_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);
- error = sysctl_rdint(oldp, oldlenp, newp,
- (istranslated != 0) ? 1 : 0);
-
- /* adjust index so we return the right required/consumed amount */
- if (!error)
- req->oldidx += req->oldlen;
-
- return (error);
-}
-/*
- * XXX make CTLFLAG_RW so sysctl_rdint() will EPERM on attempts to write;
- * XXX this may not be necessary.
- */
-SYSCTL_PROC(_kern, KERN_TRANSLATE, translate, CTLTYPE_NODE|CTLFLAG_RW | CTLFLAG_LOCKED,
- 0, /* Pointer argument (arg1) */
- 0, /* Integer argument (arg2) */
- sysctl_dotranslate, /* Handler function */
- NULL, /* Data pointer */
- "");
-
-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, OP_GETATTR, 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 = va.va_fileid;
- return 0;
-}
-
-
-STATIC int
-sysctl_handle_exec_archhandler_ppc(struct sysctl_oid *oidp, void *arg1,
- int arg2, struct sysctl_req *req)
-{
- int error = 0;
-
- if (req->newptr && !kauth_cred_issuser(kauth_cred_get()))
- return (EPERM);
-
- 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
sysctl_handle_kern_threadname( __unused struct sysctl_oid *oidp, __unused void *arg1,
__unused int arg2, struct sysctl_req *req)
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, "");
-
-SYSCTL_NODE(_kern_exec, OID_AUTO, archhandler, CTLFLAG_RD|CTLFLAG_LOCKED, 0, "");
-
-SYSCTL_PROC(_kern_exec_archhandler, OID_AUTO, powerpc,
- CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_LOCKED,
- exec_archhandler_ppc.path,
- sizeof(exec_archhandler_ppc.path),
- sysctl_handle_exec_archhandler_ppc, "A", "");
-
#define BSD_HOST 1
STATIC int
sysctl_sched_stats(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
syscalls_log[i] = 0;
}
}
- }
- if ( tmp != 0 ) {
- do_count_syscalls = 1;
- }
- }
-
- /* adjust index so we return the right required/consumed amount */
- if (!error)
- req->oldidx += req->oldlen;
-
- return (error);
-}
-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 */
-
-#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,
-};
-STATIC int
-sysctl_dodebug SYSCTL_HANDLER_ARGS
-{
- 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;
-
- struct ctldebug *cdp;
-
- /* all sysctl names at this level are name and field */
- if (namelen != 1)
- return (ENOTSUP); /* overloaded */
- if (cmd < 0 || cmd >= CTL_DEBUG_MAXID)
- return (ENOTSUP);
- cdp = debugvars[cmd];
- if (cdp->debugname == 0)
- return (ENOTSUP);
- switch (name[0]) {
- case CTL_DEBUG_NAME:
- error = sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname);
- break;
- case CTL_DEBUG_VALUE:
- error = sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar);
- break;
- default:
- error = ENOTSUP;
- break;
- }
-
- /* adjust index so we return the right required/consumed amount */
- if (!error)
- req->oldidx += req->oldlen;
-
- return (error);
-}
-/*
- * XXX We mark this RW instead of RD to let sysctl_rdstring() return the
- * XXX historical error.
- */
-SYSCTL_PROC(_debug, CTL_DEBUG_NAME, name, CTLTYPE_NODE|CTLFLAG_RW | CTLFLAG_LOCKED,
- 0, /* Pointer argument (arg1) */
- CTL_DEBUG_NAME, /* Integer argument (arg2) */
- sysctl_dodebug, /* Handler function */
- NULL, /* Data pointer */
- "Debugging");
-SYSCTL_PROC(_debug, CTL_DEBUG_VALUE, value, CTLTYPE_NODE|CTLFLAG_RW | CTLFLAG_LOCKED,
- 0, /* Pointer argument (arg1) */
- CTL_DEBUG_VALUE, /* Integer argument (arg2) */
- sysctl_dodebug, /* Handler function */
- NULL, /* Data pointer */
- "Debugging");
-#endif /* DEBUG */
-
-/*
- * The following sysctl_* functions should not be used
- * any more, as they can only cope with callers in
- * user mode: Use new-style
- * sysctl_io_number()
- * sysctl_io_string()
- * sysctl_io_opaque()
- * instead.
- */
-
-/*
- * Validate parameters and get old / set new parameters
- * for an integer-valued sysctl function.
- */
-int
-sysctl_int(user_addr_t oldp, size_t *oldlenp,
- user_addr_t newp, size_t newlen, int *valp)
-{
- int error = 0;
-
- if (oldp != USER_ADDR_NULL && oldlenp == NULL)
- return (EFAULT);
- if (oldp && *oldlenp < sizeof(int))
- return (ENOMEM);
- if (newp && newlen != sizeof(int))
- return (EINVAL);
- *oldlenp = sizeof(int);
- if (oldp)
- error = copyout(valp, oldp, sizeof(int));
- if (error == 0 && newp) {
- error = copyin(newp, valp, sizeof(int));
- AUDIT_ARG(value32, *valp);
- }
- 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.
- */
-int
-sysctl_quad(user_addr_t oldp, size_t *oldlenp,
- user_addr_t newp, size_t newlen, quad_t *valp)
-{
- int error = 0;
-
- if (oldp != USER_ADDR_NULL && oldlenp == NULL)
- return (EFAULT);
- if (oldp && *oldlenp < sizeof(quad_t))
- return (ENOMEM);
- if (newp && newlen != sizeof(quad_t))
- return (EINVAL);
- *oldlenp = sizeof(quad_t);
- if (oldp)
- error = copyout(valp, oldp, sizeof(quad_t));
- if (error == 0 && newp)
- error = copyin(newp, valp, sizeof(quad_t));
- 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);
+ }
+ if ( tmp != 0 ) {
+ do_count_syscalls = 1;
+ }
}
+
+ /* adjust index so we return the right required/consumed amount */
+ if (!error)
+ req->oldidx += req->oldlen;
+
return (error);
}
+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 */
/*
- * As above, but read-only.
+ * The following sysctl_* functions should not be used
+ * any more, as they can only cope with callers in
+ * user mode: Use new-style
+ * sysctl_io_number()
+ * sysctl_io_string()
+ * sysctl_io_opaque()
+ * instead.
*/
-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.
+ * for an integer-valued sysctl function.
*/
int
-sysctl_struct(user_addr_t oldp, size_t *oldlenp,
- user_addr_t newp, size_t newlen, void *sp, int len)
+sysctl_int(user_addr_t oldp, size_t *oldlenp,
+ user_addr_t newp, size_t newlen, int *valp)
{
int error = 0;
if (oldp != USER_ADDR_NULL && oldlenp == NULL)
return (EFAULT);
- if (oldp && (len < 0 || *oldlenp < (size_t)len))
+ if (oldp && *oldlenp < sizeof(int))
return (ENOMEM);
- if (newp && (len < 0 || newlen > (size_t)len))
+ if (newp && newlen != sizeof(int))
return (EINVAL);
- if (oldp) {
- *oldlenp = len;
- error = copyout(sp, oldp, len);
+ *oldlenp = sizeof(int);
+ if (oldp)
+ error = copyout(valp, oldp, sizeof(int));
+ if (error == 0 && newp) {
+ error = copyin(newp, valp, sizeof(int));
+ AUDIT_ARG(value32, *valp);
}
- if (error == 0 && newp)
- error = copyin(newp, sp, len);
return (error);
}
/*
- * Validate parameters and get old parameters
- * for a structure oriented sysctl function.
+ * Validate parameters and get old / set new parameters
+ * for an quad(64bit)-valued sysctl function.
*/
int
-sysctl_rdstruct(user_addr_t oldp, size_t *oldlenp,
- user_addr_t newp, void *sp, int len)
+sysctl_quad(user_addr_t oldp, size_t *oldlenp,
+ user_addr_t newp, size_t newlen, quad_t *valp)
{
int error = 0;
if (oldp != USER_ADDR_NULL && oldlenp == NULL)
return (EFAULT);
- if (oldp && (len < 0 || *oldlenp < (size_t)len))
+ if (oldp && *oldlenp < sizeof(quad_t))
return (ENOMEM);
- if (newp)
- return (EPERM);
- *oldlenp = len;
+ if (newp && newlen != sizeof(quad_t))
+ return (EINVAL);
+ *oldlenp = sizeof(quad_t);
if (oldp)
- error = copyout(sp, oldp, len);
+ error = copyout(valp, oldp, sizeof(quad_t));
+ if (error == 0 && newp)
+ error = copyin(newp, valp, sizeof(quad_t));
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 | CTLFLAG_LOCKED,
- 0, 0, sysctl_file, "S,filehead", "");
-
STATIC int
sysdoproc_filt_KERN_PROC_PID(proc_t p, void * arg)
{
STATIC int
sysdoproc_filt_KERN_PROC_TTY(proc_t p, void * arg)
{
- boolean_t funnel_state;
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) ||
else
retval = 1;
- thread_funnel_set(kernel_flock, funnel_state);
-
return(retval);
}
#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;
- int * errorp;
+ int *errorp;
int uidcheck;
int ruidcheck;
int ttycheck;
};
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->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);
- 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;
- 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;
- return(PROC_RETURNED);
+ return (PROC_RETURNED);
}
SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD | CTLFLAG_LOCKED, 0, "");
size_t needed = 0;
int buflen = where != USER_ADDR_NULL ? req->oldlen : 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;
- caddr_t kprocp;
+ void *kprocp;
int (*filterfn)(proc_t, void *) = 0;
struct sysdoproc_args args;
int uidcheck = 0;
if (namelen != 1 && !(namelen == 0 && cmd == KERN_PROC_ALL))
return (EINVAL);
- is_64_bit = proc_is64bit(current_proc());
if (is_64_bit) {
sizeof_kproc = sizeof(user_kproc);
- kprocp = (caddr_t) &user_kproc;
- }
- else {
+ kprocp = &user_kproc;
+ } else {
sizeof_kproc = sizeof(user32_kproc);
- kprocp = (caddr_t) &user32_kproc;
+ kprocp = &user32_kproc;
}
-
switch (cmd) {
case KERN_PROC_PID:
args.ttycheck = ttycheck;
args.sizeof_kproc = sizeof_kproc;
if (namelen)
- args.uidval = name[0];
+ args.uidval = name[0];
- proc_iterate((PROC_ALLPROCLIST | PROC_ZOMBPROCLIST), sysdoproc_callback, &args, filterfn, name);
+ proc_iterate((PROC_ALLPROCLIST | PROC_ZOMBPROCLIST),
+ sysdoproc_callback, &args, filterfn, name);
if (error)
- return(error);
+ return (error);
dp = args.dp;
needed = args.needed;
req->oldidx += req->oldlen;
return (0);
}
+
/*
* We specify the subcommand code for multiple nodes as the 'req->arg2' value
* in the sysctl declaration itself, which comes into the handler function
/*
- * Fill in an eproc structure for the specified process.
+ * Fill in non-zero fields of an eproc structure for the specified process.
*/
STATIC void
-fill_user32_eproc(proc_t p, struct user32_eproc *ep)
+fill_user32_eproc(proc_t p, struct user32_eproc *__restrict ep)
{
struct tty *tp;
+ struct pgrp *pg;
+ struct session *sessp;
kauth_cred_t my_cred;
- struct pgrp * pg;
- struct session * sessp;
pg = proc_pgrp(p);
sessp = proc_session(p);
- ep->e_paddr = CAST_DOWN_EXPLICIT(uint32_t,p);
-
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;
- if ((sessp != SESSION_NULL) && sessp->s_ttyvp)
+ if (sessp != SESSION_NULL && sessp->s_ttyvp)
ep->e_flag = EPROC_CTTY;
- } else {
- ep->e_sess = 0;
- ep->e_pgid = 0;
- ep->e_jobc = 0;
}
#if CONFIG_LCTX
- if (p->p_lctx) {
+ if (p->p_lctx)
ep->e_lcid = p->p_lctx->lc_id;
- } else {
- ep->e_lcid = 0;
- }
#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);
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);
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));
+ bcopy(posix_cred_get(my_cred)->cr_groups,
+ ep->e_ucred.cr_groups, NGROUPS * sizeof (gid_t));
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;
- ep->e_tsess = CAST_DOWN_EXPLICIT(uint32_t,tp->t_session);
} 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);
- if(pg != PGRP_NULL)
+ }
+ if (pg != PGRP_NULL)
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)
+fill_user64_eproc(proc_t p, struct user64_eproc *__restrict ep)
{
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);
- ep->e_paddr = CAST_USER_ADDR_T(p);
if (pg != PGRP_NULL) {
- ep->e_sess = CAST_USER_ADDR_T(sessp);
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 (p->p_lctx) {
+ if (p->p_lctx)
ep->e_lcid = p->p_lctx->lc_id;
- } else {
- ep->e_lcid = 0;
- }
#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);
ep->e_ucred.cr_ref = my_cred->cr_ref;
ep->e_ucred.cr_uid = kauth_cred_getuid(my_cred);
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));
+ bcopy(posix_cred_get(my_cred)->cr_groups,
+ ep->e_ucred.cr_groups, NGROUPS * sizeof (gid_t));
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;
- ep->e_tsess = CAST_USER_ADDR_T(tp->t_session);
} 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);
+ }
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)
+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_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;
- 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 */
- 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_
- 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
- 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.
*/
STATIC void
-fill_user64_externproc(proc_t p, struct user64_extern_proc *exp)
+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_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;
- 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 */
- 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_
- 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
- 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_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_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 */
+
+ 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 *kp)
+fill_user32_proc(proc_t p, struct user32_kinfo_proc *__restrict kp)
{
- /* on a 64 bit kernel, 32 bit users will get some truncated information */
+ /* 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);
}
STATIC void
-fill_user64_proc(proc_t p, struct user64_kinfo_proc *kp)
+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);
return(ENOTSUP);
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);
case KERN_KDSETRTCDEC:
case KERN_KDSETBUF:
case KERN_KDGETENTROPY:
+ 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:
"");
-#if !CONFIG_EMBEDDED
/*
* 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.
sysctl_doprocargs, /* Handler function */
NULL, /* Data pointer */
"");
-#endif /* !CONFIG_EMBEDDED */
STATIC int
sysctl_doprocargs2 SYSCTL_HANDLER_ARGS
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;
version, 0, "");
SYSCTL_STRING(_kern, OID_AUTO, uuid,
CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
- &kernel_uuid[0], 0, "");
+ &kernel_uuid_string[0], 0, "");
#if DEBUG
int debug_kprint_syscall = 0;
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
0, 0, sysctl_aiothreads, "I", "");
+#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)
CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
&ignore_is_ssd, 0, "");
-SYSCTL_UINT(_kern, OID_AUTO, preheat_pages_max,
+SYSCTL_UINT(_kern, OID_AUTO, preheat_max_bytes,
CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
- &preheat_pages_max, 0, "");
+ &preheat_max_bytes, 0, "");
-SYSCTL_UINT(_kern, OID_AUTO, preheat_pages_min,
+SYSCTL_UINT(_kern, OID_AUTO, preheat_min_bytes,
CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
- &preheat_pages_min, 0, "");
+ &preheat_min_bytes, 0, "");
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, "");
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
}
SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime,
- CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
+ CTLTYPE_STRUCT | CTLFLAG_KERN | CTLFLAG_RD | CTLFLAG_LOCKED,
0, 0, sysctl_boottime, "S,timeval", "");
STATIC int
#endif /* CONFIG_IMGSRC_ACCESS */
-SYSCTL_INT(_kern, OID_AUTO, timer_coalescing_enabled,
- CTLFLAG_RW | CTLFLAG_LOCKED,
+
+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)
(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
#ifdef SECURE_KERNEL
+ (void)req;
return (ENOTSUP);
-#endif
+#else
int new_value, changed;
int error = sysctl_io_number(req, do_coredump, sizeof(int), &new_value, &changed);
if (changed) {
error = EINVAL;
}
return(error);
+#endif
}
SYSCTL_PROC(_kern, KERN_COREDUMP, coredump,
(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
#ifdef SECURE_KERNEL
+ (void)req;
return (ENOTSUP);
-#endif
+#else
int new_value, changed;
int error = sysctl_io_number(req, sugid_coredump, sizeof(int), &new_value, &changed);
if (changed) {
error = EINVAL;
}
return(error);
+#endif
}
SYSCTL_PROC(_kern, KERN_SUGID_COREDUMP, sugid_coredump,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_LOCKED,
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;
+
+ 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)
{
#ifdef SECURE_KERNEL
+ (void)req;
return ENOTSUP;
-#endif
+#else
int new_value, changed;
int error;
nx_enabled = new_value;
}
return(error);
+#endif /* SECURE_KERNEL */
}
CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
0, 0, sysctl_swapusage, "S,xsw_usage", "");
-#if CONFIG_EMBEDDED
-/* <rdar://problem/7688080> */
-boolean_t vm_freeze_enabled = FALSE;
-#endif /* CONFIG_EMBEDDED */
-
-
#if CONFIG_FREEZE
extern void vm_page_reactivate_all_throttled(void);
sysctl_freeze_enabled SYSCTL_HANDLER_ARGS
{
#pragma unused(arg1, arg2)
- int error, val = vm_freeze_enabled ? 1 : 0;
+ 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 (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 freeze is being disabled, we need to move dirty pages out from the throttle to the active queue.
*/
- disabled = (!val && vm_freeze_enabled);
+ disabled = (!val && memorystatus_freeze_enabled);
- vm_freeze_enabled = val ? TRUE : FALSE;
+ memorystatus_freeze_enabled = val ? TRUE : FALSE;
if (disabled) {
vm_page_reactivate_all_throttled();
return (0);
}
-SYSCTL_PROC(_vm, OID_AUTO, freeze_enabled, CTLTYPE_INT|CTLFLAG_RW, &vm_freeze_enabled, 0, sysctl_freeze_enabled, "I", "");
+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() */
CTLFLAG_RD | CTLFLAG_LOCKED,
(int *)NULL, 0, "");
-#if defined(__i386__) || defined(__x86_64__)
-STATIC int
-sysctl_sysctl_exec_affinity(__unused struct sysctl_oid *oidp,
- __unused void *arg1, __unused int arg2,
- struct sysctl_req *req)
-{
- proc_t cur_proc = req->p;
- int 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 (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);
- }
-
- return 0;
-}
-SYSCTL_PROC(_sysctl, OID_AUTO, proc_exec_affinity, CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY | CTLFLAG_LOCKED, 0, 0, sysctl_sysctl_exec_affinity ,"I","proc_exec_affinity");
-#endif
-
STATIC int
fetch_process_cputype(
proc_t cur_proc,
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)
SYSCTL_INT (_kern, OID_AUTO, affinity_sets_mapping,
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.
*
/*
* 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
+
+#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 | CTLFLAG_LOCKED, &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
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
projects / apple / xnu.git / blobdiff