kern_mib.c revision 106605
162642Sn_hibma/*- 262642Sn_hibma * Copyright (c) 1982, 1986, 1989, 1993 362642Sn_hibma * The Regents of the University of California. All rights reserved. 462642Sn_hibma * 562642Sn_hibma * This code is derived from software contributed to Berkeley by 662642Sn_hibma * Mike Karels at Berkeley Software Design, Inc. 762642Sn_hibma * 862642Sn_hibma * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD 962642Sn_hibma * project, to make these variables more userfriendly. 1062642Sn_hibma * 1162642Sn_hibma * Redistribution and use in source and binary forms, with or without 1262642Sn_hibma * modification, are permitted provided that the following conditions 1362642Sn_hibma * are met: 1462642Sn_hibma * 1. Redistributions of source code must retain the above copyright 1562642Sn_hibma * notice, this list of conditions and the following disclaimer. 1662642Sn_hibma * 2. Redistributions in binary form must reproduce the above copyright 1762642Sn_hibma * notice, this list of conditions and the following disclaimer in the 1862642Sn_hibma * documentation and/or other materials provided with the distribution. 1962642Sn_hibma * 3. All advertising materials mentioning features or use of this software 2062642Sn_hibma * must display the following acknowledgement: 2162642Sn_hibma * This product includes software developed by the University of 2262642Sn_hibma * California, Berkeley and its contributors. 2362642Sn_hibma * 4. Neither the name of the University nor the names of its contributors 2462642Sn_hibma * may be used to endorse or promote products derived from this software 2562642Sn_hibma * without specific prior written permission. 2662642Sn_hibma * 2762642Sn_hibma * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 2862642Sn_hibma * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2962642Sn_hibma * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 3062642Sn_hibma * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 3162642Sn_hibma * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 3262642Sn_hibma * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 3362642Sn_hibma * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 3462642Sn_hibma * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 3562642Sn_hibma * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 3662642Sn_hibma * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3762642Sn_hibma * SUCH DAMAGE. 3862642Sn_hibma * 3962642Sn_hibma * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94 4062642Sn_hibma * $FreeBSD: head/sys/kern/kern_mib.c 106605 2002-11-07 23:57:17Z tmm $ 4162642Sn_hibma */ 42113273Smdodd 43188945Sthompsa#include "opt_posix.h" 4462642Sn_hibma 45225839Smav#include <sys/param.h> 46225839Smav#include <sys/kernel.h> 47225839Smav#include <sys/systm.h> 48225839Smav#include <sys/sysctl.h> 49225839Smav#include <sys/proc.h> 50225839Smav#include <sys/lock.h> 51225839Smav#include <sys/mutex.h> 52225839Smav#include <sys/jail.h> 5362642Sn_hibma#include <sys/smp.h> 5462642Sn_hibma#include <sys/unistd.h> 55164531Sgrog 56225839SmavSYSCTL_NODE(, 0, sysctl, CTLFLAG_RW, 0, 57225839Smav "Sysctl internal magic"); 5862642Sn_hibmaSYSCTL_NODE(, CTL_KERN, kern, CTLFLAG_RW, 0, 59225839Smav "High kernel, proc, limits &c"); 60225839SmavSYSCTL_NODE(, CTL_VM, vm, CTLFLAG_RW, 0, 61225839Smav "Virtual memory"); 62225839SmavSYSCTL_NODE(, CTL_VFS, vfs, CTLFLAG_RW, 0, 63225839Smav "File system"); 64225839SmavSYSCTL_NODE(, CTL_NET, net, CTLFLAG_RW, 0, 6562642Sn_hibma "Network, (see socket.h)"); 66225839SmavSYSCTL_NODE(, CTL_DEBUG, debug, CTLFLAG_RW, 0, 67225839Smav "Debugging"); 6862642Sn_hibmaSYSCTL_NODE(_debug, OID_AUTO, sizeof, CTLFLAG_RW, 0, 69225839Smav "Sizeof various things"); 70225839SmavSYSCTL_NODE(, CTL_HW, hw, CTLFLAG_RW, 0, 71225839Smav "hardware"); 72225839SmavSYSCTL_NODE(, CTL_MACHDEP, machdep, CTLFLAG_RW, 0, 73225839Smav "machine dependent"); 74225839SmavSYSCTL_NODE(, CTL_USER, user, CTLFLAG_RW, 0, 7562642Sn_hibma "user-level"); 76225839SmavSYSCTL_NODE(, CTL_P1003_1B, p1003_1b, CTLFLAG_RW, 0, 77225839Smav "p1003_1b, (see p1003_1b.h)"); 78225839Smav 79225839SmavSYSCTL_NODE(, OID_AUTO, compat, CTLFLAG_RW, 0, 80225839Smav "Compatibility code"); 81225839SmavSYSCTL_NODE(, OID_AUTO, security, CTLFLAG_RW, 0, 82225839Smav "Security"); 83225839Smav#ifdef REGRESSION 84225839SmavSYSCTL_NODE(, OID_AUTO, regression, CTLFLAG_RW, 0, 85225839Smav "Regression test MIB"); 86225839Smav#endif 87225839Smav 88225839SmavSYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD, 89225839Smav osrelease, 0, "Operating system release"); 90225839Smav 91225839SmavSYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD, 92225839Smav 0, BSD, "Operating system revision"); 93225839Smav 94225839SmavSYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD, 95225839Smav version, 0, "Kernel version"); 96225839Smav 97225839SmavSYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD, 98225839Smav ostype, 0, "Operating system type"); 99225839Smav 100225839Smavextern int osreldate; 101225839SmavSYSCTL_INT(_kern, KERN_OSRELDATE, osreldate, CTLFLAG_RD, 102225839Smav &osreldate, 0, "Operating system release date"); 103225839Smav 104225839SmavSYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RD, 105225839Smav &maxproc, 0, "Maximum number of processes"); 106225839Smav 107225839SmavSYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid, CTLFLAG_RW, 108225839Smav &maxprocperuid, 0, "Maximum processes allowed per userid"); 109225839Smav 110225839SmavSYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RD, 111225839Smav &maxusers, 0, "Hint for kernel tuning"); 112225839Smav 113225839SmavSYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD, 114225839Smav 0, ARG_MAX, "Maximum bytes of argument to execve(2)"); 115225839Smav 116225839SmavSYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD, 117225839Smav 0, _POSIX_VERSION, "Version of POSIX attempting to comply to"); 118225839Smav 119225839SmavSYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RD, 120225839Smav 0, NGROUPS_MAX, "Maximum number of groups a user can belong to"); 121225839Smav 122225839SmavSYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD, 123225839Smav 0, 1, "Whether job control is available"); 124225839Smav 125225839Smav#ifdef _POSIX_SAVED_IDS 126225839SmavSYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD, 127225839Smav 0, 1, "Whether saved set-group/user ID is available"); 128225839Smav#else 129225839SmavSYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD, 130225839Smav 0, 0, "Whether saved set-group/user ID is available"); 131225839Smav#endif 13262642Sn_hibma 133225839Smavchar kernelname[MAXPATHLEN] = "/kernel"; /* XXX bloat */ 134225839Smav 135225839SmavSYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile, CTLFLAG_RW, 136225839Smav kernelname, sizeof kernelname, "Name of kernel file booted"); 137225839Smav 138225839Smav#ifdef SMP 139225839SmavSYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD, 140225839Smav &mp_ncpus, 0, "Number of active CPUs"); 141225839Smav#else 142225839SmavSYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD, 143225839Smav 0, 1, "Number of active CPUs"); 144225839Smav#endif 145225839Smav 146225839SmavSYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD, 147225839Smav 0, BYTE_ORDER, "System byte order"); 148225839Smav 149225839SmavSYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD, 150225839Smav 0, PAGE_SIZE, "System memory page size"); 151225839Smav 152225839Smavstatic int 153225839Smavsysctl_hw_physmem(SYSCTL_HANDLER_ARGS) 154225839Smav{ 155225839Smav u_long val; 156225839Smav 157225839Smav val = ctob(physmem); 158225839Smav return (sysctl_handle_long(oidp, &val, 0, req)); 159225839Smav} 160225839Smav 161225839SmavSYSCTL_PROC(_hw, HW_PHYSMEM, physmem, CTLTYPE_ULONG | CTLFLAG_RD, 162225839Smav 0, 0, sysctl_hw_physmem, "LU", ""); 163225839Smav 164225839Smavstatic int 165225839Smavsysctl_hw_usermem(SYSCTL_HANDLER_ARGS) 166225839Smav{ 167225839Smav u_long val; 168225839Smav 169225839Smav val = ctob(physmem - cnt.v_wire_count); 170225839Smav return (sysctl_handle_long(oidp, &val, 0, req)); 171225839Smav} 172225839Smav 173225839SmavSYSCTL_PROC(_hw, HW_USERMEM, usermem, CTLTYPE_ULONG | CTLFLAG_RD, 174225839Smav 0, 0, sysctl_hw_usermem, "LU", ""); 175225839Smav 176225839SmavSYSCTL_ULONG(_hw, OID_AUTO, availpages, CTLFLAG_RD, &physmem, 0, ""); 17762642Sn_hibma 17862642Sn_hibmastatic char machine_arch[] = MACHINE_ARCH; 179225839SmavSYSCTL_STRING(_hw, HW_MACHINE_ARCH, machine_arch, CTLFLAG_RD, 18062642Sn_hibma machine_arch, 0, "System architecture"); 18162642Sn_hibma 18262642Sn_hibmachar hostname[MAXHOSTNAMELEN]; 183164531Sgrog 184164531Sgrogstatic int 185164544Sgrogsysctl_hostname(SYSCTL_HANDLER_ARGS) 186194789Sdelphij{ 187164531Sgrog struct prison *pr; 188164531Sgrog char tmphostname[MAXHOSTNAMELEN]; 189164544Sgrog int error; 190194789Sdelphij 191225839Smav pr = req->td->td_ucred->cr_prison; 192225839Smav if (pr != NULL) { 193225839Smav if (!jail_set_hostname_allowed && req->newptr) 194225839Smav return (EPERM); 19562642Sn_hibma /* 19662642Sn_hibma * Process is in jail, so make a local copy of jail 19762642Sn_hibma * hostname to get/set so we don't have to hold the jail 198225839Smav * mutex during the sysctl copyin/copyout activities. 19987699Smarkm */ 20062642Sn_hibma mtx_lock(&pr->pr_mtx); 20162642Sn_hibma bcopy(pr->pr_host, tmphostname, MAXHOSTNAMELEN); 20262642Sn_hibma mtx_unlock(&pr->pr_mtx); 203224511Smav 204224511Smav error = sysctl_handle_string(oidp, tmphostname, 205164531Sgrog sizeof pr->pr_host, req); 20662642Sn_hibma 207224511Smav if (req->newptr != NULL && error == 0) { 208224511Smav /* 20962642Sn_hibma * Copy the locally set hostname to the jail, if 21062642Sn_hibma * appropriate. 21162642Sn_hibma */ 21262642Sn_hibma mtx_lock(&pr->pr_mtx); 21362642Sn_hibma bcopy(tmphostname, pr->pr_host, MAXHOSTNAMELEN); 21462642Sn_hibma mtx_unlock(&pr->pr_mtx); 21562642Sn_hibma } 21662642Sn_hibma } else 21762642Sn_hibma error = sysctl_handle_string(oidp, 21862642Sn_hibma hostname, sizeof hostname, req); 219224511Smav return (error); 220224511Smav} 221224511Smav 222224511SmavSYSCTL_PROC(_kern, KERN_HOSTNAME, hostname, 223224511Smav CTLTYPE_STRING|CTLFLAG_RW|CTLFLAG_PRISON, 224224511Smav 0, 0, sysctl_hostname, "A", "Hostname"); 225224511Smav 226224511Smavstatic int regression_securelevel_nonmonotonic = 0; 227224511Smav 228224511Smav#ifdef REGRESSION 229224511SmavSYSCTL_INT(_regression, OID_AUTO, securelevel_nonmonotonic, CTLFLAG_RW, 230224511Smav ®ression_securelevel_nonmonotonic, 0, "securelevel may be lowered"); 231224511Smav#endif 232224511Smav 233224511Smavint securelevel = -1; 234224511Smavstruct mtx securelevel_mtx; 235224511Smav 236224511SmavMTX_SYSINIT(securelevel_lock, &securelevel_mtx, "securelevel mutex lock", 237225839Smav MTX_DEF); 23862642Sn_hibma 23962642Sn_hibmastatic int 24062642Sn_hibmasysctl_kern_securelvl(SYSCTL_HANDLER_ARGS) 24162642Sn_hibma{ 24267256Sn_hibma struct prison *pr; 24362642Sn_hibma int error, level; 244224511Smav 24562642Sn_hibma pr = req->td->td_ucred->cr_prison; 24662642Sn_hibma 247224511Smav /* 248224511Smav * If the process is in jail, return the maximum of the global and 249164531Sgrog * local levels; otherwise, return the global level. 25062642Sn_hibma */ 25162642Sn_hibma if (pr != NULL) { 25262642Sn_hibma mtx_lock(&pr->pr_mtx); 25362642Sn_hibma level = imax(securelevel, pr->pr_securelevel); 25462642Sn_hibma mtx_unlock(&pr->pr_mtx); 25562642Sn_hibma } else 25662642Sn_hibma level = securelevel; 25762642Sn_hibma error = sysctl_handle_int(oidp, &level, 0, req); 25862642Sn_hibma if (error || !req->newptr) 25962642Sn_hibma return (error); 26062642Sn_hibma /* 26162642Sn_hibma * Permit update only if the new securelevel exceeds the 26262642Sn_hibma * global level, and local level if any. 26362642Sn_hibma */ 26462642Sn_hibma if (pr != NULL) { 26562642Sn_hibma mtx_lock(&pr->pr_mtx); 26662642Sn_hibma if (!regression_securelevel_nonmonotonic && 267224511Smav (level < imax(securelevel, pr->pr_securelevel))) { 26875606Sn_hibma mtx_unlock(&pr->pr_mtx); 26962642Sn_hibma return (EPERM); 270224511Smav } 27167256Sn_hibma pr->pr_securelevel = level; 27267256Sn_hibma mtx_unlock(&pr->pr_mtx); 273224511Smav } else { 27467256Sn_hibma mtx_lock(&securelevel_mtx); 27562642Sn_hibma if (!regression_securelevel_nonmonotonic && 27662642Sn_hibma (level < securelevel)) { 277225839Smav mtx_unlock(&securelevel_mtx); 27862642Sn_hibma return (EPERM); 27962642Sn_hibma } 28062642Sn_hibma securelevel = level; 28162642Sn_hibma mtx_unlock(&securelevel_mtx); 28262642Sn_hibma } 28362642Sn_hibma return (error); 28462642Sn_hibma} 28562642Sn_hibma 286224511SmavSYSCTL_PROC(_kern, KERN_SECURELVL, securelevel, 287224511Smav CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0, sysctl_kern_securelvl, 28862642Sn_hibma "I", "Current secure level"); 28962642Sn_hibma 29062642Sn_hibmachar domainname[MAXHOSTNAMELEN]; 29162642Sn_hibmaSYSCTL_STRING(_kern, KERN_NISDOMAINNAME, domainname, CTLFLAG_RW, 292164531Sgrog &domainname, sizeof(domainname), "Name of the current YP/NIS domain"); 293164531Sgrog 294224511Smavu_long hostid; 29562642Sn_hibmaSYSCTL_ULONG(_kern, KERN_HOSTID, hostid, CTLFLAG_RW, &hostid, 0, "Host ID"); 296224511Smav 29762642Sn_hibma/* 29862642Sn_hibma * This is really cheating. These actually live in the libc, something 299225839Smav * which I'm not quite sure is a good idea anyway, but in order for 30062642Sn_hibma * getnext and friends to actually work, we define dummies here. 30162642Sn_hibma */ 302225839SmavSYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RD, 303225839Smav "", 0, "PATH that finds all the standard utilities"); 30462642Sn_hibmaSYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RD, 305225839Smav 0, 0, "Max ibase/obase values in bc(1)"); 30662642Sn_hibmaSYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RD, 307225839Smav 0, 0, "Max array size in bc(1)"); 308225839SmavSYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RD, 309225839Smav 0, 0, "Max scale value in bc(1)"); 310225839SmavSYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RD, 311225839Smav 0, 0, "Max string length in bc(1)"); 312225839SmavSYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RD, 313225839Smav 0, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry"); 314225839SmavSYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RD, 0, 0, ""); 315225839SmavSYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RD, 316225839Smav 0, 0, "Max length (bytes) of a text-processing utility's input line"); 317225839SmavSYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RD, 318225839Smav 0, 0, "Maximum number of repeats of a regexp permitted"); 319225839SmavSYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RD, 320225839Smav 0, 0, 321225839Smav "The version of POSIX 1003.2 with which the system attempts to comply"); 322225839SmavSYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RD, 323225839Smav 0, 0, "Whether C development supports the C bindings option"); 324225839SmavSYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RD, 325225839Smav 0, 0, "Whether system supports the C development utilities option"); 326225839SmavSYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RD, 327225839Smav 0, 0, ""); 32862642Sn_hibmaSYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RD, 329225839Smav 0, 0, "Whether system supports FORTRAN development utilities"); 330225839SmavSYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RD, 331225839Smav 0, 0, "Whether system supports FORTRAN runtime utilities"); 332225839SmavSYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RD, 333225839Smav 0, 0, "Whether system supports creation of locales"); 334225839SmavSYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RD, 335225839Smav 0, 0, "Whether system supports software development utilities"); 336225839SmavSYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RD, 337225839Smav 0, 0, "Whether system supports the user portability utilities"); 338225839SmavSYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RD, 339225839Smav 0, 0, "Min Maximum number of streams a process may have open at one time"); 340225839SmavSYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RD, 341225839Smav 0, 0, "Min Maximum number of types supported for timezone names"); 342225839Smav 343225839Smav#include <sys/vnode.h> 34462642Sn_hibmaSYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD, 345225839Smav 0, sizeof(struct vnode), "sizeof(struct vnode)"); 346225839Smav 347225839SmavSYSCTL_INT(_debug_sizeof, OID_AUTO, proc, CTLFLAG_RD, 348225839Smav 0, sizeof(struct proc), "sizeof(struct proc)"); 349225839Smav 350225839Smav#include <sys/conf.h> 351225839SmavSYSCTL_INT(_debug_sizeof, OID_AUTO, cdev, CTLFLAG_RD, 352225839Smav 0, sizeof(struct cdev), "sizeof(struct cdev)"); 353225839Smav 354225839Smav#include <sys/bio.h> 35562642Sn_hibma#include <sys/buf.h> 356225839SmavSYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD, 357225839Smav 0, sizeof(struct bio), "sizeof(struct bio)"); 358225839SmavSYSCTL_INT(_debug_sizeof, OID_AUTO, buf, CTLFLAG_RD, 359224511Smav 0, sizeof(struct buf), "sizeof(struct buf)"); 360225839Smav 361225839Smav#include <sys/user.h> 362225839SmavSYSCTL_INT(_debug_sizeof, OID_AUTO, kinfo_proc, CTLFLAG_RD, 363225839Smav 0, sizeof(struct kinfo_proc), "sizeof(struct kinfo_proc)"); 364225839Smav