xref: /freebsd/sys/kern/kern_mib.c (revision f976241773df2260e6170317080761d1c5814fe5)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1989, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Mike Karels at Berkeley Software Design, Inc.
9  *
10  * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
11  * project, to make these variables more userfriendly.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *	@(#)kern_sysctl.c	8.4 (Berkeley) 4/14/94
38  */
39 
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD$");
42 
43 #include "opt_posix.h"
44 #include "opt_config.h"
45 
46 #include <sys/param.h>
47 #include <sys/boot.h>
48 #include <sys/jail.h>
49 #include <sys/kernel.h>
50 #include <sys/limits.h>
51 #include <sys/lock.h>
52 #include <sys/mutex.h>
53 #include <sys/proc.h>
54 #include <sys/random.h>
55 #include <sys/sbuf.h>
56 #include <sys/smp.h>
57 #include <sys/sx.h>
58 #include <sys/vmmeter.h>
59 #include <sys/sysctl.h>
60 #include <sys/systm.h>
61 #include <sys/unistd.h>
62 
63 SYSCTL_ROOT_NODE(0,	  sysctl, CTLFLAG_RW, 0,
64 	"Sysctl internal magic");
65 SYSCTL_ROOT_NODE(CTL_KERN,	  kern,   CTLFLAG_RW|CTLFLAG_CAPRD, 0,
66 	"High kernel, proc, limits &c");
67 SYSCTL_ROOT_NODE(CTL_VM,	  vm,     CTLFLAG_RW, 0,
68 	"Virtual memory");
69 SYSCTL_ROOT_NODE(CTL_VFS,	  vfs,     CTLFLAG_RW, 0,
70 	"File system");
71 SYSCTL_ROOT_NODE(CTL_NET,	  net,    CTLFLAG_RW, 0,
72 	"Network, (see socket.h)");
73 SYSCTL_ROOT_NODE(CTL_DEBUG,  debug,  CTLFLAG_RW, 0,
74 	"Debugging");
75 SYSCTL_NODE(_debug, OID_AUTO,  sizeof,  CTLFLAG_RW, 0,
76 	"Sizeof various things");
77 SYSCTL_ROOT_NODE(CTL_HW,	  hw,     CTLFLAG_RW, 0,
78 	"hardware");
79 SYSCTL_ROOT_NODE(CTL_MACHDEP, machdep, CTLFLAG_RW, 0,
80 	"machine dependent");
81 SYSCTL_NODE(_machdep, OID_AUTO, mitigations, CTLFLAG_RW, 0,
82 	"Machine dependent platform mitigations.");
83 SYSCTL_ROOT_NODE(CTL_USER,	  user,   CTLFLAG_RW, 0,
84 	"user-level");
85 SYSCTL_ROOT_NODE(CTL_P1003_1B,  p1003_1b,   CTLFLAG_RW, 0,
86 	"p1003_1b, (see p1003_1b.h)");
87 
88 SYSCTL_ROOT_NODE(OID_AUTO,  compat, CTLFLAG_RW, 0,
89 	"Compatibility code");
90 SYSCTL_ROOT_NODE(OID_AUTO, security, CTLFLAG_RW, 0,
91      	"Security");
92 #ifdef REGRESSION
93 SYSCTL_ROOT_NODE(OID_AUTO, regression, CTLFLAG_RW, 0,
94      "Regression test MIB");
95 #endif
96 
97 SYSCTL_STRING(_kern, OID_AUTO, ident, CTLFLAG_RD|CTLFLAG_MPSAFE,
98     kern_ident, 0, "Kernel identifier");
99 
100 SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD|CTLFLAG_CAPRD,
101     SYSCTL_NULL_INT_PTR, BSD, "Operating system revision");
102 
103 SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD|CTLFLAG_MPSAFE,
104     version, 0, "Kernel version");
105 
106 SYSCTL_STRING(_kern, OID_AUTO, compiler_version, CTLFLAG_RD|CTLFLAG_MPSAFE,
107     compiler_version, 0, "Version of compiler used to compile kernel");
108 
109 SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD|CTLFLAG_MPSAFE|
110     CTLFLAG_CAPRD, ostype, 0, "Operating system type");
111 
112 SYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
113     &maxproc, 0, "Maximum number of processes");
114 
115 SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid, CTLFLAG_RW,
116     &maxprocperuid, 0, "Maximum processes allowed per userid");
117 
118 SYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
119     &maxusers, 0, "Hint for kernel tuning");
120 
121 SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD|CTLFLAG_CAPRD,
122     SYSCTL_NULL_INT_PTR, ARG_MAX, "Maximum bytes of argument to execve(2)");
123 
124 SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD|CTLFLAG_CAPRD,
125     SYSCTL_NULL_INT_PTR, _POSIX_VERSION, "Version of POSIX attempting to comply to");
126 
127 SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RDTUN |
128     CTLFLAG_NOFETCH | CTLFLAG_CAPRD, &ngroups_max, 0,
129     "Maximum number of supplemental groups a user can belong to");
130 
131 SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD|CTLFLAG_CAPRD,
132     SYSCTL_NULL_INT_PTR, 1, "Whether job control is available");
133 
134 #ifdef _POSIX_SAVED_IDS
135 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD,
136     SYSCTL_NULL_INT_PTR, 1, "Whether saved set-group/user ID is available");
137 #else
138 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD,
139     SYSCTL_NULL_INT_PTR, 0, "Whether saved set-group/user ID is available");
140 #endif
141 
142 char kernelname[MAXPATHLEN] = PATH_KERNEL;	/* XXX bloat */
143 
144 SYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile, CTLFLAG_RW | CTLFLAG_MPSAFE,
145     kernelname, sizeof kernelname, "Name of kernel file booted");
146 
147 SYSCTL_INT(_kern, KERN_MAXPHYS, maxphys, CTLFLAG_RD | CTLFLAG_CAPRD,
148     SYSCTL_NULL_INT_PTR, MAXPHYS, "Maximum block I/O access size");
149 
150 SYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD|CTLFLAG_CAPRD,
151     &mp_ncpus, 0, "Number of active CPUs");
152 
153 SYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD|CTLFLAG_CAPRD,
154     SYSCTL_NULL_INT_PTR, BYTE_ORDER, "System byte order");
155 
156 SYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD|CTLFLAG_CAPRD,
157     SYSCTL_NULL_INT_PTR, PAGE_SIZE, "System memory page size");
158 
159 static int
160 sysctl_kern_arnd(SYSCTL_HANDLER_ARGS)
161 {
162 	char buf[256];
163 	size_t len;
164 
165 	len = MIN(req->oldlen, sizeof(buf));
166 	read_random(buf, len);
167 	return (SYSCTL_OUT(req, buf, len));
168 }
169 
170 SYSCTL_PROC(_kern, KERN_ARND, arandom,
171     CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD, NULL, 0,
172     sysctl_kern_arnd, "", "arc4rand");
173 
174 static int
175 sysctl_hw_physmem(SYSCTL_HANDLER_ARGS)
176 {
177 	u_long val, p;
178 
179 	p = SIZE_T_MAX >> PAGE_SHIFT;
180 	if (physmem < p)
181 		p = physmem;
182 	val = ctob(p);
183 	return (sysctl_handle_long(oidp, &val, 0, req));
184 }
185 SYSCTL_PROC(_hw, HW_PHYSMEM, physmem, CTLTYPE_ULONG | CTLFLAG_RD,
186     0, 0, sysctl_hw_physmem, "LU",
187     "Amount of physical memory (in bytes)");
188 
189 static int
190 sysctl_hw_realmem(SYSCTL_HANDLER_ARGS)
191 {
192 	u_long val, p;
193 
194 	p = SIZE_T_MAX >> PAGE_SHIFT;
195 	if (realmem < p)
196 		p = realmem;
197 	val = ctob(p);
198 	return (sysctl_handle_long(oidp, &val, 0, req));
199 }
200 SYSCTL_PROC(_hw, HW_REALMEM, realmem, CTLTYPE_ULONG | CTLFLAG_RD,
201     0, 0, sysctl_hw_realmem, "LU",
202     "Amount of memory (in bytes) reported by the firmware");
203 
204 static int
205 sysctl_hw_usermem(SYSCTL_HANDLER_ARGS)
206 {
207 	u_long val, p, p1;
208 
209 	p1 = physmem - vm_wire_count();
210 	p = SIZE_T_MAX >> PAGE_SHIFT;
211 	if (p1 < p)
212 		p = p1;
213 	val = ctob(p);
214 	return (sysctl_handle_long(oidp, &val, 0, req));
215 }
216 SYSCTL_PROC(_hw, HW_USERMEM, usermem, CTLTYPE_ULONG | CTLFLAG_RD,
217     0, 0, sysctl_hw_usermem, "LU",
218     "Amount of memory (in bytes) which is not wired");
219 
220 SYSCTL_LONG(_hw, OID_AUTO, availpages, CTLFLAG_RD, &physmem, 0,
221     "Amount of physical memory (in pages)");
222 
223 u_long pagesizes[MAXPAGESIZES] = { PAGE_SIZE };
224 
225 static int
226 sysctl_hw_pagesizes(SYSCTL_HANDLER_ARGS)
227 {
228 	int error;
229 #ifdef SCTL_MASK32
230 	int i;
231 	uint32_t pagesizes32[MAXPAGESIZES];
232 
233 	if (req->flags & SCTL_MASK32) {
234 		/*
235 		 * Recreate the "pagesizes" array with 32-bit elements.  Truncate
236 		 * any page size greater than UINT32_MAX to zero.
237 		 */
238 		for (i = 0; i < MAXPAGESIZES; i++)
239 			pagesizes32[i] = (uint32_t)pagesizes[i];
240 
241 		error = SYSCTL_OUT(req, pagesizes32, sizeof(pagesizes32));
242 	} else
243 #endif
244 		error = SYSCTL_OUT(req, pagesizes, sizeof(pagesizes));
245 	return (error);
246 }
247 SYSCTL_PROC(_hw, OID_AUTO, pagesizes, CTLTYPE_ULONG | CTLFLAG_RD,
248     NULL, 0, sysctl_hw_pagesizes, "LU", "Supported page sizes");
249 
250 #ifdef SCTL_MASK32
251 int adaptive_machine_arch = 1;
252 SYSCTL_INT(_debug, OID_AUTO, adaptive_machine_arch, CTLFLAG_RW,
253     &adaptive_machine_arch, 1,
254     "Adapt reported machine architecture to the ABI of the binary");
255 #endif
256 
257 static int
258 sysctl_hw_machine_arch(SYSCTL_HANDLER_ARGS)
259 {
260 	int error;
261 	static const char machine_arch[] = MACHINE_ARCH;
262 #ifdef SCTL_MASK32
263 	static const char machine_arch32[] = MACHINE_ARCH32;
264 
265 	if ((req->flags & SCTL_MASK32) != 0 && adaptive_machine_arch)
266 		error = SYSCTL_OUT(req, machine_arch32, sizeof(machine_arch32));
267 	else
268 #endif
269 		error = SYSCTL_OUT(req, machine_arch, sizeof(machine_arch));
270 	return (error);
271 
272 }
273 SYSCTL_PROC(_hw, HW_MACHINE_ARCH, machine_arch, CTLTYPE_STRING | CTLFLAG_RD |
274     CTLFLAG_MPSAFE, NULL, 0, sysctl_hw_machine_arch, "A",
275     "System architecture");
276 
277 SYSCTL_STRING(_kern, OID_AUTO, supported_archs, CTLFLAG_RD | CTLFLAG_MPSAFE,
278 #ifdef COMPAT_FREEBSD32
279     MACHINE_ARCH " " MACHINE_ARCH32, 0, "Supported architectures for binaries");
280 #else
281     MACHINE_ARCH, 0, "Supported architectures for binaries");
282 #endif
283 
284 static int
285 sysctl_hostname(SYSCTL_HANDLER_ARGS)
286 {
287 	struct prison *pr, *cpr;
288 	size_t pr_offset;
289 	char tmpname[MAXHOSTNAMELEN];
290 	int descend, error, len;
291 
292 	/*
293 	 * This function can set: hostname domainname hostuuid.
294 	 * Keep that in mind when comments say "hostname".
295 	 */
296 	pr_offset = (size_t)arg1;
297 	len = arg2;
298 	KASSERT(len <= sizeof(tmpname),
299 	    ("length %d too long for %s", len, __func__));
300 
301 	pr = req->td->td_ucred->cr_prison;
302 	if (!(pr->pr_allow & PR_ALLOW_SET_HOSTNAME) && req->newptr)
303 		return (EPERM);
304 	/*
305 	 * Make a local copy of hostname to get/set so we don't have to hold
306 	 * the jail mutex during the sysctl copyin/copyout activities.
307 	 */
308 	mtx_lock(&pr->pr_mtx);
309 	bcopy((char *)pr + pr_offset, tmpname, len);
310 	mtx_unlock(&pr->pr_mtx);
311 
312 	error = sysctl_handle_string(oidp, tmpname, len, req);
313 
314 	if (req->newptr != NULL && error == 0) {
315 		/*
316 		 * Copy the locally set hostname to all jails that share
317 		 * this host info.
318 		 */
319 		sx_slock(&allprison_lock);
320 		while (!(pr->pr_flags & PR_HOST))
321 			pr = pr->pr_parent;
322 		mtx_lock(&pr->pr_mtx);
323 		bcopy(tmpname, (char *)pr + pr_offset, len);
324 		FOREACH_PRISON_DESCENDANT_LOCKED(pr, cpr, descend)
325 			if (cpr->pr_flags & PR_HOST)
326 				descend = 0;
327 			else
328 				bcopy(tmpname, (char *)cpr + pr_offset, len);
329 		mtx_unlock(&pr->pr_mtx);
330 		sx_sunlock(&allprison_lock);
331 	}
332 	return (error);
333 }
334 
335 SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname,
336     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_CAPRD | CTLFLAG_MPSAFE,
337     (void *)(offsetof(struct prison, pr_hostname)), MAXHOSTNAMELEN,
338     sysctl_hostname, "A", "Hostname");
339 SYSCTL_PROC(_kern, KERN_NISDOMAINNAME, domainname,
340     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_CAPRD | CTLFLAG_MPSAFE,
341     (void *)(offsetof(struct prison, pr_domainname)), MAXHOSTNAMELEN,
342     sysctl_hostname, "A", "Name of the current YP/NIS domain");
343 SYSCTL_PROC(_kern, KERN_HOSTUUID, hostuuid,
344     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_CAPRD | CTLFLAG_MPSAFE,
345     (void *)(offsetof(struct prison, pr_hostuuid)), HOSTUUIDLEN,
346     sysctl_hostname, "A", "Host UUID");
347 
348 static int	regression_securelevel_nonmonotonic = 0;
349 
350 #ifdef REGRESSION
351 SYSCTL_INT(_regression, OID_AUTO, securelevel_nonmonotonic, CTLFLAG_RW,
352     &regression_securelevel_nonmonotonic, 0, "securelevel may be lowered");
353 #endif
354 
355 static int
356 sysctl_kern_securelvl(SYSCTL_HANDLER_ARGS)
357 {
358 	struct prison *pr, *cpr;
359 	int descend, error, level;
360 
361 	pr = req->td->td_ucred->cr_prison;
362 
363 	/*
364 	 * Reading the securelevel is easy, since the current jail's level
365 	 * is known to be at least as secure as any higher levels.  Perform
366 	 * a lockless read since the securelevel is an integer.
367 	 */
368 	level = pr->pr_securelevel;
369 	error = sysctl_handle_int(oidp, &level, 0, req);
370 	if (error || !req->newptr)
371 		return (error);
372 	/* Permit update only if the new securelevel exceeds the old. */
373 	sx_slock(&allprison_lock);
374 	mtx_lock(&pr->pr_mtx);
375 	if (!regression_securelevel_nonmonotonic &&
376 	    level < pr->pr_securelevel) {
377 		mtx_unlock(&pr->pr_mtx);
378 		sx_sunlock(&allprison_lock);
379 		return (EPERM);
380 	}
381 	pr->pr_securelevel = level;
382 	/*
383 	 * Set all child jails to be at least this level, but do not lower
384 	 * them (even if regression_securelevel_nonmonotonic).
385 	 */
386 	FOREACH_PRISON_DESCENDANT_LOCKED(pr, cpr, descend) {
387 		if (cpr->pr_securelevel < level)
388 			cpr->pr_securelevel = level;
389 	}
390 	mtx_unlock(&pr->pr_mtx);
391 	sx_sunlock(&allprison_lock);
392 	return (error);
393 }
394 
395 SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
396     CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0, sysctl_kern_securelvl,
397     "I", "Current secure level");
398 
399 #ifdef INCLUDE_CONFIG_FILE
400 /* Actual kernel configuration options. */
401 extern char kernconfstring[];
402 
403 SYSCTL_STRING(_kern, OID_AUTO, conftxt, CTLFLAG_RD | CTLFLAG_MPSAFE,
404     kernconfstring, 0, "Kernel configuration file");
405 #endif
406 
407 static int
408 sysctl_hostid(SYSCTL_HANDLER_ARGS)
409 {
410 	struct prison *pr, *cpr;
411 	u_long tmpid;
412 	int descend, error;
413 
414 	/*
415 	 * Like sysctl_hostname, except it operates on a u_long
416 	 * instead of a string, and is used only for hostid.
417 	 */
418 	pr = req->td->td_ucred->cr_prison;
419 	if (!(pr->pr_allow & PR_ALLOW_SET_HOSTNAME) && req->newptr)
420 		return (EPERM);
421 	tmpid = pr->pr_hostid;
422 	error = sysctl_handle_long(oidp, &tmpid, 0, req);
423 
424 	if (req->newptr != NULL && error == 0) {
425 		sx_slock(&allprison_lock);
426 		while (!(pr->pr_flags & PR_HOST))
427 			pr = pr->pr_parent;
428 		mtx_lock(&pr->pr_mtx);
429 		pr->pr_hostid = tmpid;
430 		FOREACH_PRISON_DESCENDANT_LOCKED(pr, cpr, descend)
431 			if (cpr->pr_flags & PR_HOST)
432 				descend = 0;
433 			else
434 				cpr->pr_hostid = tmpid;
435 		mtx_unlock(&pr->pr_mtx);
436 		sx_sunlock(&allprison_lock);
437 	}
438 	return (error);
439 }
440 
441 SYSCTL_PROC(_kern, KERN_HOSTID, hostid,
442     CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE | CTLFLAG_CAPRD,
443     NULL, 0, sysctl_hostid, "LU", "Host ID");
444 
445 /*
446  * The osrelease string is copied from the global (osrelease in vers.c) into
447  * prison0 by a sysinit and is inherited by child jails if not changed at jail
448  * creation, so we always return the copy from the current prison data.
449  */
450 static int
451 sysctl_osrelease(SYSCTL_HANDLER_ARGS)
452 {
453 	struct prison *pr;
454 
455 	pr = req->td->td_ucred->cr_prison;
456 	return (SYSCTL_OUT(req, pr->pr_osrelease, strlen(pr->pr_osrelease) + 1));
457 
458 }
459 
460 SYSCTL_PROC(_kern, KERN_OSRELEASE, osrelease,
461     CTLTYPE_STRING | CTLFLAG_CAPRD | CTLFLAG_RD | CTLFLAG_MPSAFE,
462     NULL, 0, sysctl_osrelease, "A", "Operating system release");
463 
464 /*
465  * The osreldate number is copied from the global (osreldate in vers.c) into
466  * prison0 by a sysinit and is inherited by child jails if not changed at jail
467  * creation, so we always return the value from the current prison data.
468  */
469 static int
470 sysctl_osreldate(SYSCTL_HANDLER_ARGS)
471 {
472 	struct prison *pr;
473 
474 	pr = req->td->td_ucred->cr_prison;
475 	return (SYSCTL_OUT(req, &pr->pr_osreldate, sizeof(pr->pr_osreldate)));
476 
477 }
478 
479 /*
480  * NOTICE: The *userland* release date is available in
481  * /usr/include/osreldate.h
482  */
483 SYSCTL_PROC(_kern, KERN_OSRELDATE, osreldate,
484     CTLTYPE_INT | CTLFLAG_CAPRD | CTLFLAG_RD | CTLFLAG_MPSAFE,
485     NULL, 0, sysctl_osreldate, "I", "Kernel release date");
486 
487 /*
488  * The build-id is copied from the ELF section .note.gnu.build-id.  The linker
489  * script defines two variables to expose the beginning and end.  LLVM
490  * currently uses a SHA-1 hash, but other formats can be supported by checking
491  * the length of the section.
492  */
493 
494 extern char __build_id_start[];
495 extern char __build_id_end[];
496 
497 #define	BUILD_ID_HEADER_LEN	0x10
498 #define	BUILD_ID_HASH_MAXLEN	0x14
499 
500 static int
501 sysctl_build_id(SYSCTL_HANDLER_ARGS)
502 {
503 	uintptr_t sectionlen = (uintptr_t)(__build_id_end - __build_id_start);
504 	int hashlen;
505 	char buf[2*BUILD_ID_HASH_MAXLEN+1];
506 
507 	/*
508 	 * The ELF note section has a four byte length for the vendor name,
509 	 * four byte length for the value, and a four byte vendor specific
510 	 * type.  The name for the build id is "GNU\0".  We skip the first 16
511 	 * bytes to read the build hash.  We will return the remaining bytes up
512 	 * to 20 (SHA-1) hash size.  If the hash happens to be a custom number
513 	 * of bytes we will pad the value with zeros, as the section should be
514 	 * four byte aligned.
515 	 */
516 	if (sectionlen <= BUILD_ID_HEADER_LEN ||
517 	    sectionlen > (BUILD_ID_HEADER_LEN + BUILD_ID_HASH_MAXLEN)) {
518 		return (ENOENT);
519 	}
520 
521 	hashlen = sectionlen - BUILD_ID_HEADER_LEN;
522 	for (int i = 0; i < hashlen; i++) {
523 		uint8_t c = __build_id_start[i+BUILD_ID_HEADER_LEN];
524 		snprintf(&buf[2*i], 3, "%02x", c);
525 	}
526 
527 	return (SYSCTL_OUT(req, buf, strlen(buf) + 1));
528 }
529 
530 SYSCTL_PROC(_kern, OID_AUTO, build_id,
531     CTLTYPE_STRING | CTLFLAG_CAPRD | CTLFLAG_RD | CTLFLAG_MPSAFE,
532     NULL, 0, sysctl_build_id, "A", "Operating system build-id");
533 
534 SYSCTL_NODE(_kern, OID_AUTO, features, CTLFLAG_RD, 0, "Kernel Features");
535 
536 #ifdef COMPAT_FREEBSD4
537 FEATURE(compat_freebsd4, "Compatible with FreeBSD 4");
538 #endif
539 
540 #ifdef COMPAT_FREEBSD5
541 FEATURE(compat_freebsd5, "Compatible with FreeBSD 5");
542 #endif
543 
544 #ifdef COMPAT_FREEBSD6
545 FEATURE(compat_freebsd6, "Compatible with FreeBSD 6");
546 #endif
547 
548 #ifdef COMPAT_FREEBSD7
549 FEATURE(compat_freebsd7, "Compatible with FreeBSD 7");
550 #endif
551 
552 /*
553  * This is really cheating.  These actually live in the libc, something
554  * which I'm not quite sure is a good idea anyway, but in order for
555  * getnext and friends to actually work, we define dummies here.
556  *
557  * XXXRW: These probably should be CTLFLAG_CAPRD.
558  */
559 SYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RD,
560     "", 0, "PATH that finds all the standard utilities");
561 SYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RD,
562     SYSCTL_NULL_INT_PTR, 0, "Max ibase/obase values in bc(1)");
563 SYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RD,
564     SYSCTL_NULL_INT_PTR, 0, "Max array size in bc(1)");
565 SYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RD,
566     SYSCTL_NULL_INT_PTR, 0, "Max scale value in bc(1)");
567 SYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RD,
568     SYSCTL_NULL_INT_PTR, 0, "Max string length in bc(1)");
569 SYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RD,
570     SYSCTL_NULL_INT_PTR, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry");
571 SYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RD,
572     SYSCTL_NULL_INT_PTR, 0, "");
573 SYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RD,
574     SYSCTL_NULL_INT_PTR, 0, "Max length (bytes) of a text-processing utility's input line");
575 SYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RD,
576     SYSCTL_NULL_INT_PTR, 0, "Maximum number of repeats of a regexp permitted");
577 SYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RD,
578     SYSCTL_NULL_INT_PTR, 0,
579     "The version of POSIX 1003.2 with which the system attempts to comply");
580 SYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RD,
581     SYSCTL_NULL_INT_PTR, 0, "Whether C development supports the C bindings option");
582 SYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RD,
583     SYSCTL_NULL_INT_PTR, 0, "Whether system supports the C development utilities option");
584 SYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RD,
585     SYSCTL_NULL_INT_PTR, 0, "");
586 SYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RD,
587     SYSCTL_NULL_INT_PTR, 0, "Whether system supports FORTRAN development utilities");
588 SYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RD,
589     SYSCTL_NULL_INT_PTR, 0, "Whether system supports FORTRAN runtime utilities");
590 SYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RD,
591     SYSCTL_NULL_INT_PTR, 0, "Whether system supports creation of locales");
592 SYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RD,
593     SYSCTL_NULL_INT_PTR, 0, "Whether system supports software development utilities");
594 SYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RD,
595     SYSCTL_NULL_INT_PTR, 0, "Whether system supports the user portability utilities");
596 SYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RD,
597     SYSCTL_NULL_INT_PTR, 0, "Min Maximum number of streams a process may have open at one time");
598 SYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RD,
599     SYSCTL_NULL_INT_PTR, 0, "Min Maximum number of types supported for timezone names");
600 
601 #include <sys/vnode.h>
602 SYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD,
603     SYSCTL_NULL_INT_PTR, sizeof(struct vnode), "sizeof(struct vnode)");
604 
605 SYSCTL_INT(_debug_sizeof, OID_AUTO, proc, CTLFLAG_RD,
606     SYSCTL_NULL_INT_PTR, sizeof(struct proc), "sizeof(struct proc)");
607 
608 static int
609 sysctl_kern_pid_max(SYSCTL_HANDLER_ARGS)
610 {
611 	int error, pm;
612 
613 	pm = pid_max;
614 	error = sysctl_handle_int(oidp, &pm, 0, req);
615 	if (error || !req->newptr)
616 		return (error);
617 	sx_xlock(&proctree_lock);
618 	sx_xlock(&allproc_lock);
619 
620 	/*
621 	 * Only permit the values less then PID_MAX.
622 	 * As a safety measure, do not allow to limit the pid_max too much.
623 	 */
624 	if (pm < 300 || pm > PID_MAX)
625 		error = EINVAL;
626 	else
627 		pid_max = pm;
628 	sx_xunlock(&allproc_lock);
629 	sx_xunlock(&proctree_lock);
630 	return (error);
631 }
632 SYSCTL_PROC(_kern, OID_AUTO, pid_max, CTLTYPE_INT |
633     CTLFLAG_RWTUN | CTLFLAG_NOFETCH | CTLFLAG_MPSAFE,
634     0, 0, sysctl_kern_pid_max, "I", "Maximum allowed pid");
635 
636 #include <sys/bio.h>
637 #include <sys/buf.h>
638 SYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD,
639     SYSCTL_NULL_INT_PTR, sizeof(struct bio), "sizeof(struct bio)");
640 SYSCTL_INT(_debug_sizeof, OID_AUTO, buf, CTLFLAG_RD,
641     SYSCTL_NULL_INT_PTR, sizeof(struct buf), "sizeof(struct buf)");
642 
643 #include <sys/user.h>
644 SYSCTL_INT(_debug_sizeof, OID_AUTO, kinfo_proc, CTLFLAG_RD,
645     SYSCTL_NULL_INT_PTR, sizeof(struct kinfo_proc), "sizeof(struct kinfo_proc)");
646 
647 /* Used by kernel debuggers. */
648 const int pcb_size = sizeof(struct pcb);
649 SYSCTL_INT(_debug_sizeof, OID_AUTO, pcb, CTLFLAG_RD,
650     SYSCTL_NULL_INT_PTR, sizeof(struct pcb), "sizeof(struct pcb)");
651 
652 /* XXX compatibility, remove for 6.0 */
653 #include <sys/imgact.h>
654 #include <sys/imgact_elf.h>
655 SYSCTL_INT(_kern, OID_AUTO, fallback_elf_brand, CTLFLAG_RW,
656     &__elfN(fallback_brand), sizeof(__elfN(fallback_brand)),
657     "compatibility for kern.fallback_elf_brand");
658