1*459e97e6Sskrll /* $NetBSD: init_sysctl.c,v 1.227 2020/09/20 12:51:57 skrll Exp $ */
213f8d2ceSatatat
313f8d2ceSatatat /*-
4d991fcb3Sad * Copyright (c) 2003, 2007, 2008, 2009 The NetBSD Foundation, Inc.
513f8d2ceSatatat * All rights reserved.
613f8d2ceSatatat *
713f8d2ceSatatat * This code is derived from software contributed to The NetBSD Foundation
877e0b212Sad * by Andrew Brown, and by Andrew Doran.
913f8d2ceSatatat *
1013f8d2ceSatatat * Redistribution and use in source and binary forms, with or without
1113f8d2ceSatatat * modification, are permitted provided that the following conditions
1213f8d2ceSatatat * are met:
1313f8d2ceSatatat * 1. Redistributions of source code must retain the above copyright
1413f8d2ceSatatat * notice, this list of conditions and the following disclaimer.
1513f8d2ceSatatat * 2. Redistributions in binary form must reproduce the above copyright
1613f8d2ceSatatat * notice, this list of conditions and the following disclaimer in the
1713f8d2ceSatatat * documentation and/or other materials provided with the distribution.
1813f8d2ceSatatat *
1913f8d2ceSatatat * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
2013f8d2ceSatatat * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
2113f8d2ceSatatat * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2213f8d2ceSatatat * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
2313f8d2ceSatatat * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
2413f8d2ceSatatat * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
2513f8d2ceSatatat * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
2613f8d2ceSatatat * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
2713f8d2ceSatatat * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
2813f8d2ceSatatat * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
2913f8d2ceSatatat * POSSIBILITY OF SUCH DAMAGE.
3013f8d2ceSatatat */
3113f8d2ceSatatat
328e0c1f15Satatat #include <sys/cdefs.h>
33*459e97e6Sskrll __KERNEL_RCSID(0, "$NetBSD: init_sysctl.c,v 1.227 2020/09/20 12:51:57 skrll Exp $");
348e0c1f15Satatat
3513f8d2ceSatatat #include "opt_sysv.h"
36461a86f9Schristos #include "opt_compat_netbsd.h"
370cc72e51Sapb #include "opt_modular.h"
388778e3b7Smaxv #include "opt_gprof.h"
3913f8d2ceSatatat #include "pty.h"
4013f8d2ceSatatat
4113f8d2ceSatatat #include <sys/param.h>
42*459e97e6Sskrll #include <sys/types.h>
43*459e97e6Sskrll
44*459e97e6Sskrll #include <dev/cons.h>
45*459e97e6Sskrll #include <sys/conf.h>
468e933452Stls #include <sys/cprng.h>
47*459e97e6Sskrll #include <sys/cpu.h>
48*459e97e6Sskrll #include <sys/device.h>
49*459e97e6Sskrll #include <sys/disklabel.h>
50*459e97e6Sskrll #include <sys/errno.h>
51*459e97e6Sskrll #include <sys/exec.h>
52*459e97e6Sskrll #include <sys/filedesc.h>
53*459e97e6Sskrll #include <sys/file.h>
54*459e97e6Sskrll #include <sys/kauth.h>
55*459e97e6Sskrll #include <sys/kernel.h>
56*459e97e6Sskrll #include <sys/kmem.h>
57*459e97e6Sskrll #include <sys/ktrace.h>
5813f8d2ceSatatat #include <sys/mount.h>
5913f8d2ceSatatat #include <sys/namei.h>
60c8d23c47Spgoyette #include <sys/reboot.h>
6113f8d2ceSatatat #include <sys/resource.h>
6213f8d2ceSatatat #include <sys/resourcevar.h>
63*459e97e6Sskrll #include <sys/socketvar.h>
644a302fa0Selad #include <sys/stat.h>
65*459e97e6Sskrll #include <sys/sysctl.h>
66*459e97e6Sskrll #include <sys/systm.h>
67*459e97e6Sskrll #include <sys/tty.h>
68*459e97e6Sskrll #include <sys/unistd.h>
69*459e97e6Sskrll #include <sys/vnode_impl.h> /* For vfs_drainvnodes(). */
70150a6bd8Sfvdl
714a302fa0Selad int security_setidcore_dump;
724a302fa0Selad char security_setidcore_path[MAXPATHLEN] = "/var/crash/%n.core";
734a302fa0Selad uid_t security_setidcore_owner = 0;
744a302fa0Selad gid_t security_setidcore_group = 0;
754a302fa0Selad mode_t security_setidcore_mode = (S_IRUSR|S_IWUSR);
76ec14f2d1Selad
77decc4c2aSpgoyette /*
78decc4c2aSpgoyette * Current status of SysV IPC capability. Initially, these are
79decc4c2aSpgoyette * 0 if the capability is not built-in to the kernel, but can
80decc4c2aSpgoyette * be updated if the appropriate kernel module is (auto)loaded.
81decc4c2aSpgoyette */
82decc4c2aSpgoyette
83decc4c2aSpgoyette int kern_has_sysvmsg = 0;
84decc4c2aSpgoyette int kern_has_sysvshm = 0;
85decc4c2aSpgoyette int kern_has_sysvsem = 0;
86decc4c2aSpgoyette
87b07ec3fcSad static const u_int sysctl_lwpprflagmap[] = {
88934634a1Spavel LPR_DETACHED, L_DETACHED,
89b07ec3fcSad 0
90b07ec3fcSad };
91b07ec3fcSad
9213f8d2ceSatatat /*
9313f8d2ceSatatat * try over estimating by 5 procs/lwps
9413f8d2ceSatatat */
9513f8d2ceSatatat #define KERN_LWPSLOP (5 * sizeof(struct kinfo_lwp))
9613f8d2ceSatatat
9763c45061Sad static int dcopyout(struct lwp *, const void *, void *, size_t);
988a1037a4Smanu
9963c45061Sad static int
dcopyout(struct lwp * l,const void * kaddr,void * uaddr,size_t len)1006d6aefbfSmatt dcopyout(struct lwp *l, const void *kaddr, void *uaddr, size_t len)
1018a1037a4Smanu {
1028a1037a4Smanu int error;
1038a1037a4Smanu
1048a1037a4Smanu error = copyout(kaddr, uaddr, len);
10563c45061Sad ktrmibio(-1, UIO_READ, uaddr, len, error);
1068a1037a4Smanu
1078a1037a4Smanu return error;
1088a1037a4Smanu }
109087fdb90Sad
11013f8d2ceSatatat static int sysctl_kern_maxvnodes(SYSCTLFN_PROTO);
111c8d23c47Spgoyette static int sysctl_kern_messages(SYSCTLFN_PROTO);
1121813308fSthorpej static int sysctl_kern_boottime(SYSCTLFN_PROTO);
113be59b63fSmartin static int sysctl_kern_rtc_offset(SYSCTLFN_PROTO);
11413f8d2ceSatatat static int sysctl_kern_maxproc(SYSCTLFN_PROTO);
11513f8d2ceSatatat static int sysctl_kern_hostid(SYSCTLFN_PROTO);
11613f8d2ceSatatat static int sysctl_kern_defcorename(SYSCTLFN_PROTO);
11713f8d2ceSatatat static int sysctl_kern_cptime(SYSCTLFN_PROTO);
118073a54fdShe #if NPTY > 0
11913f8d2ceSatatat static int sysctl_kern_maxptys(SYSCTLFN_PROTO);
120073a54fdShe #endif /* NPTY > 0 */
12113f8d2ceSatatat static int sysctl_kern_lwp(SYSCTLFN_PROTO);
12213f8d2ceSatatat static int sysctl_kern_forkfsleep(SYSCTLFN_PROTO);
12313f8d2ceSatatat static int sysctl_kern_root_partition(SYSCTLFN_PROTO);
12413f8d2ceSatatat static int sysctl_kern_drivers(SYSCTLFN_PROTO);
1254a302fa0Selad static int sysctl_security_setidcore(SYSCTLFN_PROTO);
1264a302fa0Selad static int sysctl_security_setidcorename(SYSCTLFN_PROTO);
127dfa8191fSchristos static int sysctl_kern_cpid(SYSCTLFN_PROTO);
12813f8d2ceSatatat static int sysctl_hw_usermem(SYSCTLFN_PROTO);
12913f8d2ceSatatat static int sysctl_hw_cnmagic(SYSCTLFN_PROTO);
13013f8d2ceSatatat
13113f8d2ceSatatat static void fill_lwp(struct lwp *l, struct kinfo_lwp *kl);
13213f8d2ceSatatat
13313f8d2ceSatatat /*
13413f8d2ceSatatat * ********************************************************************
13513f8d2ceSatatat * section 1: setup routines
13613f8d2ceSatatat * ********************************************************************
137e221af6aSchristos * These functions are stuffed into a link set for sysctl setup
138e221af6aSchristos * functions. They're never called or referenced from anywhere else.
13913f8d2ceSatatat * ********************************************************************
14013f8d2ceSatatat */
14113f8d2ceSatatat
14213f8d2ceSatatat /*
14313f8d2ceSatatat * this setup routine is a replacement for kern_sysctl()
14413f8d2ceSatatat */
14513f8d2ceSatatat SYSCTL_SETUP(sysctl_kern_setup, "sysctl kern subtree setup")
14613f8d2ceSatatat {
14713f8d2ceSatatat extern int kern_logsigexit; /* defined in kern/kern_sig.c */
14813f8d2ceSatatat extern fixpt_t ccpu; /* defined in kern/kern_synch.c */
14913f8d2ceSatatat extern int dumponpanic; /* defined in kern/subr_prf.c */
1501c8d298bSelad const struct sysctlnode *rnode;
15113f8d2ceSatatat
15219af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
15319af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1543a5915c0Satatat CTLTYPE_INT, "maxvnodes",
1553a5915c0Satatat SYSCTL_DESCR("Maximum number of vnodes"),
15613f8d2ceSatatat sysctl_kern_maxvnodes, 0, NULL, 0,
15713f8d2ceSatatat CTL_KERN, KERN_MAXVNODES, CTL_EOL);
15819af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
15919af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1603a5915c0Satatat CTLTYPE_INT, "maxproc",
1613a5915c0Satatat SYSCTL_DESCR("Maximum number of simultaneous processes"),
16213f8d2ceSatatat sysctl_kern_maxproc, 0, NULL, 0,
16313f8d2ceSatatat CTL_KERN, KERN_MAXPROC, CTL_EOL);
16419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
16519af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1663a5915c0Satatat CTLTYPE_INT, "maxfiles",
1673a5915c0Satatat SYSCTL_DESCR("Maximum number of open files"),
16813f8d2ceSatatat NULL, 0, &maxfiles, 0,
16913f8d2ceSatatat CTL_KERN, KERN_MAXFILES, CTL_EOL);
17019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
17119af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
1723a5915c0Satatat CTLTYPE_INT, "argmax",
1733a5915c0Satatat SYSCTL_DESCR("Maximum number of bytes of arguments to "
1743a5915c0Satatat "execve(2)"),
17513f8d2ceSatatat NULL, ARG_MAX, NULL, 0,
17613f8d2ceSatatat CTL_KERN, KERN_ARGMAX, CTL_EOL);
17719af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
178904ca216Satatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_HEX,
1793a5915c0Satatat CTLTYPE_INT, "hostid",
1803a5915c0Satatat SYSCTL_DESCR("System host ID number"),
18113f8d2ceSatatat sysctl_kern_hostid, 0, NULL, 0,
18213f8d2ceSatatat CTL_KERN, KERN_HOSTID, CTL_EOL);
18319af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
18419af35fdSatatat CTLFLAG_PERMANENT,
1853a5915c0Satatat CTLTYPE_STRUCT, "vnode",
1863a5915c0Satatat SYSCTL_DESCR("System vnode table"),
18713f8d2ceSatatat sysctl_kern_vnode, 0, NULL, 0,
18813f8d2ceSatatat CTL_KERN, KERN_VNODE, CTL_EOL);
18913f8d2ceSatatat #ifndef GPROF
19019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
19119af35fdSatatat CTLFLAG_PERMANENT,
1923a5915c0Satatat CTLTYPE_NODE, "profiling",
1933a5915c0Satatat SYSCTL_DESCR("Profiling information (not available)"),
19413f8d2ceSatatat sysctl_notavail, 0, NULL, 0,
19513f8d2ceSatatat CTL_KERN, KERN_PROF, CTL_EOL);
19613f8d2ceSatatat #endif
19719af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
19819af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
1993a5915c0Satatat CTLTYPE_INT, "posix1version",
2003a5915c0Satatat SYSCTL_DESCR("Version of ISO/IEC 9945 (POSIX 1003.1) "
2013a5915c0Satatat "with which the operating system attempts "
2023a5915c0Satatat "to comply"),
20313f8d2ceSatatat NULL, _POSIX_VERSION, NULL, 0,
20413f8d2ceSatatat CTL_KERN, KERN_POSIX1, CTL_EOL);
20519af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
20619af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
2073a5915c0Satatat CTLTYPE_INT, "ngroups",
2083a5915c0Satatat SYSCTL_DESCR("Maximum number of supplemental groups"),
20913f8d2ceSatatat NULL, NGROUPS_MAX, NULL, 0,
21013f8d2ceSatatat CTL_KERN, KERN_NGROUPS, CTL_EOL);
21119af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
21219af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
2133a5915c0Satatat CTLTYPE_INT, "job_control",
2143a5915c0Satatat SYSCTL_DESCR("Whether job control is available"),
21513f8d2ceSatatat NULL, 1, NULL, 0,
21613f8d2ceSatatat CTL_KERN, KERN_JOB_CONTROL, CTL_EOL);
21719af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
21819af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
2193a5915c0Satatat CTLTYPE_INT, "saved_ids",
2201ec91453Smrg SYSCTL_DESCR("Whether POSIX saved set-group/user ID is "
2213a5915c0Satatat "available"), NULL,
22213f8d2ceSatatat #ifdef _POSIX_SAVED_IDS
22313f8d2ceSatatat 1,
22413f8d2ceSatatat #else /* _POSIX_SAVED_IDS */
22513f8d2ceSatatat 0,
22613f8d2ceSatatat #endif /* _POSIX_SAVED_IDS */
22713f8d2ceSatatat NULL, 0, CTL_KERN, KERN_SAVED_IDS, CTL_EOL);
22819af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
2297ab65de0Sapb CTLFLAG_PERMANENT|CTLFLAG_HEX,
2307ab65de0Sapb CTLTYPE_INT, "boothowto",
2317ab65de0Sapb SYSCTL_DESCR("Flags from boot loader"),
2327ab65de0Sapb NULL, 0, &boothowto, sizeof(boothowto),
2337ab65de0Sapb CTL_KERN, CTL_CREATE, CTL_EOL);
2347ab65de0Sapb sysctl_createv(clog, 0, NULL, NULL,
23519af35fdSatatat CTLFLAG_PERMANENT,
2363a5915c0Satatat CTLTYPE_STRUCT, "boottime",
2373a5915c0Satatat SYSCTL_DESCR("System boot time"),
2381813308fSthorpej sysctl_kern_boottime, 0, NULL, sizeof(struct timespec),
23913f8d2ceSatatat CTL_KERN, KERN_BOOTTIME, CTL_EOL);
24019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
24119af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
2423a5915c0Satatat CTLTYPE_INT, "maxpartitions",
2433a5915c0Satatat SYSCTL_DESCR("Maximum number of partitions allowed per "
2443a5915c0Satatat "disk"),
24513f8d2ceSatatat NULL, MAXPARTITIONS, NULL, 0,
24613f8d2ceSatatat CTL_KERN, KERN_MAXPARTITIONS, CTL_EOL);
24719af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
24819af35fdSatatat CTLFLAG_PERMANENT,
24913f8d2ceSatatat CTLTYPE_STRUCT, "timex", NULL,
25013f8d2ceSatatat sysctl_notavail, 0, NULL, 0,
25113f8d2ceSatatat CTL_KERN, KERN_TIMEX, CTL_EOL);
25219af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
25319af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
2543a5915c0Satatat CTLTYPE_INT, "rtc_offset",
2553a5915c0Satatat SYSCTL_DESCR("Offset of real time clock from UTC in "
2563a5915c0Satatat "minutes"),
257be59b63fSmartin sysctl_kern_rtc_offset, 0, &rtc_offset, 0,
25813f8d2ceSatatat CTL_KERN, KERN_RTC_OFFSET, CTL_EOL);
25919af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
26019af35fdSatatat CTLFLAG_PERMANENT,
2613a5915c0Satatat CTLTYPE_STRING, "root_device",
2623a5915c0Satatat SYSCTL_DESCR("Name of the root device"),
26313f8d2ceSatatat sysctl_root_device, 0, NULL, 0,
26413f8d2ceSatatat CTL_KERN, KERN_ROOT_DEVICE, CTL_EOL);
26519af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
26619af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
2673a5915c0Satatat CTLTYPE_INT, "fsync",
2683a5915c0Satatat SYSCTL_DESCR("Whether the POSIX 1003.1b File "
2693a5915c0Satatat "Synchronization Option is available on "
2703a5915c0Satatat "this system"),
27113f8d2ceSatatat NULL, 1, NULL, 0,
27213f8d2ceSatatat CTL_KERN, KERN_FSYNC, CTL_EOL);
27319af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
274df031f1eSchristos CTLFLAG_PERMANENT,
275df031f1eSchristos CTLTYPE_NODE, "ipc",
276df031f1eSchristos SYSCTL_DESCR("SysV IPC options"),
277df031f1eSchristos NULL, 0, NULL, 0,
278df031f1eSchristos CTL_KERN, KERN_SYSVIPC, CTL_EOL);
279df031f1eSchristos sysctl_createv(clog, 0, NULL, NULL,
280decc4c2aSpgoyette CTLFLAG_PERMANENT|CTLFLAG_READONLY,
2813a5915c0Satatat CTLTYPE_INT, "sysvmsg",
2823a5915c0Satatat SYSCTL_DESCR("System V style message support available"),
283decc4c2aSpgoyette NULL, 0, &kern_has_sysvmsg, sizeof(int),
284decc4c2aSpgoyette CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_MSG, CTL_EOL);
28519af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
286decc4c2aSpgoyette CTLFLAG_PERMANENT|CTLFLAG_READONLY,
2873a5915c0Satatat CTLTYPE_INT, "sysvsem",
2883a5915c0Satatat SYSCTL_DESCR("System V style semaphore support "
289decc4c2aSpgoyette "available"),
290decc4c2aSpgoyette NULL, 0, &kern_has_sysvsem, sizeof(int),
291decc4c2aSpgoyette CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SEM, CTL_EOL);
29219af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
293decc4c2aSpgoyette CTLFLAG_PERMANENT|CTLFLAG_READONLY,
2943a5915c0Satatat CTLTYPE_INT, "sysvshm",
2953a5915c0Satatat SYSCTL_DESCR("System V style shared memory support "
296decc4c2aSpgoyette "available"),
297decc4c2aSpgoyette NULL, 0, &kern_has_sysvshm, sizeof(int),
298decc4c2aSpgoyette CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SHM, CTL_EOL);
29919af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
30019af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3013a5915c0Satatat CTLTYPE_INT, "synchronized_io",
3023a5915c0Satatat SYSCTL_DESCR("Whether the POSIX 1003.1b Synchronized "
3033a5915c0Satatat "I/O Option is available on this system"),
30413f8d2ceSatatat NULL, 1, NULL, 0,
30513f8d2ceSatatat CTL_KERN, KERN_SYNCHRONIZED_IO, CTL_EOL);
30619af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
30719af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3083a5915c0Satatat CTLTYPE_INT, "iov_max",
3093a5915c0Satatat SYSCTL_DESCR("Maximum number of iovec structures per "
3103a5915c0Satatat "process"),
31113f8d2ceSatatat NULL, IOV_MAX, NULL, 0,
31213f8d2ceSatatat CTL_KERN, KERN_IOV_MAX, CTL_EOL);
31319af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
31419af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3153a5915c0Satatat CTLTYPE_INT, "mapped_files",
3163a5915c0Satatat SYSCTL_DESCR("Whether the POSIX 1003.1b Memory Mapped "
3173a5915c0Satatat "Files Option is available on this system"),
31813f8d2ceSatatat NULL, 1, NULL, 0,
31913f8d2ceSatatat CTL_KERN, KERN_MAPPED_FILES, CTL_EOL);
32019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
32119af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3223a5915c0Satatat CTLTYPE_INT, "memlock",
3233a5915c0Satatat SYSCTL_DESCR("Whether the POSIX 1003.1b Process Memory "
3243a5915c0Satatat "Locking Option is available on this "
3253a5915c0Satatat "system"),
32613f8d2ceSatatat NULL, 1, NULL, 0,
32713f8d2ceSatatat CTL_KERN, KERN_MEMLOCK, CTL_EOL);
32819af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
32919af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3303a5915c0Satatat CTLTYPE_INT, "memlock_range",
3313a5915c0Satatat SYSCTL_DESCR("Whether the POSIX 1003.1b Range Memory "
3323a5915c0Satatat "Locking Option is available on this "
3333a5915c0Satatat "system"),
33413f8d2ceSatatat NULL, 1, NULL, 0,
33513f8d2ceSatatat CTL_KERN, KERN_MEMLOCK_RANGE, CTL_EOL);
33619af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
33719af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3383a5915c0Satatat CTLTYPE_INT, "memory_protection",
3393a5915c0Satatat SYSCTL_DESCR("Whether the POSIX 1003.1b Memory "
3403a5915c0Satatat "Protection Option is available on this "
3413a5915c0Satatat "system"),
34213f8d2ceSatatat NULL, 1, NULL, 0,
34313f8d2ceSatatat CTL_KERN, KERN_MEMORY_PROTECTION, CTL_EOL);
34419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
34519af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3463a5915c0Satatat CTLTYPE_INT, "login_name_max",
3473a5915c0Satatat SYSCTL_DESCR("Maximum login name length"),
34813f8d2ceSatatat NULL, LOGIN_NAME_MAX, NULL, 0,
34913f8d2ceSatatat CTL_KERN, KERN_LOGIN_NAME_MAX, CTL_EOL);
35019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
35119af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
3523a5915c0Satatat CTLTYPE_STRING, "defcorename",
3533a5915c0Satatat SYSCTL_DESCR("Default core file name"),
35413f8d2ceSatatat sysctl_kern_defcorename, 0, defcorename, MAXPATHLEN,
35513f8d2ceSatatat CTL_KERN, KERN_DEFCORENAME, CTL_EOL);
35619af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
35719af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
3583a5915c0Satatat CTLTYPE_INT, "logsigexit",
3593a5915c0Satatat SYSCTL_DESCR("Log process exit when caused by signals"),
36013f8d2ceSatatat NULL, 0, &kern_logsigexit, 0,
36113f8d2ceSatatat CTL_KERN, KERN_LOGSIGEXIT, CTL_EOL);
36219af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
36319af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3643a5915c0Satatat CTLTYPE_INT, "fscale",
3653a5915c0Satatat SYSCTL_DESCR("Kernel fixed-point scale factor"),
36613f8d2ceSatatat NULL, FSCALE, NULL, 0,
36713f8d2ceSatatat CTL_KERN, KERN_FSCALE, CTL_EOL);
36819af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
36919af35fdSatatat CTLFLAG_PERMANENT,
3703a5915c0Satatat CTLTYPE_INT, "ccpu",
3713a5915c0Satatat SYSCTL_DESCR("Scheduler exponential decay value"),
37213f8d2ceSatatat NULL, 0, &ccpu, 0,
37313f8d2ceSatatat CTL_KERN, KERN_CCPU, CTL_EOL);
37419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
37519af35fdSatatat CTLFLAG_PERMANENT,
3763a5915c0Satatat CTLTYPE_STRUCT, "cp_time",
3773a5915c0Satatat SYSCTL_DESCR("Clock ticks spent in different CPU states"),
37813f8d2ceSatatat sysctl_kern_cptime, 0, NULL, 0,
37913f8d2ceSatatat CTL_KERN, KERN_CP_TIME, CTL_EOL);
38019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
38119af35fdSatatat CTLFLAG_PERMANENT,
3823a5915c0Satatat CTLTYPE_STRUCT, "consdev",
3833a5915c0Satatat SYSCTL_DESCR("Console device"),
38413f8d2ceSatatat sysctl_consdev, 0, NULL, sizeof(dev_t),
38513f8d2ceSatatat CTL_KERN, KERN_CONSDEV, CTL_EOL);
38613f8d2ceSatatat #if NPTY > 0
38719af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
38819af35fdSatatat CTLFLAG_PERMANENT,
3893a5915c0Satatat CTLTYPE_INT, "maxptys",
3903a5915c0Satatat SYSCTL_DESCR("Maximum number of pseudo-ttys"),
39113f8d2ceSatatat sysctl_kern_maxptys, 0, NULL, 0,
39213f8d2ceSatatat CTL_KERN, KERN_MAXPTYS, CTL_EOL);
39313f8d2ceSatatat #endif /* NPTY > 0 */
39419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
39519af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
3963a5915c0Satatat CTLTYPE_INT, "maxphys",
3973a5915c0Satatat SYSCTL_DESCR("Maximum raw I/O transfer size"),
39813f8d2ceSatatat NULL, MAXPHYS, NULL, 0,
39913f8d2ceSatatat CTL_KERN, KERN_MAXPHYS, CTL_EOL);
40019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
40119af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4023a5915c0Satatat CTLTYPE_INT, "monotonic_clock",
4033a5915c0Satatat SYSCTL_DESCR("Implementation version of the POSIX "
4043a5915c0Satatat "1003.1b Monotonic Clock Option"),
40513f8d2ceSatatat /* XXX _POSIX_VERSION */
40613f8d2ceSatatat NULL, _POSIX_MONOTONIC_CLOCK, NULL, 0,
40713f8d2ceSatatat CTL_KERN, KERN_MONOTONIC_CLOCK, CTL_EOL);
40819af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
40919af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4103a5915c0Satatat CTLTYPE_INT, "labelsector",
4113a5915c0Satatat SYSCTL_DESCR("Sector number containing the disklabel"),
41213f8d2ceSatatat NULL, LABELSECTOR, NULL, 0,
41313f8d2ceSatatat CTL_KERN, KERN_LABELSECTOR, CTL_EOL);
41419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
41519af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4163a5915c0Satatat CTLTYPE_INT, "labeloffset",
4173a5915c0Satatat SYSCTL_DESCR("Offset of the disklabel within the "
4183a5915c0Satatat "sector"),
41913f8d2ceSatatat NULL, LABELOFFSET, NULL, 0,
42013f8d2ceSatatat CTL_KERN, KERN_LABELOFFSET, CTL_EOL);
42119af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
422509fd41bSbouyer CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
423509fd41bSbouyer CTLTYPE_INT, "labelusesmbr",
424509fd41bSbouyer SYSCTL_DESCR("disklabel is inside MBR partition"),
425509fd41bSbouyer NULL, LABELUSESMBR, NULL, 0,
426509fd41bSbouyer CTL_KERN, CTL_CREATE, CTL_EOL);
427509fd41bSbouyer sysctl_createv(clog, 0, NULL, NULL,
42819af35fdSatatat CTLFLAG_PERMANENT,
4293a5915c0Satatat CTLTYPE_NODE, "lwp",
4303a5915c0Satatat SYSCTL_DESCR("System-wide LWP information"),
43113f8d2ceSatatat sysctl_kern_lwp, 0, NULL, 0,
43213f8d2ceSatatat CTL_KERN, KERN_LWP, CTL_EOL);
43319af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
43419af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4353a5915c0Satatat CTLTYPE_INT, "forkfsleep",
4363a5915c0Satatat SYSCTL_DESCR("Milliseconds to sleep on fork failure due "
4373a5915c0Satatat "to process limits"),
43813f8d2ceSatatat sysctl_kern_forkfsleep, 0, NULL, 0,
43913f8d2ceSatatat CTL_KERN, KERN_FORKFSLEEP, CTL_EOL);
44019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
44119af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4423a5915c0Satatat CTLTYPE_INT, "posix_threads",
4433a5915c0Satatat SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
4443a5915c0Satatat "Threads option to which the system "
4453a5915c0Satatat "attempts to conform"),
44613f8d2ceSatatat /* XXX _POSIX_VERSION */
44713f8d2ceSatatat NULL, _POSIX_THREADS, NULL, 0,
44813f8d2ceSatatat CTL_KERN, KERN_POSIX_THREADS, CTL_EOL);
44919af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
450f7d40cc5Sjoerg CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4513a5915c0Satatat CTLTYPE_INT, "posix_semaphores",
4523a5915c0Satatat SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
4533a5915c0Satatat "Semaphores option to which the system "
4543a5915c0Satatat "attempts to conform"), NULL,
455f7d40cc5Sjoerg 200112, NULL, 0,
456f7d40cc5Sjoerg CTL_KERN, KERN_POSIX_SEMAPHORES, CTL_EOL);
45719af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
45819af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4593a5915c0Satatat CTLTYPE_INT, "posix_barriers",
4603a5915c0Satatat SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
4613a5915c0Satatat "Barriers option to which the system "
4623a5915c0Satatat "attempts to conform"),
46313f8d2ceSatatat /* XXX _POSIX_VERSION */
46413f8d2ceSatatat NULL, _POSIX_BARRIERS, NULL, 0,
46513f8d2ceSatatat CTL_KERN, KERN_POSIX_BARRIERS, CTL_EOL);
46619af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
46719af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4683a5915c0Satatat CTLTYPE_INT, "posix_timers",
4693a5915c0Satatat SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
4703a5915c0Satatat "Timers option to which the system "
4713a5915c0Satatat "attempts to conform"),
47213f8d2ceSatatat /* XXX _POSIX_VERSION */
47313f8d2ceSatatat NULL, _POSIX_TIMERS, NULL, 0,
47413f8d2ceSatatat CTL_KERN, KERN_POSIX_TIMERS, CTL_EOL);
47519af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
47619af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4773a5915c0Satatat CTLTYPE_INT, "posix_spin_locks",
4783a5915c0Satatat SYSCTL_DESCR("Version of IEEE Std 1003.1 and its Spin "
4793a5915c0Satatat "Locks option to which the system attempts "
4803a5915c0Satatat "to conform"),
48113f8d2ceSatatat /* XXX _POSIX_VERSION */
48213f8d2ceSatatat NULL, _POSIX_SPIN_LOCKS, NULL, 0,
48313f8d2ceSatatat CTL_KERN, KERN_POSIX_SPIN_LOCKS, CTL_EOL);
48419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
48519af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
4863a5915c0Satatat CTLTYPE_INT, "posix_reader_writer_locks",
4873a5915c0Satatat SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
4883a5915c0Satatat "Read-Write Locks option to which the "
4893a5915c0Satatat "system attempts to conform"),
49013f8d2ceSatatat /* XXX _POSIX_VERSION */
49113f8d2ceSatatat NULL, _POSIX_READER_WRITER_LOCKS, NULL, 0,
49213f8d2ceSatatat CTL_KERN, KERN_POSIX_READER_WRITER_LOCKS, CTL_EOL);
49319af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
49419af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4953a5915c0Satatat CTLTYPE_INT, "dump_on_panic",
4963a5915c0Satatat SYSCTL_DESCR("Perform a crash dump on system panic"),
49713f8d2ceSatatat NULL, 0, &dumponpanic, 0,
49813f8d2ceSatatat CTL_KERN, KERN_DUMP_ON_PANIC, CTL_EOL);
49919af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
50019af35fdSatatat CTLFLAG_PERMANENT,
5013a5915c0Satatat CTLTYPE_INT, "root_partition",
5023a5915c0Satatat SYSCTL_DESCR("Root partition on the root device"),
50313f8d2ceSatatat sysctl_kern_root_partition, 0, NULL, 0,
50413f8d2ceSatatat CTL_KERN, KERN_ROOT_PARTITION, CTL_EOL);
50519af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
50619af35fdSatatat CTLFLAG_PERMANENT,
5073a5915c0Satatat CTLTYPE_STRUCT, "drivers",
5083a5915c0Satatat SYSCTL_DESCR("List of all drivers with block and "
5093a5915c0Satatat "character device numbers"),
51013f8d2ceSatatat sysctl_kern_drivers, 0, NULL, 0,
51113f8d2ceSatatat CTL_KERN, KERN_DRIVERS, CTL_EOL);
512529b14ddSatatat sysctl_createv(clog, 0, NULL, NULL,
513529b14ddSatatat CTLFLAG_PERMANENT,
514dfa8191fSchristos CTLTYPE_STRUCT, "cp_id",
515dfa8191fSchristos SYSCTL_DESCR("Mapping of CPU number to CPU id"),
516dfa8191fSchristos sysctl_kern_cpid, 0, NULL, 0,
517dfa8191fSchristos CTL_KERN, KERN_CP_ID, CTL_EOL);
5181c8d298bSelad sysctl_createv(clog, 0, NULL, &rnode,
5191c8d298bSelad CTLFLAG_PERMANENT,
5201c8d298bSelad CTLTYPE_NODE, "coredump",
5211c8d298bSelad SYSCTL_DESCR("Coredump settings."),
5221c8d298bSelad NULL, 0, NULL, 0,
5231c8d298bSelad CTL_KERN, CTL_CREATE, CTL_EOL);
5241c8d298bSelad sysctl_createv(clog, 0, &rnode, &rnode,
5251c8d298bSelad CTLFLAG_PERMANENT,
5261c8d298bSelad CTLTYPE_NODE, "setid",
5271c8d298bSelad SYSCTL_DESCR("Set-id processes' coredump settings."),
5281c8d298bSelad NULL, 0, NULL, 0,
5291c8d298bSelad CTL_CREATE, CTL_EOL);
5301c8d298bSelad sysctl_createv(clog, 0, &rnode, NULL,
5311c8d298bSelad CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
5321c8d298bSelad CTLTYPE_INT, "dump",
5331c8d298bSelad SYSCTL_DESCR("Allow set-id processes to dump core."),
5341c8d298bSelad sysctl_security_setidcore, 0, &security_setidcore_dump,
5351c8d298bSelad sizeof(security_setidcore_dump),
5361c8d298bSelad CTL_CREATE, CTL_EOL);
5371c8d298bSelad sysctl_createv(clog, 0, &rnode, NULL,
5381c8d298bSelad CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
5391c8d298bSelad CTLTYPE_STRING, "path",
5401c8d298bSelad SYSCTL_DESCR("Path pattern for set-id coredumps."),
5411c8d298bSelad sysctl_security_setidcorename, 0,
5427c283e77Sdsl security_setidcore_path,
5431c8d298bSelad sizeof(security_setidcore_path),
5441c8d298bSelad CTL_CREATE, CTL_EOL);
5451c8d298bSelad sysctl_createv(clog, 0, &rnode, NULL,
5461c8d298bSelad CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
5471c8d298bSelad CTLTYPE_INT, "owner",
5481c8d298bSelad SYSCTL_DESCR("Owner id for set-id processes' cores."),
5491c8d298bSelad sysctl_security_setidcore, 0, &security_setidcore_owner,
5501c8d298bSelad 0,
5511c8d298bSelad CTL_CREATE, CTL_EOL);
5521c8d298bSelad sysctl_createv(clog, 0, &rnode, NULL,
5531c8d298bSelad CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
5541c8d298bSelad CTLTYPE_INT, "group",
5551c8d298bSelad SYSCTL_DESCR("Group id for set-id processes' cores."),
5561c8d298bSelad sysctl_security_setidcore, 0, &security_setidcore_group,
5571c8d298bSelad 0,
5581c8d298bSelad CTL_CREATE, CTL_EOL);
5591c8d298bSelad sysctl_createv(clog, 0, &rnode, NULL,
5601c8d298bSelad CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
5611c8d298bSelad CTLTYPE_INT, "mode",
5621c8d298bSelad SYSCTL_DESCR("Mode for set-id processes' cores."),
5631c8d298bSelad sysctl_security_setidcore, 0, &security_setidcore_mode,
5641c8d298bSelad 0,
5651c8d298bSelad CTL_CREATE, CTL_EOL);
566fc7511b0Swrstuden sysctl_createv(clog, 0, NULL, NULL,
567154d3024Srmind CTLFLAG_IMMEDIATE|CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
568fc7511b0Swrstuden CTLTYPE_INT, "no_sa_support",
5697fad4f26Schristos SYSCTL_DESCR("0 if the kernel supports SA, otherwise "
5707fad4f26Schristos "it doesn't"),
571154d3024Srmind NULL, 1, NULL, 0,
5727fad4f26Schristos CTL_KERN, CTL_CREATE, CTL_EOL);
573727810e9Sapb sysctl_createv(clog, 0, NULL, NULL,
574727810e9Sapb CTLFLAG_PERMANENT,
575727810e9Sapb CTLTYPE_STRING, "configname",
576727810e9Sapb SYSCTL_DESCR("Name of config file"),
577727810e9Sapb NULL, 0, __UNCONST(kernel_ident), 0,
578727810e9Sapb CTL_KERN, CTL_CREATE, CTL_EOL);
579727810e9Sapb sysctl_createv(clog, 0, NULL, NULL,
580727810e9Sapb CTLFLAG_PERMANENT,
581727810e9Sapb CTLTYPE_STRING, "buildinfo",
582727810e9Sapb SYSCTL_DESCR("Information from build environment"),
583727810e9Sapb NULL, 0, __UNCONST(buildinfo), 0,
584727810e9Sapb CTL_KERN, CTL_CREATE, CTL_EOL);
585c8d23c47Spgoyette sysctl_createv(clog, 0, NULL, NULL,
586c8d23c47Spgoyette CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
587c8d23c47Spgoyette CTLTYPE_INT, "messages",
588c8d23c47Spgoyette SYSCTL_DESCR("Kernel message verbosity"),
589c8d23c47Spgoyette sysctl_kern_messages, 0, NULL, 0,
590c8d23c47Spgoyette CTL_KERN, CTL_CREATE, CTL_EOL);
59113f8d2ceSatatat }
59213f8d2ceSatatat
593abb480b2Spooka SYSCTL_SETUP(sysctl_hw_misc_setup, "sysctl hw subtree misc setup")
59413f8d2ceSatatat {
59513f8d2ceSatatat
59619af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
59719af35fdSatatat CTLFLAG_PERMANENT,
5983a5915c0Satatat CTLTYPE_INT, "usermem",
5993a5915c0Satatat SYSCTL_DESCR("Bytes of non-kernel memory"),
60013f8d2ceSatatat sysctl_hw_usermem, 0, NULL, 0,
60113f8d2ceSatatat CTL_HW, HW_USERMEM, CTL_EOL);
60219af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
60319af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_HEX,
6043a5915c0Satatat CTLTYPE_STRING, "cnmagic",
6053a5915c0Satatat SYSCTL_DESCR("Console magic key sequence"),
60613f8d2ceSatatat sysctl_hw_cnmagic, 0, NULL, CNS_LEN,
60713f8d2ceSatatat CTL_HW, HW_CNMAGIC, CTL_EOL);
60819af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
60919af35fdSatatat CTLFLAG_PERMANENT,
6103a5915c0Satatat CTLTYPE_QUAD, "usermem64",
6113a5915c0Satatat SYSCTL_DESCR("Bytes of non-kernel memory"),
61213f8d2ceSatatat sysctl_hw_usermem, 0, NULL, 0,
61313f8d2ceSatatat CTL_HW, HW_USERMEM64, CTL_EOL);
61413f8d2ceSatatat }
61513f8d2ceSatatat
61613f8d2ceSatatat #ifdef DEBUG
61713f8d2ceSatatat /*
61813f8d2ceSatatat * Debugging related system variables.
61913f8d2ceSatatat */
62013f8d2ceSatatat struct ctldebug /* debug0, */ /* debug1, */ debug2, debug3, debug4;
62113f8d2ceSatatat struct ctldebug debug5, debug6, debug7, debug8, debug9;
62213f8d2ceSatatat struct ctldebug debug10, debug11, debug12, debug13, debug14;
62313f8d2ceSatatat struct ctldebug debug15, debug16, debug17, debug18, debug19;
624b949e7a1Smrg static struct ctldebug *debugvars[] = {
62513f8d2ceSatatat &debug0, &debug1, &debug2, &debug3, &debug4,
62613f8d2ceSatatat &debug5, &debug6, &debug7, &debug8, &debug9,
62713f8d2ceSatatat &debug10, &debug11, &debug12, &debug13, &debug14,
62813f8d2ceSatatat &debug15, &debug16, &debug17, &debug18, &debug19,
62913f8d2ceSatatat };
63013f8d2ceSatatat
63113f8d2ceSatatat /*
63213f8d2ceSatatat * this setup routine is a replacement for debug_sysctl()
63313f8d2ceSatatat *
63413f8d2ceSatatat * note that it creates several nodes per defined debug variable
63513f8d2ceSatatat */
63613f8d2ceSatatat SYSCTL_SETUP(sysctl_debug_setup, "sysctl debug subtree setup")
63713f8d2ceSatatat {
63813f8d2ceSatatat struct ctldebug *cdp;
63913f8d2ceSatatat char nodename[20];
64013f8d2ceSatatat int i;
64113f8d2ceSatatat
64213f8d2ceSatatat /*
64313f8d2ceSatatat * two ways here:
64413f8d2ceSatatat *
64513f8d2ceSatatat * the "old" way (debug.name -> value) which was emulated by
64613f8d2ceSatatat * the sysctl(8) binary
64713f8d2ceSatatat *
64813f8d2ceSatatat * the new way, which the sysctl(8) binary was actually using
64913f8d2ceSatatat
65013f8d2ceSatatat node debug
65113f8d2ceSatatat node debug.0
65213f8d2ceSatatat string debug.0.name
65313f8d2ceSatatat int debug.0.value
65413f8d2ceSatatat int debug.name
65513f8d2ceSatatat
65613f8d2ceSatatat */
65713f8d2ceSatatat
658b949e7a1Smrg for (i = 0; i < __arraycount(debugvars); i++) {
65913f8d2ceSatatat cdp = debugvars[i];
66013f8d2ceSatatat if (cdp->debugname == NULL || cdp->debugvar == NULL)
66113f8d2ceSatatat continue;
66213f8d2ceSatatat
66313f8d2ceSatatat snprintf(nodename, sizeof(nodename), "debug%d", i);
66419af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
66519af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_HIDDEN,
66613f8d2ceSatatat CTLTYPE_NODE, nodename, NULL,
66713f8d2ceSatatat NULL, 0, NULL, 0,
66813f8d2ceSatatat CTL_DEBUG, i, CTL_EOL);
66919af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
67019af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_HIDDEN,
67113f8d2ceSatatat CTLTYPE_STRING, "name", NULL,
672efb69433Schristos /*XXXUNCONST*/
673efb69433Schristos NULL, 0, __UNCONST(cdp->debugname), 0,
67413f8d2ceSatatat CTL_DEBUG, i, CTL_DEBUG_NAME, CTL_EOL);
67519af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
67619af35fdSatatat CTLFLAG_PERMANENT|CTLFLAG_HIDDEN,
67713f8d2ceSatatat CTLTYPE_INT, "value", NULL,
67813f8d2ceSatatat NULL, 0, cdp->debugvar, 0,
67913f8d2ceSatatat CTL_DEBUG, i, CTL_DEBUG_VALUE, CTL_EOL);
68019af35fdSatatat sysctl_createv(clog, 0, NULL, NULL,
68119af35fdSatatat CTLFLAG_PERMANENT,
68213f8d2ceSatatat CTLTYPE_INT, cdp->debugname, NULL,
68313f8d2ceSatatat NULL, 0, cdp->debugvar, 0,
68413f8d2ceSatatat CTL_DEBUG, CTL_CREATE, CTL_EOL);
68513f8d2ceSatatat }
68613f8d2ceSatatat }
68713f8d2ceSatatat #endif /* DEBUG */
68813f8d2ceSatatat
68913f8d2ceSatatat /*
69013f8d2ceSatatat * ********************************************************************
69113f8d2ceSatatat * section 2: private node-specific helper routines.
69213f8d2ceSatatat * ********************************************************************
69313f8d2ceSatatat */
69413f8d2ceSatatat
69513f8d2ceSatatat /*
696e221af6aSchristos * sysctl helper routine for kern.maxvnodes. Drain vnodes if
6978b9614a4Syamt * new value is lower than desiredvnodes and then calls reinit
69813f8d2ceSatatat * routines that needs to adjust to the new value.
69913f8d2ceSatatat */
70013f8d2ceSatatat static int
sysctl_kern_maxvnodes(SYSCTLFN_ARGS)70113f8d2ceSatatat sysctl_kern_maxvnodes(SYSCTLFN_ARGS)
70213f8d2ceSatatat {
703a9c4cefeSad int error, new_vnodes, old_vnodes, new_max;
70413f8d2ceSatatat struct sysctlnode node;
70513f8d2ceSatatat
70613f8d2ceSatatat new_vnodes = desiredvnodes;
70713f8d2ceSatatat node = *rnode;
70813f8d2ceSatatat node.sysctl_data = &new_vnodes;
70913f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
71013f8d2ceSatatat if (error || newp == NULL)
71113f8d2ceSatatat return (error);
71213f8d2ceSatatat
7134fb4590bSmlelstv /*
7144fb4590bSmlelstv * sysctl passes down unsigned values, require them
7154fb4590bSmlelstv * to be positive
7164fb4590bSmlelstv */
7174fb4590bSmlelstv if (new_vnodes <= 0)
7184fb4590bSmlelstv return (EINVAL);
7194fb4590bSmlelstv
720482b2587Spara /* Limits: 75% of kmem and physical memory. */
721482b2587Spara new_max = calc_cache_size(vmem_size(kmem_arena, VMEM_FREE|VMEM_ALLOC),
722482b2587Spara 75, 75) / VNODE_COST;
723a9c4cefeSad if (new_vnodes > new_max)
724a9c4cefeSad new_vnodes = new_max;
725a9c4cefeSad
7264dd42306Syamt old_vnodes = desiredvnodes;
72713f8d2ceSatatat desiredvnodes = new_vnodes;
7287b4242abShannken error = vfs_drainvnodes();
7294dd42306Syamt if (error) {
7304dd42306Syamt desiredvnodes = old_vnodes;
7314dd42306Syamt return (error);
7324dd42306Syamt }
73313f8d2ceSatatat vfs_reinit();
73413f8d2ceSatatat
73513f8d2ceSatatat return (0);
73613f8d2ceSatatat }
73713f8d2ceSatatat
73813f8d2ceSatatat /*
739c8d23c47Spgoyette * sysctl helper routine for kern.messages.
740c8d23c47Spgoyette * Alters boothowto to display kernel messages in increasing verbosity
741c8d23c47Spgoyette * from 0 to 4.
742c8d23c47Spgoyette */
743c8d23c47Spgoyette
744c8d23c47Spgoyette #define MAXMESSAGES 4
745c8d23c47Spgoyette static int
sysctl_kern_messages(SYSCTLFN_ARGS)746c8d23c47Spgoyette sysctl_kern_messages(SYSCTLFN_ARGS)
747c8d23c47Spgoyette {
748c8d23c47Spgoyette int error, messageverbose, messagemask, newboothowto;
749c8d23c47Spgoyette struct sysctlnode node;
750c8d23c47Spgoyette
751c8d23c47Spgoyette messagemask = (AB_NORMAL|AB_QUIET|AB_SILENT|AB_VERBOSE|AB_DEBUG);
752c8d23c47Spgoyette switch (boothowto & messagemask) {
753c8d23c47Spgoyette case AB_SILENT:
754c8d23c47Spgoyette messageverbose = 0;
755c8d23c47Spgoyette break;
756c8d23c47Spgoyette case AB_QUIET:
757c8d23c47Spgoyette messageverbose = 1;
758c8d23c47Spgoyette break;
759c8d23c47Spgoyette case AB_VERBOSE:
760c8d23c47Spgoyette messageverbose = 3;
761c8d23c47Spgoyette break;
762c8d23c47Spgoyette case AB_DEBUG:
763c8d23c47Spgoyette messageverbose = 4;
764c8d23c47Spgoyette break;
765c8d23c47Spgoyette case AB_NORMAL:
766c8d23c47Spgoyette default:
767c8d23c47Spgoyette messageverbose = 2;
768c8d23c47Spgoyette }
769c8d23c47Spgoyette
770c8d23c47Spgoyette node = *rnode;
771c8d23c47Spgoyette node.sysctl_data = &messageverbose;
772c8d23c47Spgoyette error = sysctl_lookup(SYSCTLFN_CALL(&node));
773c8d23c47Spgoyette if (error || newp == NULL)
774c8d23c47Spgoyette return (error);
775c8d23c47Spgoyette if (messageverbose < 0 || messageverbose > MAXMESSAGES)
776c8d23c47Spgoyette return EINVAL;
777c8d23c47Spgoyette
778c8d23c47Spgoyette /* Set boothowto */
779c8d23c47Spgoyette newboothowto = boothowto & ~messagemask;
780c8d23c47Spgoyette
781c8d23c47Spgoyette switch (messageverbose) {
782c8d23c47Spgoyette case 0:
783c8d23c47Spgoyette newboothowto |= AB_SILENT;
784c8d23c47Spgoyette break;
785c8d23c47Spgoyette case 1:
786c8d23c47Spgoyette newboothowto |= AB_QUIET;
787c8d23c47Spgoyette break;
788c8d23c47Spgoyette case 3:
789c8d23c47Spgoyette newboothowto |= AB_VERBOSE;
790c8d23c47Spgoyette break;
791c8d23c47Spgoyette case 4:
792c8d23c47Spgoyette newboothowto |= AB_DEBUG;
793c8d23c47Spgoyette break;
794c8d23c47Spgoyette case 2:
795c8d23c47Spgoyette default: /* Messages default to normal. */
796c8d23c47Spgoyette break;
797c8d23c47Spgoyette }
798c8d23c47Spgoyette
799c8d23c47Spgoyette boothowto = newboothowto;
800c8d23c47Spgoyette
801c8d23c47Spgoyette return (0);
802c8d23c47Spgoyette }
803c8d23c47Spgoyette
804c8d23c47Spgoyette /*
8051813308fSthorpej * sysctl helper routine for the kern.boottime node
8061813308fSthorpej */
8071813308fSthorpej static int
sysctl_kern_boottime(SYSCTLFN_ARGS)8081813308fSthorpej sysctl_kern_boottime(SYSCTLFN_ARGS)
8091813308fSthorpej {
8101813308fSthorpej struct sysctlnode node;
8111813308fSthorpej struct timespec ts;
8121813308fSthorpej
8131813308fSthorpej getnanoboottime(&ts);
8141813308fSthorpej node = *rnode;
8151813308fSthorpej node.sysctl_data = &ts;
8161813308fSthorpej return (sysctl_lookup(SYSCTLFN_CALL(&node)));
8171813308fSthorpej }
8181813308fSthorpej
8191813308fSthorpej /*
820be59b63fSmartin * sysctl helper routine for rtc_offset - set time after changes
821be59b63fSmartin */
822be59b63fSmartin static int
sysctl_kern_rtc_offset(SYSCTLFN_ARGS)823be59b63fSmartin sysctl_kern_rtc_offset(SYSCTLFN_ARGS)
824be59b63fSmartin {
825184ad089Schristos struct timespec ts, delta;
826184ad089Schristos int error, new_rtc_offset;
827be59b63fSmartin struct sysctlnode node;
828be59b63fSmartin
829be59b63fSmartin new_rtc_offset = rtc_offset;
830be59b63fSmartin node = *rnode;
831be59b63fSmartin node.sysctl_data = &new_rtc_offset;
832be59b63fSmartin error = sysctl_lookup(SYSCTLFN_CALL(&node));
833be59b63fSmartin if (error || newp == NULL)
834be59b63fSmartin return (error);
835be59b63fSmartin
8365f7169ccSelad if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_TIME,
8375f7169ccSelad KAUTH_REQ_SYSTEM_TIME_RTCOFFSET,
8389725bcfdSelad KAUTH_ARG(new_rtc_offset), NULL, NULL))
839be59b63fSmartin return (EPERM);
840be59b63fSmartin if (rtc_offset == new_rtc_offset)
841be59b63fSmartin return (0);
842be59b63fSmartin
843be59b63fSmartin /* if we change the offset, adjust the time */
844184ad089Schristos nanotime(&ts);
845be59b63fSmartin delta.tv_sec = 60 * (new_rtc_offset - rtc_offset);
846184ad089Schristos delta.tv_nsec = 0;
847184ad089Schristos timespecadd(&ts, &delta, &ts);
848be59b63fSmartin rtc_offset = new_rtc_offset;
8499725bcfdSelad return (settime(l->l_proc, &ts));
850be59b63fSmartin }
851be59b63fSmartin
852be59b63fSmartin /*
853e221af6aSchristos * sysctl helper routine for kern.maxproc. Ensures that the new
85413f8d2ceSatatat * values are not too low or too high.
85513f8d2ceSatatat */
85613f8d2ceSatatat static int
sysctl_kern_maxproc(SYSCTLFN_ARGS)85713f8d2ceSatatat sysctl_kern_maxproc(SYSCTLFN_ARGS)
85813f8d2ceSatatat {
85913f8d2ceSatatat int error, nmaxproc;
86013f8d2ceSatatat struct sysctlnode node;
86113f8d2ceSatatat
86213f8d2ceSatatat nmaxproc = maxproc;
86313f8d2ceSatatat node = *rnode;
86413f8d2ceSatatat node.sysctl_data = &nmaxproc;
86513f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
86613f8d2ceSatatat if (error || newp == NULL)
86713f8d2ceSatatat return (error);
86813f8d2ceSatatat
86913f8d2ceSatatat if (nmaxproc < 0 || nmaxproc >= PID_MAX)
87013f8d2ceSatatat return (EINVAL);
87113f8d2ceSatatat #ifdef __HAVE_CPU_MAXPROC
87213f8d2ceSatatat if (nmaxproc > cpu_maxproc())
87313f8d2ceSatatat return (EINVAL);
87413f8d2ceSatatat #endif
87543a356c2Sskrll error = 0;
87643a356c2Sskrll #ifdef __HAVE_MAXPROC_HOOK
87743a356c2Sskrll error = cpu_maxproc_hook(nmaxproc);
87843a356c2Sskrll #endif
87943a356c2Sskrll if (error)
88043a356c2Sskrll return error;
88143a356c2Sskrll
88213f8d2ceSatatat maxproc = nmaxproc;
88313f8d2ceSatatat
88413f8d2ceSatatat return (0);
88513f8d2ceSatatat }
88613f8d2ceSatatat
88713f8d2ceSatatat /*
888e221af6aSchristos * sysctl helper function for kern.hostid. The hostid is a long, but
88913f8d2ceSatatat * we export it as an int, so we need to give it a little help.
89013f8d2ceSatatat */
89113f8d2ceSatatat static int
sysctl_kern_hostid(SYSCTLFN_ARGS)89213f8d2ceSatatat sysctl_kern_hostid(SYSCTLFN_ARGS)
89313f8d2ceSatatat {
89413f8d2ceSatatat int error, inthostid;
89513f8d2ceSatatat struct sysctlnode node;
89613f8d2ceSatatat
897efe61cceSmartin inthostid = hostid; /* XXX assumes sizeof int <= sizeof long */
89813f8d2ceSatatat node = *rnode;
89913f8d2ceSatatat node.sysctl_data = &inthostid;
90013f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
90113f8d2ceSatatat if (error || newp == NULL)
90213f8d2ceSatatat return (error);
90313f8d2ceSatatat
904904ca216Satatat hostid = (unsigned)inthostid;
90513f8d2ceSatatat
90613f8d2ceSatatat return (0);
90713f8d2ceSatatat }
90813f8d2ceSatatat
90913f8d2ceSatatat /*
910e221af6aSchristos * sysctl helper routine for kern.defcorename. In the case of a new
91113f8d2ceSatatat * string being assigned, check that it's not a zero-length string.
91213f8d2ceSatatat * (XXX the check in -current doesn't work, but do we really care?)
91313f8d2ceSatatat */
91413f8d2ceSatatat static int
sysctl_kern_defcorename(SYSCTLFN_ARGS)91513f8d2ceSatatat sysctl_kern_defcorename(SYSCTLFN_ARGS)
91613f8d2ceSatatat {
91713f8d2ceSatatat int error;
9185a3e3617Syamt char *newcorename;
91913f8d2ceSatatat struct sysctlnode node;
92013f8d2ceSatatat
9215a3e3617Syamt newcorename = PNBUF_GET();
92213f8d2ceSatatat node = *rnode;
92313f8d2ceSatatat node.sysctl_data = &newcorename[0];
92413f8d2ceSatatat memcpy(node.sysctl_data, rnode->sysctl_data, MAXPATHLEN);
92513f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
9265a3e3617Syamt if (error || newp == NULL) {
9275a3e3617Syamt goto done;
9285a3e3617Syamt }
92913f8d2ceSatatat
93013f8d2ceSatatat /*
93113f8d2ceSatatat * when sysctl_lookup() deals with a string, it's guaranteed
932e221af6aSchristos * to come back nul terminated. So there. :)
93313f8d2ceSatatat */
9345a3e3617Syamt if (strlen(newcorename) == 0) {
9355a3e3617Syamt error = EINVAL;
9365a3e3617Syamt } else {
93713f8d2ceSatatat memcpy(rnode->sysctl_data, node.sysctl_data, MAXPATHLEN);
9385a3e3617Syamt error = 0;
9395a3e3617Syamt }
9405a3e3617Syamt done:
9415a3e3617Syamt PNBUF_PUT(newcorename);
9425a3e3617Syamt return error;
94313f8d2ceSatatat }
94413f8d2ceSatatat
94513f8d2ceSatatat /*
946e221af6aSchristos * sysctl helper routine for kern.cp_time node. Adds up cpu time
94713f8d2ceSatatat * across all cpus.
94813f8d2ceSatatat */
94913f8d2ceSatatat static int
sysctl_kern_cptime(SYSCTLFN_ARGS)95013f8d2ceSatatat sysctl_kern_cptime(SYSCTLFN_ARGS)
95113f8d2ceSatatat {
95213f8d2ceSatatat struct sysctlnode node = *rnode;
953144515ceSperry uint64_t *cp_time = NULL;
954087fdb90Sad int error, n = ncpu, i;
95513f8d2ceSatatat struct cpu_info *ci;
95613f8d2ceSatatat CPU_INFO_ITERATOR cii;
95713f8d2ceSatatat
95813f8d2ceSatatat /*
95913f8d2ceSatatat * if you specifically pass a buffer that is the size of the
96013f8d2ceSatatat * sum, or if you are probing for the size, you get the "sum"
96113f8d2ceSatatat * of cp_time (and the size thereof) across all processors.
96213f8d2ceSatatat *
96313f8d2ceSatatat * alternately, you can pass an additional mib number and get
96413f8d2ceSatatat * cp_time for that particular processor.
96513f8d2ceSatatat */
96613f8d2ceSatatat switch (namelen) {
96713f8d2ceSatatat case 0:
968144515ceSperry if (*oldlenp == sizeof(uint64_t) * CPUSTATES || oldp == NULL) {
969144515ceSperry node.sysctl_size = sizeof(uint64_t) * CPUSTATES;
97013f8d2ceSatatat n = -1; /* SUM */
97113f8d2ceSatatat }
97213f8d2ceSatatat else {
973144515ceSperry node.sysctl_size = n * sizeof(uint64_t) * CPUSTATES;
97413f8d2ceSatatat n = -2; /* ALL */
97513f8d2ceSatatat }
97613f8d2ceSatatat break;
97713f8d2ceSatatat case 1:
97813f8d2ceSatatat if (name[0] < 0 || name[0] >= n)
9790f7550bbSatatat return (ENOENT); /* ENOSUCHPROCESSOR */
980144515ceSperry node.sysctl_size = sizeof(uint64_t) * CPUSTATES;
98113f8d2ceSatatat n = name[0];
98213f8d2ceSatatat /*
98313f8d2ceSatatat * adjust these so that sysctl_lookup() will be happy
98413f8d2ceSatatat */
98513f8d2ceSatatat name++;
98613f8d2ceSatatat namelen--;
9878c36f223Smartin break;
98813f8d2ceSatatat default:
98913f8d2ceSatatat return (EINVAL);
99013f8d2ceSatatat }
99113f8d2ceSatatat
99277e0b212Sad cp_time = kmem_alloc(node.sysctl_size, KM_SLEEP);
99313f8d2ceSatatat node.sysctl_data = cp_time;
99413f8d2ceSatatat memset(cp_time, 0, node.sysctl_size);
99513f8d2ceSatatat
99613f8d2ceSatatat for (CPU_INFO_FOREACH(cii, ci)) {
99777e0b212Sad if (n <= 0) {
99877e0b212Sad for (i = 0; i < CPUSTATES; i++) {
99913f8d2ceSatatat cp_time[i] += ci->ci_schedstate.spc_cp_time[i];
100077e0b212Sad }
100177e0b212Sad }
100213f8d2ceSatatat /*
100313f8d2ceSatatat * if a specific processor was requested and we just
100413f8d2ceSatatat * did it, we're done here
100513f8d2ceSatatat */
100613f8d2ceSatatat if (n == 0)
100713f8d2ceSatatat break;
100813f8d2ceSatatat /*
100913f8d2ceSatatat * if doing "all", skip to next cp_time set for next processor
101013f8d2ceSatatat */
101113f8d2ceSatatat if (n == -2)
101213f8d2ceSatatat cp_time += CPUSTATES;
101313f8d2ceSatatat /*
101413f8d2ceSatatat * if we're doing a specific processor, we're one
101513f8d2ceSatatat * processor closer
101613f8d2ceSatatat */
101713f8d2ceSatatat if (n > 0)
101813f8d2ceSatatat n--;
101913f8d2ceSatatat }
102013f8d2ceSatatat
102113f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
102277e0b212Sad kmem_free(node.sysctl_data, node.sysctl_size);
102313f8d2ceSatatat return (error);
102413f8d2ceSatatat }
102513f8d2ceSatatat
102613f8d2ceSatatat #if NPTY > 0
102713f8d2ceSatatat /*
1028e221af6aSchristos * sysctl helper routine for kern.maxptys. Ensures that any new value
102913f8d2ceSatatat * is acceptable to the pty subsystem.
103013f8d2ceSatatat */
103113f8d2ceSatatat static int
sysctl_kern_maxptys(SYSCTLFN_ARGS)103213f8d2ceSatatat sysctl_kern_maxptys(SYSCTLFN_ARGS)
103313f8d2ceSatatat {
103413f8d2ceSatatat int pty_maxptys(int, int); /* defined in kern/tty_pty.c */
1035efb69433Schristos int error, xmax;
103613f8d2ceSatatat struct sysctlnode node;
103713f8d2ceSatatat
103813f8d2ceSatatat /* get current value of maxptys */
1039efb69433Schristos xmax = pty_maxptys(0, 0);
104013f8d2ceSatatat
104113f8d2ceSatatat node = *rnode;
1042efb69433Schristos node.sysctl_data = &xmax;
104313f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
104413f8d2ceSatatat if (error || newp == NULL)
104513f8d2ceSatatat return (error);
104613f8d2ceSatatat
1047efb69433Schristos if (xmax != pty_maxptys(xmax, 1))
104813f8d2ceSatatat return (EINVAL);
104913f8d2ceSatatat
105013f8d2ceSatatat return (0);
105113f8d2ceSatatat }
105213f8d2ceSatatat #endif /* NPTY > 0 */
105313f8d2ceSatatat
105413f8d2ceSatatat /*
105513f8d2ceSatatat * sysctl helper routine to do kern.lwp.* work.
105613f8d2ceSatatat */
105713f8d2ceSatatat static int
sysctl_kern_lwp(SYSCTLFN_ARGS)105813f8d2ceSatatat sysctl_kern_lwp(SYSCTLFN_ARGS)
105913f8d2ceSatatat {
106013f8d2ceSatatat struct kinfo_lwp klwp;
106113f8d2ceSatatat struct proc *p;
106277e0b212Sad struct lwp *l2, *l3;
106313f8d2ceSatatat char *where, *dp;
106413f8d2ceSatatat int pid, elem_size, elem_count;
106513f8d2ceSatatat int buflen, needed, error;
106677e0b212Sad bool gotit;
106713f8d2ceSatatat
1068b1c111a6Satatat if (namelen == 1 && name[0] == CTL_QUERY)
1069420d9120Satatat return (sysctl_query(SYSCTLFN_CALL(rnode)));
1070b1c111a6Satatat
107113f8d2ceSatatat dp = where = oldp;
107213f8d2ceSatatat buflen = where != NULL ? *oldlenp : 0;
107313f8d2ceSatatat error = needed = 0;
107413f8d2ceSatatat
1075701a167dSsimonb if (newp != NULL || namelen != 3)
107613f8d2ceSatatat return (EINVAL);
1077701a167dSsimonb pid = name[0];
1078701a167dSsimonb elem_size = name[1];
1079701a167dSsimonb elem_count = name[2];
108013f8d2ceSatatat
108177e0b212Sad sysctl_unlock();
1082f0301095Syamt if (pid == -1) {
108314b4bbb2Sad mutex_enter(&proc_lock);
1084d4da6c3dSyamt PROCLIST_FOREACH(p, &allproc) {
108577e0b212Sad /* Grab a hold on the process. */
108677e0b212Sad if (!rw_tryenter(&p->p_reflock, RW_READER)) {
108777e0b212Sad continue;
108877e0b212Sad }
108914b4bbb2Sad mutex_exit(&proc_lock);
109077e0b212Sad
1091284c2b9aSad mutex_enter(p->p_lock);
109277e0b212Sad LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
1093f0301095Syamt if (buflen >= elem_size && elem_count > 0) {
1094f0301095Syamt lwp_lock(l2);
1095f0301095Syamt fill_lwp(l2, &klwp);
1096f0301095Syamt lwp_unlock(l2);
1097284c2b9aSad mutex_exit(p->p_lock);
1098f0301095Syamt
1099f0301095Syamt /*
110077e0b212Sad * Copy out elem_size, but not
110177e0b212Sad * larger than the size of a
110277e0b212Sad * struct kinfo_proc2.
1103f0301095Syamt */
1104f0301095Syamt error = dcopyout(l, &klwp, dp,
1105a8a5c538Sriastradh uimin(sizeof(klwp), elem_size));
110677e0b212Sad if (error) {
110777e0b212Sad rw_exit(&p->p_reflock);
1108f0301095Syamt goto cleanup;
110977e0b212Sad }
1110284c2b9aSad mutex_enter(p->p_lock);
111177e0b212Sad LIST_FOREACH(l3, &p->p_lwps,
111277e0b212Sad l_sibling) {
111377e0b212Sad if (l2 == l3)
111477e0b212Sad break;
111577e0b212Sad }
111677e0b212Sad if (l3 == NULL) {
1117284c2b9aSad mutex_exit(p->p_lock);
111877e0b212Sad rw_exit(&p->p_reflock);
111977e0b212Sad error = EAGAIN;
112077e0b212Sad goto cleanup;
112177e0b212Sad }
1122f0301095Syamt dp += elem_size;
1123f0301095Syamt buflen -= elem_size;
1124f0301095Syamt elem_count--;
1125f0301095Syamt }
1126f0301095Syamt needed += elem_size;
1127f0301095Syamt }
1128284c2b9aSad mutex_exit(p->p_lock);
112977e0b212Sad
113077e0b212Sad /* Drop reference to process. */
113114b4bbb2Sad mutex_enter(&proc_lock);
113277e0b212Sad rw_exit(&p->p_reflock);
113377e0b212Sad }
113414b4bbb2Sad mutex_exit(&proc_lock);
1135f0301095Syamt } else {
113614b4bbb2Sad mutex_enter(&proc_lock);
11373c507045Srmind p = proc_find(pid);
1138b07ec3fcSad if (p == NULL) {
113977e0b212Sad error = ESRCH;
114014b4bbb2Sad mutex_exit(&proc_lock);
114177e0b212Sad goto cleanup;
1142b07ec3fcSad }
114377e0b212Sad /* Grab a hold on the process. */
114477e0b212Sad gotit = rw_tryenter(&p->p_reflock, RW_READER);
114514b4bbb2Sad mutex_exit(&proc_lock);
114677e0b212Sad if (!gotit) {
114777e0b212Sad error = ESRCH;
114877e0b212Sad goto cleanup;
114977e0b212Sad }
115077e0b212Sad
1151284c2b9aSad mutex_enter(p->p_lock);
115213f8d2ceSatatat LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
115313f8d2ceSatatat if (buflen >= elem_size && elem_count > 0) {
1154b07ec3fcSad lwp_lock(l2);
115513f8d2ceSatatat fill_lwp(l2, &klwp);
1156b07ec3fcSad lwp_unlock(l2);
1157284c2b9aSad mutex_exit(p->p_lock);
115813f8d2ceSatatat /*
115913f8d2ceSatatat * Copy out elem_size, but not larger than
116013f8d2ceSatatat * the size of a struct kinfo_proc2.
116113f8d2ceSatatat */
11628a1037a4Smanu error = dcopyout(l, &klwp, dp,
1163a8a5c538Sriastradh uimin(sizeof(klwp), elem_size));
116416598eeeSad if (error) {
116577e0b212Sad rw_exit(&p->p_reflock);
116613f8d2ceSatatat goto cleanup;
116716598eeeSad }
1168284c2b9aSad mutex_enter(p->p_lock);
116916598eeeSad LIST_FOREACH(l3, &p->p_lwps, l_sibling) {
117016598eeeSad if (l2 == l3)
117116598eeeSad break;
117216598eeeSad }
1173aa9301c8Srmind if (l3 == NULL) {
1174284c2b9aSad mutex_exit(p->p_lock);
117577e0b212Sad rw_exit(&p->p_reflock);
117616598eeeSad error = EAGAIN;
117716598eeeSad goto cleanup;
117816598eeeSad }
117913f8d2ceSatatat dp += elem_size;
118013f8d2ceSatatat buflen -= elem_size;
118113f8d2ceSatatat elem_count--;
118213f8d2ceSatatat }
118313f8d2ceSatatat needed += elem_size;
118413f8d2ceSatatat }
1185284c2b9aSad mutex_exit(p->p_lock);
118677e0b212Sad
118777e0b212Sad /* Drop reference to process. */
118877e0b212Sad rw_exit(&p->p_reflock);
1189f0301095Syamt }
119013f8d2ceSatatat
119113f8d2ceSatatat if (where != NULL) {
119213f8d2ceSatatat *oldlenp = dp - where;
119377e0b212Sad if (needed > *oldlenp) {
119477e0b212Sad sysctl_relock();
119513f8d2ceSatatat return (ENOMEM);
119677e0b212Sad }
119713f8d2ceSatatat } else {
119856392ab4Satatat needed += KERN_LWPSLOP;
119913f8d2ceSatatat *oldlenp = needed;
120013f8d2ceSatatat }
120177e0b212Sad error = 0;
120213f8d2ceSatatat cleanup:
120377e0b212Sad sysctl_relock();
120413f8d2ceSatatat return (error);
120513f8d2ceSatatat }
120613f8d2ceSatatat
120713f8d2ceSatatat /*
1208e221af6aSchristos * sysctl helper routine for kern.forkfsleep node. Ensures that the
120913f8d2ceSatatat * given value is not too large or two small, and is at least one
121013f8d2ceSatatat * timer tick if not zero.
121113f8d2ceSatatat */
121213f8d2ceSatatat static int
sysctl_kern_forkfsleep(SYSCTLFN_ARGS)121313f8d2ceSatatat sysctl_kern_forkfsleep(SYSCTLFN_ARGS)
121413f8d2ceSatatat {
121513f8d2ceSatatat /* userland sees value in ms, internally is in ticks */
121613f8d2ceSatatat extern int forkfsleep; /* defined in kern/kern_fork.c */
121713f8d2ceSatatat int error, timo, lsleep;
121813f8d2ceSatatat struct sysctlnode node;
121913f8d2ceSatatat
122013f8d2ceSatatat lsleep = forkfsleep * 1000 / hz;
122113f8d2ceSatatat node = *rnode;
122213f8d2ceSatatat node.sysctl_data = &lsleep;
122313f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
122413f8d2ceSatatat if (error || newp == NULL)
122513f8d2ceSatatat return (error);
122613f8d2ceSatatat
122713f8d2ceSatatat /* refuse negative values, and overly 'long time' */
122813f8d2ceSatatat if (lsleep < 0 || lsleep > MAXSLP * 1000)
122913f8d2ceSatatat return (EINVAL);
123013f8d2ceSatatat
123113f8d2ceSatatat timo = mstohz(lsleep);
123213f8d2ceSatatat
123313f8d2ceSatatat /* if the interval is >0 ms && <1 tick, use 1 tick */
123413f8d2ceSatatat if (lsleep != 0 && timo == 0)
123513f8d2ceSatatat forkfsleep = 1;
123613f8d2ceSatatat else
123713f8d2ceSatatat forkfsleep = timo;
123813f8d2ceSatatat
123913f8d2ceSatatat return (0);
124013f8d2ceSatatat }
124113f8d2ceSatatat
124213f8d2ceSatatat /*
124313f8d2ceSatatat * sysctl helper routine for kern.root_partition
124413f8d2ceSatatat */
124513f8d2ceSatatat static int
sysctl_kern_root_partition(SYSCTLFN_ARGS)124613f8d2ceSatatat sysctl_kern_root_partition(SYSCTLFN_ARGS)
124713f8d2ceSatatat {
124813f8d2ceSatatat int rootpart = DISKPART(rootdev);
124913f8d2ceSatatat struct sysctlnode node = *rnode;
125013f8d2ceSatatat
125113f8d2ceSatatat node.sysctl_data = &rootpart;
125213f8d2ceSatatat return (sysctl_lookup(SYSCTLFN_CALL(&node)));
125313f8d2ceSatatat }
125413f8d2ceSatatat
125513f8d2ceSatatat /*
125613f8d2ceSatatat * sysctl helper function for kern.drivers
125713f8d2ceSatatat */
125813f8d2ceSatatat static int
sysctl_kern_drivers(SYSCTLFN_ARGS)125913f8d2ceSatatat sysctl_kern_drivers(SYSCTLFN_ARGS)
126013f8d2ceSatatat {
126113f8d2ceSatatat int error;
126213f8d2ceSatatat size_t buflen;
126313f8d2ceSatatat struct kinfo_drivers kd;
126413f8d2ceSatatat char *start, *where;
126513f8d2ceSatatat const char *dname;
126613f8d2ceSatatat int i;
126713f8d2ceSatatat extern struct devsw_conv *devsw_conv;
126813f8d2ceSatatat extern int max_devsw_convs;
126913f8d2ceSatatat
127013f8d2ceSatatat start = where = oldp;
127113f8d2ceSatatat buflen = *oldlenp;
127213f8d2ceSatatat if (where == NULL) {
127313f8d2ceSatatat *oldlenp = max_devsw_convs * sizeof kd;
127413f8d2ceSatatat return 0;
127513f8d2ceSatatat }
127613f8d2ceSatatat
127713f8d2ceSatatat /*
127813f8d2ceSatatat * An array of kinfo_drivers structures
127913f8d2ceSatatat */
128013f8d2ceSatatat error = 0;
128177e0b212Sad sysctl_unlock();
12828583cae2Spooka mutex_enter(&device_lock);
128313f8d2ceSatatat for (i = 0; i < max_devsw_convs; i++) {
128413f8d2ceSatatat dname = devsw_conv[i].d_name;
128513f8d2ceSatatat if (dname == NULL)
128613f8d2ceSatatat continue;
128713f8d2ceSatatat if (buflen < sizeof kd) {
128813f8d2ceSatatat error = ENOMEM;
128913f8d2ceSatatat break;
129013f8d2ceSatatat }
1291a70c39ffSatatat memset(&kd, 0, sizeof(kd));
129213f8d2ceSatatat kd.d_bmajor = devsw_conv[i].d_bmajor;
129313f8d2ceSatatat kd.d_cmajor = devsw_conv[i].d_cmajor;
129413f8d2ceSatatat strlcpy(kd.d_name, dname, sizeof kd.d_name);
12958583cae2Spooka mutex_exit(&device_lock);
12968a1037a4Smanu error = dcopyout(l, &kd, where, sizeof kd);
12978583cae2Spooka mutex_enter(&device_lock);
129813f8d2ceSatatat if (error != 0)
129913f8d2ceSatatat break;
130013f8d2ceSatatat buflen -= sizeof kd;
130113f8d2ceSatatat where += sizeof kd;
130213f8d2ceSatatat }
13038583cae2Spooka mutex_exit(&device_lock);
130477e0b212Sad sysctl_relock();
130513f8d2ceSatatat *oldlenp = where - start;
130613f8d2ceSatatat return error;
130713f8d2ceSatatat }
130813f8d2ceSatatat
13094a302fa0Selad static int
sysctl_security_setidcore(SYSCTLFN_ARGS)13104a302fa0Selad sysctl_security_setidcore(SYSCTLFN_ARGS)
13114a302fa0Selad {
13124a302fa0Selad int newsize, error;
13134a302fa0Selad struct sysctlnode node;
13144a302fa0Selad
13154a302fa0Selad node = *rnode;
13164a302fa0Selad node.sysctl_data = &newsize;
13174a302fa0Selad newsize = *(int *)rnode->sysctl_data;
13184a302fa0Selad error = sysctl_lookup(SYSCTLFN_CALL(&node));
13194a302fa0Selad if (error || newp == NULL)
13204a302fa0Selad return error;
13214a302fa0Selad
13225f7169ccSelad if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_SETIDCORE,
1323bada0c77Selad 0, NULL, NULL, NULL))
13244a302fa0Selad return (EPERM);
13254a302fa0Selad
13264a302fa0Selad *(int *)rnode->sysctl_data = newsize;
13274a302fa0Selad
13284a302fa0Selad return 0;
13294a302fa0Selad }
13304a302fa0Selad
13314a302fa0Selad static int
sysctl_security_setidcorename(SYSCTLFN_ARGS)13324a302fa0Selad sysctl_security_setidcorename(SYSCTLFN_ARGS)
13334a302fa0Selad {
13344a302fa0Selad int error;
13357b37f454Syamt char *newsetidcorename;
13364a302fa0Selad struct sysctlnode node;
13374a302fa0Selad
13387b37f454Syamt newsetidcorename = PNBUF_GET();
13394a302fa0Selad node = *rnode;
13407b37f454Syamt node.sysctl_data = newsetidcorename;
13414a302fa0Selad memcpy(node.sysctl_data, rnode->sysctl_data, MAXPATHLEN);
13424a302fa0Selad error = sysctl_lookup(SYSCTLFN_CALL(&node));
13437b37f454Syamt if (error || newp == NULL) {
13447b37f454Syamt goto out;
13457b37f454Syamt }
13465f7169ccSelad if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_SETIDCORE,
1347bada0c77Selad 0, NULL, NULL, NULL)) {
13487b37f454Syamt error = EPERM;
13497b37f454Syamt goto out;
13507b37f454Syamt }
13517b37f454Syamt if (strlen(newsetidcorename) == 0) {
13527b37f454Syamt error = EINVAL;
13537b37f454Syamt goto out;
13547b37f454Syamt }
13554a302fa0Selad memcpy(rnode->sysctl_data, node.sysctl_data, MAXPATHLEN);
13567b37f454Syamt out:
13577b37f454Syamt PNBUF_PUT(newsetidcorename);
13587b37f454Syamt return error;
13594a302fa0Selad }
13604a302fa0Selad
13615888b16eSelad /*
1362e221af6aSchristos * sysctl helper routine for kern.cp_id node. Maps cpus to their
1363dfa8191fSchristos * cpuids.
1364dfa8191fSchristos */
1365dfa8191fSchristos static int
sysctl_kern_cpid(SYSCTLFN_ARGS)1366dfa8191fSchristos sysctl_kern_cpid(SYSCTLFN_ARGS)
1367dfa8191fSchristos {
1368dfa8191fSchristos struct sysctlnode node = *rnode;
1369144515ceSperry uint64_t *cp_id = NULL;
1370087fdb90Sad int error, n = ncpu;
1371dfa8191fSchristos struct cpu_info *ci;
1372dfa8191fSchristos CPU_INFO_ITERATOR cii;
1373dfa8191fSchristos
1374dfa8191fSchristos /*
1375e221af6aSchristos * Here you may either retrieve a single cpu id or the whole
1376e221af6aSchristos * set. The size you get back when probing depends on what
1377efb42707Satatat * you ask for.
1378dfa8191fSchristos */
1379dfa8191fSchristos switch (namelen) {
1380dfa8191fSchristos case 0:
1381144515ceSperry node.sysctl_size = n * sizeof(uint64_t);
1382dfa8191fSchristos n = -2; /* ALL */
1383dfa8191fSchristos break;
1384dfa8191fSchristos case 1:
1385dfa8191fSchristos if (name[0] < 0 || name[0] >= n)
1386dfa8191fSchristos return (ENOENT); /* ENOSUCHPROCESSOR */
1387144515ceSperry node.sysctl_size = sizeof(uint64_t);
1388dfa8191fSchristos n = name[0];
1389dfa8191fSchristos /*
1390dfa8191fSchristos * adjust these so that sysctl_lookup() will be happy
1391dfa8191fSchristos */
1392dfa8191fSchristos name++;
1393dfa8191fSchristos namelen--;
1394dfa8191fSchristos break;
1395dfa8191fSchristos default:
1396dfa8191fSchristos return (EINVAL);
1397dfa8191fSchristos }
1398dfa8191fSchristos
139977e0b212Sad cp_id = kmem_alloc(node.sysctl_size, KM_SLEEP);
1400dfa8191fSchristos node.sysctl_data = cp_id;
1401dfa8191fSchristos memset(cp_id, 0, node.sysctl_size);
1402dfa8191fSchristos
1403dfa8191fSchristos for (CPU_INFO_FOREACH(cii, ci)) {
1404dfa8191fSchristos if (n <= 0)
1405a9ee17c5Sad cp_id[0] = cpu_index(ci);
1406dfa8191fSchristos /*
1407dfa8191fSchristos * if a specific processor was requested and we just
1408dfa8191fSchristos * did it, we're done here
1409dfa8191fSchristos */
1410dfa8191fSchristos if (n == 0)
1411dfa8191fSchristos break;
1412dfa8191fSchristos /*
1413dfa8191fSchristos * if doing "all", skip to next cp_id slot for next processor
1414dfa8191fSchristos */
1415dfa8191fSchristos if (n == -2)
1416dfa8191fSchristos cp_id++;
1417dfa8191fSchristos /*
1418dfa8191fSchristos * if we're doing a specific processor, we're one
1419dfa8191fSchristos * processor closer
1420dfa8191fSchristos */
1421dfa8191fSchristos if (n > 0)
1422dfa8191fSchristos n--;
1423dfa8191fSchristos }
1424dfa8191fSchristos
1425dfa8191fSchristos error = sysctl_lookup(SYSCTLFN_CALL(&node));
142677e0b212Sad kmem_free(node.sysctl_data, node.sysctl_size);
1427dfa8191fSchristos return (error);
1428dfa8191fSchristos }
1429dfa8191fSchristos
1430dfa8191fSchristos /*
1431e221af6aSchristos * sysctl helper routine for hw.usermem and hw.usermem64. Values are
143213f8d2ceSatatat * calculate on the fly taking into account integer overflow and the
143313f8d2ceSatatat * current wired count.
143413f8d2ceSatatat */
143513f8d2ceSatatat static int
sysctl_hw_usermem(SYSCTLFN_ARGS)143613f8d2ceSatatat sysctl_hw_usermem(SYSCTLFN_ARGS)
143713f8d2ceSatatat {
143813f8d2ceSatatat u_int ui;
143913f8d2ceSatatat u_quad_t uq;
144013f8d2ceSatatat struct sysctlnode node;
144113f8d2ceSatatat
144213f8d2ceSatatat node = *rnode;
144313f8d2ceSatatat switch (rnode->sysctl_num) {
144413f8d2ceSatatat case HW_USERMEM:
144513f8d2ceSatatat if ((ui = physmem - uvmexp.wired) > (UINT_MAX / PAGE_SIZE))
144613f8d2ceSatatat ui = UINT_MAX;
144713f8d2ceSatatat else
144813f8d2ceSatatat ui *= PAGE_SIZE;
144913f8d2ceSatatat node.sysctl_data = &ui;
145013f8d2ceSatatat break;
145113f8d2ceSatatat case HW_USERMEM64:
145213f8d2ceSatatat uq = (u_quad_t)(physmem - uvmexp.wired) * PAGE_SIZE;
145313f8d2ceSatatat node.sysctl_data = &uq;
145413f8d2ceSatatat break;
145513f8d2ceSatatat default:
145613f8d2ceSatatat return (EINVAL);
145713f8d2ceSatatat }
145813f8d2ceSatatat
145913f8d2ceSatatat return (sysctl_lookup(SYSCTLFN_CALL(&node)));
146013f8d2ceSatatat }
146113f8d2ceSatatat
146213f8d2ceSatatat /*
1463e221af6aSchristos * sysctl helper routine for kern.cnmagic node. Pulls the old value
146413f8d2ceSatatat * out, encoded, and stuffs the new value in for decoding.
146513f8d2ceSatatat */
146613f8d2ceSatatat static int
sysctl_hw_cnmagic(SYSCTLFN_ARGS)146713f8d2ceSatatat sysctl_hw_cnmagic(SYSCTLFN_ARGS)
146813f8d2ceSatatat {
146913f8d2ceSatatat char magic[CNS_LEN];
147013f8d2ceSatatat int error;
147113f8d2ceSatatat struct sysctlnode node;
147213f8d2ceSatatat
147313f8d2ceSatatat if (oldp)
147413f8d2ceSatatat cn_get_magic(magic, CNS_LEN);
147513f8d2ceSatatat node = *rnode;
147613f8d2ceSatatat node.sysctl_data = &magic[0];
147713f8d2ceSatatat error = sysctl_lookup(SYSCTLFN_CALL(&node));
147813f8d2ceSatatat if (error || newp == NULL)
147913f8d2ceSatatat return (error);
148013f8d2ceSatatat
148113f8d2ceSatatat return (cn_set_magic(magic));
148213f8d2ceSatatat }
148313f8d2ceSatatat
148413f8d2ceSatatat /*
148513f8d2ceSatatat * ********************************************************************
148613f8d2ceSatatat * section 3: public helper routines that are used for more than one
148713f8d2ceSatatat * node
148813f8d2ceSatatat * ********************************************************************
148913f8d2ceSatatat */
149013f8d2ceSatatat
149113f8d2ceSatatat /*
149213f8d2ceSatatat * sysctl helper routine for the kern.root_device node and some ports'
149313f8d2ceSatatat * machdep.root_device nodes.
149413f8d2ceSatatat */
149513f8d2ceSatatat int
sysctl_root_device(SYSCTLFN_ARGS)149613f8d2ceSatatat sysctl_root_device(SYSCTLFN_ARGS)
149713f8d2ceSatatat {
149813f8d2ceSatatat struct sysctlnode node;
149913f8d2ceSatatat
150013f8d2ceSatatat node = *rnode;
15015f819ca3Schs node.sysctl_data = __UNCONST(device_xname(root_device));
1502224670aeScegger node.sysctl_size = strlen(device_xname(root_device)) + 1;
150313f8d2ceSatatat return (sysctl_lookup(SYSCTLFN_CALL(&node)));
150413f8d2ceSatatat }
150513f8d2ceSatatat
150613f8d2ceSatatat /*
150713f8d2ceSatatat * sysctl helper routine for kern.consdev, dependent on the current
1508e221af6aSchristos * state of the console. Also used for machdep.console_device on some
150913f8d2ceSatatat * ports.
151013f8d2ceSatatat */
151113f8d2ceSatatat int
sysctl_consdev(SYSCTLFN_ARGS)151213f8d2ceSatatat sysctl_consdev(SYSCTLFN_ARGS)
151313f8d2ceSatatat {
151413f8d2ceSatatat dev_t consdev;
1515a9d1bfd0Schristos uint32_t oconsdev;
151613f8d2ceSatatat struct sysctlnode node;
151713f8d2ceSatatat
151813f8d2ceSatatat if (cn_tab != NULL)
151913f8d2ceSatatat consdev = cn_tab->cn_dev;
152013f8d2ceSatatat else
152113f8d2ceSatatat consdev = NODEV;
152213f8d2ceSatatat node = *rnode;
1523a9d1bfd0Schristos switch (*oldlenp) {
1524a9d1bfd0Schristos case sizeof(consdev):
152513f8d2ceSatatat node.sysctl_data = &consdev;
152613f8d2ceSatatat node.sysctl_size = sizeof(consdev);
1527a9d1bfd0Schristos break;
1528a9d1bfd0Schristos case sizeof(oconsdev):
1529a9d1bfd0Schristos oconsdev = (uint32_t)consdev;
1530a9d1bfd0Schristos node.sysctl_data = &oconsdev;
1531a9d1bfd0Schristos node.sysctl_size = sizeof(oconsdev);
1532a9d1bfd0Schristos break;
1533a9d1bfd0Schristos default:
1534a9d1bfd0Schristos return EINVAL;
1535a9d1bfd0Schristos }
153613f8d2ceSatatat return (sysctl_lookup(SYSCTLFN_CALL(&node)));
153713f8d2ceSatatat }
153813f8d2ceSatatat
153913f8d2ceSatatat /*
154013f8d2ceSatatat * ********************************************************************
154113f8d2ceSatatat * section 4: support for some helpers
154213f8d2ceSatatat * ********************************************************************
154313f8d2ceSatatat */
15446b9261b2Schristos
154513f8d2ceSatatat
154613f8d2ceSatatat /*
154713f8d2ceSatatat * Fill in a kinfo_lwp structure for the specified lwp.
154813f8d2ceSatatat */
154913f8d2ceSatatat static void
fill_lwp(struct lwp * l,struct kinfo_lwp * kl)155013f8d2ceSatatat fill_lwp(struct lwp *l, struct kinfo_lwp *kl)
155113f8d2ceSatatat {
155232952fa9Smaxv const bool allowaddr = get_expose_address(curproc);
1553f0301095Syamt struct proc *p = l->l_proc;
1554949e16d9Syamt struct timeval tv;
155513f8d2ceSatatat
15563426b80bSyamt KASSERT(lwp_locked(l, NULL));
15573426b80bSyamt
15585b19556aSpooka memset(kl, 0, sizeof(*kl));
15595b19556aSpooka
1560f0301095Syamt kl->l_forw = 0;
1561f0301095Syamt kl->l_back = 0;
156232952fa9Smaxv COND_SET_VALUE(kl->l_laddr, PTRTOUINT64(l), allowaddr);
156332952fa9Smaxv COND_SET_VALUE(kl->l_addr, PTRTOUINT64(l->l_addr), allowaddr);
156413f8d2ceSatatat kl->l_stat = l->l_stat;
156513f8d2ceSatatat kl->l_lid = l->l_lid;
156617a42f25Sdsl kl->l_flag = L_INMEM;
156717a42f25Sdsl kl->l_flag |= sysctl_map_flags(sysctl_lwpprflagmap, l->l_prflag);
1568460ae70dSchristos kl->l_flag |= sysctl_map_flags(sysctl_lwpflagmap, l->l_flag);
156913f8d2ceSatatat
157013f8d2ceSatatat kl->l_swtime = l->l_swtime;
157113f8d2ceSatatat kl->l_slptime = l->l_slptime;
1572b07ec3fcSad if (l->l_stat == LSONPROC)
157313f8d2ceSatatat kl->l_schedflags = l->l_cpu->ci_schedstate.spc_flags;
1574b07ec3fcSad else
157513f8d2ceSatatat kl->l_schedflags = 0;
1576d831186dSad kl->l_priority = lwp_eprio(l);
1577d831186dSad kl->l_usrpri = l->l_priority;
15783426b80bSyamt if (l->l_wchan)
1579247cd610Sxtraeme strncpy(kl->l_wmesg, l->l_wmesg, sizeof(kl->l_wmesg));
158032952fa9Smaxv COND_SET_VALUE(kl->l_wchan, PTRTOUINT64(l->l_wchan), allowaddr);
1581a9ee17c5Sad kl->l_cpuid = cpu_index(l->l_cpu);
1582949e16d9Syamt bintime2timeval(&l->l_rtime, &tv);
1583949e16d9Syamt kl->l_rtime_sec = tv.tv_sec;
1584949e16d9Syamt kl->l_rtime_usec = tv.tv_usec;
1585f0301095Syamt kl->l_cpticks = l->l_cpticks;
1586f0301095Syamt kl->l_pctcpu = l->l_pctcpu;
1587f0301095Syamt kl->l_pid = p->p_pid;
1588f0301095Syamt if (l->l_name == NULL)
1589f0301095Syamt kl->l_name[0] = '\0';
1590dcf3ee7dSxtraeme else
1591247cd610Sxtraeme strlcpy(kl->l_name, l->l_name, sizeof(kl->l_name));
159213f8d2ceSatatat }
1593