2 * Copyright (c) 1982, 1986, 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Mike Karels at Berkeley Software Design, Inc.
8 * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
9 * project, to make these variables more userfriendly.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94
36 * $FreeBSD: src/sys/kern/kern_mib.c,v 1.29.2.4 2001/07/30 23:28:00 peter Exp $
39 #include <sys/param.h>
40 #include <sys/kernel.h>
41 #include <sys/systm.h>
42 #include <sys/sysctl.h>
44 #include <sys/lockf.h>
46 #include <sys/unistd.h>
47 #include <machine/tls.h>
48 #include <machine/smp.h>
50 SYSCTL_NODE(, 0, sysctl
, CTLFLAG_RW
, 0,
51 "Sysctl internal magic");
52 SYSCTL_NODE(, CTL_KERN
, kern
, CTLFLAG_RW
, 0,
53 "High kernel, proc, limits &c");
54 SYSCTL_NODE(, CTL_VM
, vm
, CTLFLAG_RW
, 0,
56 SYSCTL_NODE(, CTL_VFS
, vfs
, CTLFLAG_RW
, 0,
58 SYSCTL_NODE(, CTL_NET
, net
, CTLFLAG_RW
, 0,
59 "Network, (see socket.h)");
60 SYSCTL_NODE(, CTL_DEBUG
, debug
, CTLFLAG_RW
, 0,
62 SYSCTL_NODE(_debug
, OID_AUTO
, sizeof, CTLFLAG_RW
, 0,
63 "Size of various kernel data structures");
64 SYSCTL_NODE(, CTL_HW
, hw
, CTLFLAG_RW
, 0,
66 SYSCTL_NODE(, CTL_MACHDEP
, machdep
, CTLFLAG_RW
, 0,
68 SYSCTL_NODE(, CTL_USER
, user
, CTLFLAG_RW
, 0,
70 SYSCTL_NODE(, CTL_P1003_1B
, p1003_1b
, CTLFLAG_RW
, 0,
71 "p1003_1b, (see p1003_1b.h)");
72 SYSCTL_NODE(, CTL_LWKT
, lwkt
, CTLFLAG_RW
, 0,
73 "light weight kernel threads");
75 SYSCTL_NODE(, OID_AUTO
, compat
, CTLFLAG_RW
, 0,
76 "Compatibility code");
77 SYSCTL_NODE(, OID_AUTO
, security
, CTLFLAG_RW
, 0,
80 SYSCTL_STRING(_kern
, OID_AUTO
, ident
, CTLFLAG_RD
| CTLFLAG_NOLOCK
,
81 kern_ident
, 0, "Kernel identifier");
83 SYSCTL_STRING(_kern
, KERN_OSRELEASE
, osrelease
, CTLFLAG_RD
| CTLFLAG_NOLOCK
,
84 osrelease
, 0, "Operating system type");
86 SYSCTL_INT(_kern
, KERN_OSREV
, osrevision
, CTLFLAG_RD
,
87 0, __DragonFly_version
, "Operating system revision");
89 SYSCTL_STRING(_kern
, KERN_VERSION
, version
, CTLFLAG_RD
| CTLFLAG_NOLOCK
,
90 version
, 0, "Kernel version");
92 SYSCTL_STRING(_kern
, KERN_OSTYPE
, ostype
, CTLFLAG_RD
| CTLFLAG_NOLOCK
,
93 ostype
, 0, "Operating system type");
95 SYSCTL_INT(_kern
, KERN_OSRELDATE
, osreldate
, CTLFLAG_RD
,
96 &osreldate
, 0, "Operating system release date");
98 static int tls_extra
= RTLD_STATIC_TLS_EXTRA_DEFAULT
;
99 SYSCTL_INT(_kern
, KERN_STATIC_TLS_EXTRA
, tls_extra
, CTLFLAG_RW
| CTLFLAG_NOLOCK
,
100 &tls_extra
, 0, "Extra static tls space for libraries");
102 SYSCTL_INT(_kern
, KERN_MAXPROC
, maxproc
, CTLFLAG_RD
,
103 &maxproc
, 0, "Maximum number of processes");
105 SYSCTL_INT(_kern
, KERN_MAXPROCPERUID
, maxprocperuid
, CTLFLAG_RW
,
106 &maxprocperuid
, 0, "Maximum processes allowed per userid");
108 SYSCTL_INT(_kern
, KERN_MAXPOSIXLOCKSPERUID
, maxposixlocksperuid
, CTLFLAG_RW
,
109 &maxposixlocksperuid
, 0, "Maximum number of POSIX-type locks per user id");
111 SYSCTL_INT(_kern
, OID_AUTO
, maxusers
, CTLFLAG_RD
,
112 &maxusers
, 0, "Hint for kernel tuning");
114 SYSCTL_INT(_kern
, KERN_ARGMAX
, argmax
, CTLFLAG_RD
,
115 0, ARG_MAX
, "Maximum bytes of argument to execve(2)");
117 SYSCTL_INT(_kern
, KERN_POSIX1
, posix1version
, CTLFLAG_RD
,
118 0, _POSIX_VERSION
, "Version of POSIX attempting to comply to");
120 SYSCTL_INT(_kern
, KERN_NGROUPS
, ngroups
, CTLFLAG_RD
,
121 0, NGROUPS_MAX
, "Maximum number of groups a user can belong to");
123 SYSCTL_INT(_kern
, KERN_JOB_CONTROL
, job_control
, CTLFLAG_RD
,
124 0, 1, "Whether job control is available");
126 #ifdef _POSIX_SAVED_IDS
127 SYSCTL_INT(_kern
, KERN_SAVED_IDS
, saved_ids
, CTLFLAG_RD
,
128 0, 1, "Whether saved set-group/user ID is available");
130 SYSCTL_INT(_kern
, KERN_SAVED_IDS
, saved_ids
, CTLFLAG_RD
,
131 0, 0, "Whether saved set-group/user ID is available");
134 char kernelname
[MAXPATHLEN
] = "/kernel"; /* XXX bloat */
136 SYSCTL_STRING(_kern
, KERN_BOOTFILE
, bootfile
, CTLFLAG_RW
,
137 kernelname
, sizeof kernelname
, "Name of kernel file booted");
139 SYSCTL_INT(_hw
, HW_NCPU
, ncpu
, CTLFLAG_RD
,
140 &ncpus
, 0, "Number of active CPUs");
142 SYSCTL_INT(_hw
, HW_BYTEORDER
, byteorder
, CTLFLAG_RD
,
143 0, BYTE_ORDER
, "System byte order");
145 SYSCTL_INT(_hw
, HW_PAGESIZE
, pagesize
, CTLFLAG_RD
,
146 0, PAGE_SIZE
, "System memory page size");
148 static char platform
[] = MACHINE_PLATFORM
;
149 SYSCTL_STRING(_hw
, HW_MACHINE_PLATFORM
, platform
, CTLFLAG_RD
| CTLFLAG_NOLOCK
,
150 platform
, 0, "Platform architecture");
152 static char machine_arch
[] = MACHINE_ARCH
;
153 SYSCTL_STRING(_hw
, HW_MACHINE_ARCH
, machine_arch
, CTLFLAG_RD
| CTLFLAG_NOLOCK
,
154 machine_arch
, 0, "Cpu architecture");
156 char hostname
[MAXHOSTNAMELEN
];
159 * Hostname sysctl handler. We use CTLFLAG_NOLOCK to avoid acquiring
160 * the per-oid lock. The per-cpu SLOCK is still acquired, so to interlock
161 * against setting the hostname we relock with XLOCK. The result is
162 * that the critical path (just reading the hostname) gets one less lock
163 * and will have improved performance.
166 sysctl_hostname(SYSCTL_HANDLER_ARGS
)
168 struct thread
*td
= req
->td
;
169 struct proc
*p
= td
? td
->td_proc
: NULL
;
178 pr
= p
->p_ucred
->cr_prison
;
180 if (!PRISON_CAP_ISSET(pr
->pr_caps
,
181 PRISON_CAP_SYS_SET_HOSTNAME
) && req
->newptr
)
183 error
= sysctl_handle_string(oidp
,
184 p
->p_ucred
->cr_prison
->pr_host
,
185 sizeof p
->p_ucred
->cr_prison
->pr_host
, req
);
187 error
= sysctl_handle_string(oidp
,
188 hostname
, sizeof hostname
, req
);
197 SYSCTL_PROC(_kern
, KERN_HOSTNAME
, hostname
,
198 CTLTYPE_STRING
| CTLFLAG_RW
| CTLFLAG_PRISON
| CTLFLAG_NOLOCK
,
199 0, 0, sysctl_hostname
, "A", "Hostname");
201 int securelevel
= -1;
202 int kernel_mem_readonly
= 0;
205 sysctl_kern_securelvl(SYSCTL_HANDLER_ARGS
)
210 error
= sysctl_handle_int(oidp
, &level
, 0, req
);
211 if (error
|| !req
->newptr
)
213 if (level
< securelevel
)
219 SYSCTL_PROC(_kern
, KERN_SECURELVL
, securelevel
, CTLTYPE_INT
|CTLFLAG_RW
,
220 0, 0, sysctl_kern_securelvl
, "I", "Current secure level");
222 char domainname
[MAXHOSTNAMELEN
];
223 SYSCTL_STRING(_kern
, KERN_NISDOMAINNAME
, domainname
, CTLFLAG_RW
,
224 &domainname
, sizeof(domainname
), "Name of the current YP/NIS domain");
226 unsigned long hostid
;
227 SYSCTL_ULONG(_kern
, KERN_HOSTID
, hostid
, CTLFLAG_RW
, &hostid
, 0, "Host ID");
230 * This is really cheating. These actually live in the libc, something
231 * which I'm not quite sure is a good idea anyway, but in order for
232 * getnext and friends to actually work, we define dummies here.
234 SYSCTL_STRING(_user
, USER_CS_PATH
, cs_path
, CTLFLAG_RD
,
235 "", 0, "PATH that finds all the standard utilities");
236 SYSCTL_INT(_user
, USER_BC_BASE_MAX
, bc_base_max
, CTLFLAG_RD
,
237 0, 0, "Max ibase/obase values in bc(1)");
238 SYSCTL_INT(_user
, USER_BC_DIM_MAX
, bc_dim_max
, CTLFLAG_RD
,
239 0, 0, "Max array size in bc(1)");
240 SYSCTL_INT(_user
, USER_BC_SCALE_MAX
, bc_scale_max
, CTLFLAG_RD
,
241 0, 0, "Max scale value in bc(1)");
242 SYSCTL_INT(_user
, USER_BC_STRING_MAX
, bc_string_max
, CTLFLAG_RD
,
243 0, 0, "Max string length in bc(1)");
244 SYSCTL_INT(_user
, USER_COLL_WEIGHTS_MAX
, coll_weights_max
, CTLFLAG_RD
,
245 0, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry");
246 SYSCTL_INT(_user
, USER_EXPR_NEST_MAX
, expr_nest_max
, CTLFLAG_RD
, 0, 0, "");
247 SYSCTL_INT(_user
, USER_LINE_MAX
, line_max
, CTLFLAG_RD
,
248 0, 0, "Max length (bytes) of a text-processing utility's input line");
249 SYSCTL_INT(_user
, USER_RE_DUP_MAX
, re_dup_max
, CTLFLAG_RD
,
250 0, 0, "Maximum number of repeats of a regexp permitted");
251 SYSCTL_INT(_user
, USER_POSIX2_VERSION
, posix2_version
, CTLFLAG_RD
,
253 "The version of POSIX 1003.2 with which the system attempts to comply");
254 SYSCTL_INT(_user
, USER_POSIX2_C_BIND
, posix2_c_bind
, CTLFLAG_RD
,
255 0, 0, "Whether C development supports the C bindings option");
256 SYSCTL_INT(_user
, USER_POSIX2_C_DEV
, posix2_c_dev
, CTLFLAG_RD
,
257 0, 0, "Whether system supports the C development utilities option");
258 SYSCTL_INT(_user
, USER_POSIX2_CHAR_TERM
, posix2_char_term
, CTLFLAG_RD
,
260 SYSCTL_INT(_user
, USER_POSIX2_FORT_DEV
, posix2_fort_dev
, CTLFLAG_RD
,
261 0, 0, "Whether system supports FORTRAN development utilities");
262 SYSCTL_INT(_user
, USER_POSIX2_FORT_RUN
, posix2_fort_run
, CTLFLAG_RD
,
263 0, 0, "Whether system supports FORTRAN runtime utilities");
264 SYSCTL_INT(_user
, USER_POSIX2_LOCALEDEF
, posix2_localedef
, CTLFLAG_RD
,
265 0, 0, "Whether system supports creation of locales");
266 SYSCTL_INT(_user
, USER_POSIX2_SW_DEV
, posix2_sw_dev
, CTLFLAG_RD
,
267 0, 0, "Whether system supports software development utilities");
268 SYSCTL_INT(_user
, USER_POSIX2_UPE
, posix2_upe
, CTLFLAG_RD
,
269 0, 0, "Whether system supports the user portability utilities");
270 SYSCTL_INT(_user
, USER_STREAM_MAX
, stream_max
, CTLFLAG_RD
,
271 0, 0, "Min Maximum number of streams a process may have open at one time");
272 SYSCTL_INT(_user
, USER_TZNAME_MAX
, tzname_max
, CTLFLAG_RD
,
273 0, 0, "Min Maximum number of types supported for timezone names");
275 #include <sys/vnode.h>
276 SYSCTL_INT(_debug_sizeof
, OID_AUTO
, vnode
, CTLFLAG_RD
,
277 0, sizeof(struct vnode
), "sizeof(struct vnode)");
279 SYSCTL_INT(_debug_sizeof
, OID_AUTO
, proc
, CTLFLAG_RD
,
280 0, sizeof(struct proc
), "sizeof(struct proc)");
282 #include <sys/conf.h>
283 SYSCTL_INT(_debug_sizeof
, OID_AUTO
, cdev
, CTLFLAG_RD
,
284 0, sizeof(struct cdev
), "sizeof(struct cdev)");
286 SYSCTL_NODE(_kern
, OID_AUTO
, features
, CTLFLAG_RD
, 0, "Kernel Features");