| 1 | /*- |
| 2 | * Copyright (c) 1982, 1986, 1989, 1993 |
| 3 | * The Regents of the University of California. All rights reserved. |
| 4 | * |
| 5 | * This code is derived from software contributed to Berkeley by |
| 6 | * Mike Karels at Berkeley Software Design, Inc. |
| 7 | * |
| 8 | * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD |
| 9 | * project, to make these variables more userfriendly. |
| 10 | * |
| 11 | * Redistribution and use in source and binary forms, with or without |
| 12 | * modification, are permitted provided that the following conditions |
| 13 | * are met: |
| 14 | * 1. Redistributions of source code must retain the above copyright |
| 15 | * notice, this list of conditions and the following disclaimer. |
| 16 | * 2. Redistributions in binary form must reproduce the above copyright |
| 17 | * notice, this list of conditions and the following disclaimer in the |
| 18 | * documentation and/or other materials provided with the distribution. |
| 19 | * 3. All advertising materials mentioning features or use of this software |
| 20 | * must display the following acknowledgement: |
| 21 | * This product includes software developed by the University of |
| 22 | * California, Berkeley and its contributors. |
| 23 | * 4. Neither the name of the University nor the names of its contributors |
| 24 | * may be used to endorse or promote products derived from this software |
| 25 | * without specific prior written permission. |
| 26 | * |
| 27 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 28 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 29 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 30 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 31 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 32 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 33 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 34 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 35 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 36 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 37 | * SUCH DAMAGE. |
| 38 | * |
| 39 | * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94 |
| 40 | * $FreeBSD: src/sys/kern/kern_mib.c,v 1.29.2.4 2001/07/30 23:28:00 peter Exp $ |
| 41 | */ |
| 42 | |
| 43 | #include <sys/param.h> |
| 44 | #include <sys/kernel.h> |
| 45 | #include <sys/systm.h> |
| 46 | #include <sys/sysctl.h> |
| 47 | #include <sys/proc.h> |
| 48 | #include <sys/jail.h> |
| 49 | #include <machine/smp.h> |
| 50 | |
| 51 | SYSCTL_NODE(, 0, sysctl, CTLFLAG_RW, 0, |
| 52 | "Sysctl internal magic"); |
| 53 | SYSCTL_NODE(, CTL_KERN, kern, CTLFLAG_RW, 0, |
| 54 | "High kernel, proc, limits &c"); |
| 55 | SYSCTL_NODE(, CTL_VM, vm, CTLFLAG_RW, 0, |
| 56 | "Virtual memory"); |
| 57 | SYSCTL_NODE(, CTL_VFS, vfs, CTLFLAG_RW, 0, |
| 58 | "File system"); |
| 59 | SYSCTL_NODE(, CTL_NET, net, CTLFLAG_RW, 0, |
| 60 | "Network, (see socket.h)"); |
| 61 | SYSCTL_NODE(, CTL_DEBUG, debug, CTLFLAG_RW, 0, |
| 62 | "Debugging"); |
| 63 | SYSCTL_NODE(_debug, OID_AUTO, sizeof, CTLFLAG_RW, 0, |
| 64 | "Sizeof various things"); |
| 65 | SYSCTL_NODE(, CTL_HW, hw, CTLFLAG_RW, 0, |
| 66 | "hardware"); |
| 67 | SYSCTL_NODE(, CTL_MACHDEP, machdep, CTLFLAG_RW, 0, |
| 68 | "machine dependent"); |
| 69 | SYSCTL_NODE(, CTL_USER, user, CTLFLAG_RW, 0, |
| 70 | "user-level"); |
| 71 | SYSCTL_NODE(, CTL_P1003_1B, p1003_1b, CTLFLAG_RW, 0, |
| 72 | "p1003_1b, (see p1003_1b.h)"); |
| 73 | |
| 74 | SYSCTL_NODE(, OID_AUTO, compat, CTLFLAG_RW, 0, |
| 75 | "Compatibility code"); |
| 76 | |
| 77 | SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD, |
| 78 | osrelease, 0, "Operating system type"); |
| 79 | |
| 80 | SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD, |
| 81 | 0, BSD, "Operating system revision"); |
| 82 | |
| 83 | SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD, |
| 84 | version, 0, "Kernel version"); |
| 85 | |
| 86 | SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD, |
| 87 | ostype, 0, "Operating system type"); |
| 88 | |
| 89 | extern int osreldate; |
| 90 | SYSCTL_INT(_kern, KERN_OSRELDATE, osreldate, CTLFLAG_RD, |
| 91 | &osreldate, 0, "Operating system release date"); |
| 92 | |
| 93 | SYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RD, |
| 94 | &maxproc, 0, "Maximum number of processes"); |
| 95 | |
| 96 | SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid, CTLFLAG_RW, |
| 97 | &maxprocperuid, 0, "Maximum processes allowed per userid"); |
| 98 | |
| 99 | SYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RD, |
| 100 | &maxusers, 0, "Hint for kernel tuning"); |
| 101 | |
| 102 | SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD, |
| 103 | 0, ARG_MAX, "Maximum bytes of argument to execve(2)"); |
| 104 | |
| 105 | SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD, |
| 106 | 0, _KPOSIX_VERSION, "Version of POSIX attempting to comply to"); |
| 107 | |
| 108 | SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RD, |
| 109 | 0, NGROUPS_MAX, "Maximum number of groups a user can belong to"); |
| 110 | |
| 111 | SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD, |
| 112 | 0, 1, "Whether job control is available"); |
| 113 | |
| 114 | #ifdef _POSIX_SAVED_IDS |
| 115 | SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD, |
| 116 | 0, 1, "Whether saved set-group/user ID is available"); |
| 117 | #else |
| 118 | SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD, |
| 119 | 0, 0, "Whether saved set-group/user ID is available"); |
| 120 | #endif |
| 121 | |
| 122 | char kernelname[MAXPATHLEN] = "/kernel"; /* XXX bloat */ |
| 123 | |
| 124 | SYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile, CTLFLAG_RW, |
| 125 | kernelname, sizeof kernelname, "Name of kernel file booted"); |
| 126 | |
| 127 | #ifdef SMP |
| 128 | SYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD, |
| 129 | &mp_ncpus, 0, "Number of active CPUs"); |
| 130 | #else |
| 131 | SYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD, |
| 132 | 0, 1, "Number of active CPUs"); |
| 133 | #endif |
| 134 | |
| 135 | SYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD, |
| 136 | 0, BYTE_ORDER, "System byte order"); |
| 137 | |
| 138 | SYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD, |
| 139 | 0, PAGE_SIZE, "System memory page size"); |
| 140 | |
| 141 | static char machine_arch[] = MACHINE_ARCH; |
| 142 | SYSCTL_STRING(_hw, HW_MACHINE_ARCH, machine_arch, CTLFLAG_RD, |
| 143 | machine_arch, 0, "System architecture"); |
| 144 | |
| 145 | char hostname[MAXHOSTNAMELEN]; |
| 146 | |
| 147 | static int |
| 148 | sysctl_hostname(SYSCTL_HANDLER_ARGS) |
| 149 | { |
| 150 | int error; |
| 151 | |
| 152 | if (req->p->p_prison) { |
| 153 | if (!jail_set_hostname_allowed && req->newptr) |
| 154 | return(EPERM); |
| 155 | error = sysctl_handle_string(oidp, |
| 156 | req->p->p_prison->pr_host, |
| 157 | sizeof req->p->p_prison->pr_host, req); |
| 158 | } else |
| 159 | error = sysctl_handle_string(oidp, |
| 160 | hostname, sizeof hostname, req); |
| 161 | return (error); |
| 162 | } |
| 163 | |
| 164 | SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname, |
| 165 | CTLTYPE_STRING|CTLFLAG_RW|CTLFLAG_PRISON, |
| 166 | 0, 0, sysctl_hostname, "A", "Hostname"); |
| 167 | |
| 168 | int securelevel = -1; |
| 169 | |
| 170 | static int |
| 171 | sysctl_kern_securelvl(SYSCTL_HANDLER_ARGS) |
| 172 | { |
| 173 | int error, level; |
| 174 | |
| 175 | level = securelevel; |
| 176 | error = sysctl_handle_int(oidp, &level, 0, req); |
| 177 | if (error || !req->newptr) |
| 178 | return (error); |
| 179 | if (level < securelevel) |
| 180 | return (EPERM); |
| 181 | securelevel = level; |
| 182 | return (error); |
| 183 | } |
| 184 | |
| 185 | SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel, CTLTYPE_INT|CTLFLAG_RW, |
| 186 | 0, 0, sysctl_kern_securelvl, "I", "Current secure level"); |
| 187 | |
| 188 | char domainname[MAXHOSTNAMELEN]; |
| 189 | SYSCTL_STRING(_kern, KERN_NISDOMAINNAME, domainname, CTLFLAG_RW, |
| 190 | &domainname, sizeof(domainname), "Name of the current YP/NIS domain"); |
| 191 | |
| 192 | unsigned long hostid; |
| 193 | SYSCTL_ULONG(_kern, KERN_HOSTID, hostid, CTLFLAG_RW, &hostid, 0, "Host ID"); |
| 194 | |
| 195 | /* |
| 196 | * This is really cheating. These actually live in the libc, something |
| 197 | * which I'm not quite sure is a good idea anyway, but in order for |
| 198 | * getnext and friends to actually work, we define dummies here. |
| 199 | */ |
| 200 | SYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RD, |
| 201 | "", 0, "PATH that finds all the standard utilities"); |
| 202 | SYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RD, |
| 203 | 0, 0, "Max ibase/obase values in bc(1)"); |
| 204 | SYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RD, |
| 205 | 0, 0, "Max array size in bc(1)"); |
| 206 | SYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RD, |
| 207 | 0, 0, "Max scale value in bc(1)"); |
| 208 | SYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RD, |
| 209 | 0, 0, "Max string length in bc(1)"); |
| 210 | SYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RD, |
| 211 | 0, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry"); |
| 212 | SYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RD, 0, 0, ""); |
| 213 | SYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RD, |
| 214 | 0, 0, "Max length (bytes) of a text-processing utility's input line"); |
| 215 | SYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RD, |
| 216 | 0, 0, "Maximum number of repeats of a regexp permitted"); |
| 217 | SYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RD, |
| 218 | 0, 0, |
| 219 | "The version of POSIX 1003.2 with which the system attempts to comply"); |
| 220 | SYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RD, |
| 221 | 0, 0, "Whether C development supports the C bindings option"); |
| 222 | SYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RD, |
| 223 | 0, 0, "Whether system supports the C development utilities option"); |
| 224 | SYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RD, |
| 225 | 0, 0, ""); |
| 226 | SYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RD, |
| 227 | 0, 0, "Whether system supports FORTRAN development utilities"); |
| 228 | SYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RD, |
| 229 | 0, 0, "Whether system supports FORTRAN runtime utilities"); |
| 230 | SYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RD, |
| 231 | 0, 0, "Whether system supports creation of locales"); |
| 232 | SYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RD, |
| 233 | 0, 0, "Whether system supports software development utilities"); |
| 234 | SYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RD, |
| 235 | 0, 0, "Whether system supports the user portability utilities"); |
| 236 | SYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RD, |
| 237 | 0, 0, "Min Maximum number of streams a process may have open at one time"); |
| 238 | SYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RD, |
| 239 | 0, 0, "Min Maximum number of types supported for timezone names"); |
| 240 | |
| 241 | #include <sys/vnode.h> |
| 242 | SYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD, |
| 243 | 0, sizeof(struct vnode), "sizeof(struct vnode)"); |
| 244 | |
| 245 | SYSCTL_INT(_debug_sizeof, OID_AUTO, proc, CTLFLAG_RD, |
| 246 | 0, sizeof(struct proc), "sizeof(struct proc)"); |
| 247 | |
| 248 | #include <sys/conf.h> |
| 249 | SYSCTL_INT(_debug_sizeof, OID_AUTO, specinfo, CTLFLAG_RD, |
| 250 | 0, sizeof(struct specinfo), "sizeof(struct specinfo)"); |