diff options
Diffstat (limited to 'rtl/darwin/sysctlh.inc')
| -rw-r--r-- | rtl/darwin/sysctlh.inc | 541 |
1 files changed, 541 insertions, 0 deletions
diff --git a/rtl/darwin/sysctlh.inc b/rtl/darwin/sysctlh.inc new file mode 100644 index 0000000000..1c94fd934d --- /dev/null +++ b/rtl/darwin/sysctlh.inc @@ -0,0 +1,541 @@ +{ + $Id: sysctlh.inc,v 1.2 2005/02/14 17:13:22 peter Exp $ +} + +{$PACKRECORDS C} + + { + Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. + + @APPLE_LICENSE_HEADER_START@ + + The contents of this file constitute Original Code as defined in and + are subject to the Apple Public Source License Version 1.1 (the + "License"). You may not use this file except in compliance with the + License. Please obtain a copy of the License at + http://www.apple.com/publicsource and read it before using this file. + + This Original Code and all software distributed under the License are + distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + License for the specific language governing rights and limitations + under the License. + + @APPLE_LICENSE_HEADER_END@ + } + { Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved } + { + Copyright (c) 1989, 1993 + The Regents of the University of California. All rights reserved. + + This code is derived from software contributed to Berkeley by + Mike Karels at Berkeley Software Design, Inc. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. All advertising materials mentioning features or use of this software + must display the following acknowledgement: + This product includes software developed by the University of + California, Berkeley and its contributors. + 4. Neither the name of the University nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + @(#)sysctl.h 8.1 (Berkeley) 6/2/93 + } + { + These are for the eproc structure defined below. + } + { + Definitions for sysctl call. The sysctl call uses a hierarchical name + for objects that can be examined or modified. The name is expressed as + a sequence of integers. Like a file path name, the meaning of each + component depends on its place in the hierarchy. The top-level and kern + identifiers are defined here, and other identifiers are defined in the + respective subsystem header files. + } + { largest number of components supported } + + const + CTL_MAXNAME = 12; + { + Each subsystem defined by sysctl defines a list of variables + for that subsystem. Each name is either a node with further + levels defined below it, or it is a leaf of some particular + type given below. Each sysctl level defines a set of name/type + pairs to be used by sysctl(1) in manipulating the subsystem. + } + { subsystem name } + { type of name } + + type + ctlname = record + ctl_name : ^char; + ctl_type : longint; + end; + + { Mask for the type } + + const + CTLTYPE = $f; + { name is a node } + CTLTYPE_NODE = 1; + { name describes an integer } + CTLTYPE_INT = 2; + { name describes a string } + CTLTYPE_STRING = 3; + { name describes a 64-bit number } + CTLTYPE_QUAD = 4; + { name describes a structure } + CTLTYPE_OPAQUE = 5; + { name describes a structure } + CTLTYPE_STRUCT = CTLTYPE_OPAQUE; + { Allow reads of variable } + CTLFLAG_RD = $80000000; + { Allow writes to the variable } + CTLFLAG_WR = $40000000; + CTLFLAG_RW = CTLFLAG_RD or CTLFLAG_WR; + { XXX Don't Lock } + CTLFLAG_NOLOCK = $20000000; + { All users can set this var } + CTLFLAG_ANYBODY = $10000000; + { Permit set only if securelevel<=0 } + CTLFLAG_SECURE = $08000000; + { deprecated variable, do not display } + CTLFLAG_MASKED = $04000000; + { do not auto-register } + CTLFLAG_NOAUTO = $02000000; + { valid inside the kernel } + CTLFLAG_KERN = $01000000; + { + USE THIS instead of a hardwired number from the categories below + to get dynamically assigned sysctl entries using the linker-set + technology. This is the way nearly all new sysctl variables should + be implemented. + e.g. SYSCTL_INT(_parent, OID_AUTO, name, CTLFLAG_RW, &variable, 0, ""); + } + OID_AUTO = -(1); + { + Top-level identifiers + } + { unused } + CTL_UNSPEC = 0; + { "high kernel": proc, limits } + CTL_KERN = 1; + { virtual memory } + CTL_VM = 2; + { file system, mount type is next } + CTL_VFS = 3; + { network, see socket.h } + CTL_NET = 4; + { debugging parameters } + CTL_DEBUG = 5; + { generic cpu/io } + CTL_HW = 6; + { machine dependent } + CTL_MACHDEP = 7; + { user-level } + CTL_USER = 8; + { number of valid top-level ids } + CTL_MAXID = 9; + { + CTL_KERN identifiers + } + { string: system version } + KERN_OSTYPE = 1; + { string: system release } + KERN_OSRELEASE = 2; + { int: system revision } + KERN_OSREV = 3; + { string: compile time info } + KERN_VERSION = 4; + { int: max vnodes } + KERN_MAXVNODES = 5; + { int: max processes } + KERN_MAXPROC = 6; + { int: max open files } + KERN_MAXFILES = 7; + { int: max arguments to exec } + KERN_ARGMAX = 8; + { int: system security level } + KERN_SECURELVL = 9; + { string: hostname } + KERN_HOSTNAME = 10; + { int: host identifier } + KERN_HOSTID = 11; + { struct: struct clockrate } + KERN_CLOCKRATE = 12; + { struct: vnode structures } + KERN_VNODE = 13; + { struct: process entries } + KERN_PROC = 14; + { struct: file entries } + KERN_FILE = 15; + { node: kernel profiling info } + KERN_PROF = 16; + { int: POSIX.1 version } + KERN_POSIX1 = 17; + { int: # of supplemental group ids } + KERN_NGROUPS = 18; + { int: is job control available } + KERN_JOB_CONTROL = 19; + { int: saved set-user/group-ID } + KERN_SAVED_IDS = 20; + { struct: time kernel was booted } + KERN_BOOTTIME = 21; + { string: YP domain name } + KERN_NISDOMAINNAME = 22; + KERN_DOMAINNAME = KERN_NISDOMAINNAME; + { int: number of partitions/disk } + KERN_MAXPARTITIONS = 23; + { int: kernel trace points } + KERN_KDEBUG = 24; + { int: update process sleep time } + KERN_UPDATEINTERVAL = 25; + { int: OS release date } + KERN_OSRELDATE = 26; + { node: NTP PLL control } + KERN_NTP_PLL = 27; + { string: name of booted kernel } + KERN_BOOTFILE = 28; + { int: max open files per proc } + KERN_MAXFILESPERPROC = 29; + { int: max processes per uid } + KERN_MAXPROCPERUID = 30; + { dev_t: device to dump on } + KERN_DUMPDEV = 31; + { node: anything related to IPC } + KERN_IPC = 32; + { unused } + KERN_DUMMY = 33; + { int: address of PS_STRINGS } + KERN_PS_STRINGS = 34; + { int: address of USRSTACK } + KERN_USRSTACK = 35; + { int: do we log sigexit procs? } + KERN_LOGSIGEXIT = 36; + { string: kernel symbol filename } + KERN_SYMFILE = 37; + KERN_PROCARGS = 38; + { node: pc sampling } + KERN_PCSAMPLES = 39; + { int: are we netbooted? 1=yes,0=no } + KERN_NETBOOT = 40; + { node: panic UI information } + KERN_PANICINFO = 41; + { node: panic UI information } + KERN_SYSV = 42; + { xxx } + KERN_AFFINITY = 43; + { xxx } + KERN_CLASSIC = 44; + { xxx } + KERN_CLASSICHANDLER = 45; + { int: max aio requests } + KERN_AIOMAX = 46; + { int: max aio requests per process } + KERN_AIOPROCMAX = 47; + { int: max aio worker threads } + KERN_AIOTHREADS = 48; + { __APPLE_API_UNSTABLE } + { number of valid kern ids } + + const + KERN_MAXID = 50; + { KERN_KDEBUG types } + KERN_KDEFLAGS = 1; + KERN_KDDFLAGS = 2; + KERN_KDENABLE = 3; + KERN_KDSETBUF = 4; + KERN_KDGETBUF = 5; + KERN_KDSETUP = 6; + KERN_KDREMOVE = 7; + KERN_KDSETREG = 8; + KERN_KDGETREG = 9; + KERN_KDREADTR = 10; + KERN_KDPIDTR = 11; + KERN_KDTHRMAP = 12; + { Don't use 13 as it is overloaded with KERN_VNODE } + KERN_KDPIDEX = 14; + KERN_KDSETRTCDEC = 15; + KERN_KDGETENTROPY = 16; + { KERN_PCSAMPLES types } + KERN_PCDISABLE = 1; + KERN_PCSETBUF = 2; + KERN_PCGETBUF = 3; + KERN_PCSETUP = 4; + KERN_PCREMOVE = 5; + KERN_PCREADBUF = 6; + KERN_PCSETREG = 7; + KERN_PCCOMM = 8; + { KERN_PANICINFO types } + { quad: panic UI image size limit } + KERN_PANICINFO_MAXSIZE = 1; + { string: path to the panic UI (16 bit) } + KERN_PANICINFO_IMAGE16 = 2; + { string: path to the panic UI (32 bit) } + KERN_PANICINFO_IMAGE32 = 3; + { + KERN_SYSV identifiers + } + { int: max shared memory segment size (bytes) } + KSYSV_SHMMAX = 1; + { int: min shared memory segment size (bytes) } + KSYSV_SHMMIN = 2; + { int: max number of shared memory identifiers } + KSYSV_SHMMNI = 3; + { int: max shared memory segments per process } + KSYSV_SHMSEG = 4; + { int: max amount of shared memory (pages) } + KSYSV_SHMALL = 5; + { int: max num of semaphore identifiers } + KSYSV_SEMMNI = 6; + { int: max num of semaphores in system } + KSYSV_SEMMNS = 7; + { int: max num of undo structures in system } + KSYSV_SEMMNU = 8; + { int: max num of semaphores per id } + KSYSV_SEMMSL = 9; + { int: max num of undo entries per process } + KSYSV_SEMUNE = 10; + error1 = 1; + { + KERN_PROC subtypes + } + { everything } + KERN_PROC_ALL = 0; + { by process id } + KERN_PROC_PID = 1; + { by process group id } + KERN_PROC_PGRP = 2; + { by session of pid } + KERN_PROC_SESSION = 3; + { by controlling tty } + KERN_PROC_TTY = 4; + { by effective uid } + KERN_PROC_UID = 5; + { by real uid } + KERN_PROC_RUID = 6; + { + KERN_PROC subtype ops return arrays of augmented proc structures: + } + { + KERN_IPC identifiers + } + { int: max size of a socket buffer } + + const + KIPC_MAXSOCKBUF = 1; + { int: wastage factor in sockbuf } + KIPC_SOCKBUF_WASTE = 2; + { int: max length of connection q } + KIPC_SOMAXCONN = 3; + { int: max length of link header } + KIPC_MAX_LINKHDR = 4; + { int: max length of network header } + KIPC_MAX_PROTOHDR = 5; + { int: max total length of headers } + KIPC_MAX_HDR = 6; + { int: max length of data? } + KIPC_MAX_DATALEN = 7; + { struct: mbuf usage statistics } + KIPC_MBSTAT = 8; + { int: maximum mbuf clusters } + KIPC_NMBCLUSTERS = 9; + { + CTL_VM identifiers + } + { struct vmmeter } + VM_METER = 1; + { struct loadavg } + VM_LOADAVG = 2; + { number of valid vm ids } + VM_MAXID = 3; + { struct loadavg with mach factor } + VM_MACHFACTOR = 4; + { + CTL_HW identifiers + } + { string: machine class } + HW_MACHINE = 1; + { string: specific machine model } + HW_MODEL = 2; + { int: number of cpus } + HW_NCPU = 3; + { int: machine byte order } + HW_BYTEORDER = 4; + { int: total memory } + HW_PHYSMEM = 5; + { int: non-kernel memory } + HW_USERMEM = 6; + { int: software page size } + HW_PAGESIZE = 7; + { strings: disk drive names } + HW_DISKNAMES = 8; + { struct: diskstats[] } + HW_DISKSTATS = 9; + { int: 0 for Legacy, else NewWorld } + HW_EPOCH = 10; + { int: has HW floating point? } + HW_FLOATINGPT = 11; + { string: machine architecture } + HW_MACHINE_ARCH = 12; + { int: has HW vector unit? } + HW_VECTORUNIT = 13; + { int: Bus Frequency } + HW_BUS_FREQ = 14; + { int: CPU Frequency } + HW_CPU_FREQ = 15; + { int: Cache Line Size in Bytes } + HW_CACHELINE = 16; + { int: L1 I Cache Size in Bytes } + HW_L1ICACHESIZE = 17; + { int: L1 D Cache Size in Bytes } + HW_L1DCACHESIZE = 18; + { int: L2 Cache Settings } + HW_L2SETTINGS = 19; + { int: L2 Cache Size in Bytes } + HW_L2CACHESIZE = 20; + { int: L3 Cache Settings } + HW_L3SETTINGS = 21; + { int: L3 Cache Size in Bytes } + HW_L3CACHESIZE = 22; + { int: Bus Frequency } + HW_TB_FREQ = 23; + { uint64_t: physical ram size } + HW_MEMSIZE = 24; + { int: number of available CPUs } + HW_AVAILCPU = 25; + { number of valid hw ids } + HW_MAXID = 26; + + { + These are the support HW selectors for sysctlbyname. Parameters that are byte count or frequencies are 64 bit numbers. + All other parameters are 32 bit numbers. + + hw.memsize - The number of bytes of physical memory in the system. + + hw.ncpu - The number maximum number of processor that could be available this boot. + Use this value for sizing of static per processor arrays; i.e. processor load statistics. + + hw.activecpu - The number of cpus currently available for executing threads. + Use this number to determine the number threads to create in SMP aware applications. + This number can change when power management modes are changed. + + hw.tbfrequency - This gives the time base frequency used by the OS and is the basis of all timing services. + In general is is better to use mach's or higher level timing services, but this value + is needed to convert the PPC Time Base registers to real time. + + hw.cpufrequency - These values provide the current, min and max cpu frequency. The min and max are for + hw.cpufrequency_max - all power management modes. The current frequency is the max frequency in the current mode. + hw.cpufrequency_min - All frequencies are in Hz. + + hw.busfrequency - These values provide the current, min and max bus frequency. The min and max are for + hw.busfrequency_max - all power management modes. The current frequency is the max frequency in the current mode. + hw.busfrequency_min - All frequencies are in Hz. + + hw.cputype - These values provide the mach-o cpu type and subtype. A complete list is in <mach/machine.h> + hw.cpusubtype - These values should be used to determine what processor family the running cpu is from so that + the best binary can be chosen, or the best dynamic code generated. They should not be used + to determine if a given processor feature is available. + + hw.byteorder - Gives the byte order of the processor. 4321 for big endian, 1234 for little. + + hw.pagesize - Gives the size in bytes of the pages used by the processor and VM system. + + hw.cachelinesize - Gives the size in bytes of the processor's cache lines. + This value should be use to control the strides of loops that use cache control instructions + like dcbz, dcbt or dcbst. + + hw.l1dcachesize - These values provide the size in bytes of the L1, L2 and L3 caches. If a cache is not present + hw.l1icachesize - then the selector will return and error. + hw.l2cachesize - + hw.l3cachesize - + + + These are the selectors for optional processor features. Selectors that return errors are not support on the system. + Supported features will return 1 if they are recommended or 0 if they are supported but are not expected to help performance. + Future versions of these selectors may return larger values as necessary so it is best to test for non zero. + + hw.optional.floatingpoint - Floating Point Instructions + hw.optional.altivec - AltiVec Instructions + hw.optional.graphicsops - Graphics Operations + hw.optional.64bitops - 64-bit Instructions + hw.optional.fsqrt - HW Floating Point Square Root Instruction + hw.optional.stfiwx - Store Floating Point as Integer Word Indexed Instructions + hw.optional.dcba - Data Cache Block Allocate Instruction + hw.optional.datastreams - Data Streams Instructions + hw.optional.dcbtstreams - Data Cache Block Touch Steams Instruction Form + + } + { + CTL_USER definitions + } + { string: _CS_PATH } + { int: BC_BASE_MAX } + USER_BC_BASE_MAX = 2; + { int: BC_DIM_MAX } + USER_BC_DIM_MAX = 3; + { int: BC_SCALE_MAX } + USER_BC_SCALE_MAX = 4; + { int: BC_STRING_MAX } + USER_BC_STRING_MAX = 5; + { int: COLL_WEIGHTS_MAX } + USER_COLL_WEIGHTS_MAX = 6; + { int: EXPR_NEST_MAX } + USER_EXPR_NEST_MAX = 7; + { int: LINE_MAX } + USER_LINE_MAX = 8; + { int: RE_DUP_MAX } + USER_RE_DUP_MAX = 9; + { int: POSIX2_VERSION } + USER_POSIX2_VERSION = 10; + { int: POSIX2_C_BIND } + USER_POSIX2_C_BIND = 11; + { int: POSIX2_C_DEV } + USER_POSIX2_C_DEV = 12; + { int: POSIX2_CHAR_TERM } + USER_POSIX2_CHAR_TERM = 13; + { int: POSIX2_FORT_DEV } + USER_POSIX2_FORT_DEV = 14; + { int: POSIX2_FORT_RUN } + USER_POSIX2_FORT_RUN = 15; + { int: POSIX2_LOCALEDEF } + USER_POSIX2_LOCALEDEF = 16; + { int: POSIX2_SW_DEV } + USER_POSIX2_SW_DEV = 17; + { int: POSIX2_UPE } + USER_POSIX2_UPE = 18; + { int: POSIX2_STREAM_MAX } + USER_STREAM_MAX = 19; + { int: POSIX2_TZNAME_MAX } + USER_TZNAME_MAX = 20; + { number of valid user ids } + USER_MAXID = 21; + +{ + $Log: sysctlh.inc,v $ + Revision 1.2 2005/02/14 17:13:22 peter + * truncate log + +} |