/usr/src/sys/kern/kern

Bug Summary

File:	kern/kern_sysctl.c
Warning:	line 1133, column 16 Access to field 'v_type' results in a dereference of a null pointer (loaded from variable 'vp')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name kern_sysctl.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -D CONFIG_DRM_AMD_DC_DCN3_0 -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /usr/obj/sys/arch/amd64/compile/GENERIC.MP/scan-build/2022-01-12-131800-47421-1 -x c /usr/src/sys/kern/kern_sysctl.c
1/*	$OpenBSD: kern_sysctl.c,v 1.398 2021/12/23 10:17:01 bluhm Exp $	*/
2/*	$NetBSD: kern_sysctl.c,v 1.17 1996/05/20 17:49:05 mrg Exp $	*/

4/*-
* Copyright (c) 1982, 1986, 1989, 1993
*	The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Mike Karels at Berkeley Software Design, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*	@(#)kern_sysctl.c	8.4 (Berkeley) 4/14/94
*/

38/*
* sysctl system call.
*/

42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/kernel.h>
45#include <sys/malloc.h>
46#include <sys/pool.h>
47#include <sys/proc.h>
48#include <sys/resourcevar.h>
49#include <sys/signalvar.h>
50#include <sys/fcntl.h>
51#include <sys/file.h>
52#include <sys/filedesc.h>
53#include <sys/vnode.h>
54#include <sys/unistd.h>
55#include <sys/buf.h>
56#include <sys/ioctl.h>
57#include <sys/tty.h>
58#include <sys/disklabel.h>
59#include <sys/disk.h>
60#include <sys/sysctl.h>
61#include <sys/msgbuf.h>
62#include <sys/vmmeter.h>
63#include <sys/namei.h>
64#include <sys/exec.h>
65#include <sys/mbuf.h>
66#include <sys/percpu.h>
67#include <sys/sensors.h>
68#include <sys/pipe.h>
69#include <sys/eventvar.h>
70#include <sys/socketvar.h>
71#include <sys/socket.h>
72#include <sys/domain.h>
73#include <sys/protosw.h>
74#include <sys/pledge.h>
75#include <sys/timetc.h>
76#include <sys/evcount.h>
77#include <sys/un.h>
78#include <sys/unpcb.h>
79#include <sys/sched.h>
80#include <sys/mount.h>
81#include <sys/syscallargs.h>
82#include <sys/wait.h>
83#include <sys/witness.h>

85#include <uvm/uvm_extern.h>

87#include <dev/cons.h>

89#include <net/route.h>
90#include <netinet/in.h>
91#include <netinet/ip.h>
92#include <netinet/ip_var.h>
93#include <netinet/in_pcb.h>
94#include <netinet/ip6.h>
95#include <netinet/tcp.h>
96#include <netinet/tcp_timer.h>
97#include <netinet/tcp_var.h>
98#include <netinet/udp.h>
99#include <netinet/udp_var.h>
100#include <netinet6/ip6_var.h>

102#ifdef DDB1
103#include <ddb/db_var.h>
104#endif

106#ifdef SYSVMSG1
107#include <sys/msg.h>
108#endif
109#ifdef SYSVSEM1
110#include <sys/sem.h>
111#endif
112#ifdef SYSVSHM1
113#include <sys/shm.h>
114#endif

116#include "audio.h"
117#include "dt.h"
118#include "pf.h"
119#include "video.h"

121extern struct forkstat forkstat;
122extern struct nchstats nchstats;
123extern int nselcoll, fscale;
124extern fixpt_t ccpu;
125extern long numvnodes;
126extern int allowdt;
127extern int audio_record_enable;
128extern int video_record_enable;

130int allowkmem;

132int sysctl_diskinit(int, struct proc *);
133int sysctl_proc_args(int *, u_int, void *, size_t *, struct proc *);
134int sysctl_proc_cwd(int *, u_int, void *, size_t *, struct proc *);
135int sysctl_proc_nobroadcastkill(int *, u_int, void *, size_t, void *, size_t *,
struct proc *);
137int sysctl_proc_vmmap(int *, u_int, void *, size_t *, struct proc *);
138int sysctl_intrcnt(int *, u_int, void *, size_t *);
139int sysctl_sensors(int *, u_int, void *, size_t *, void *, size_t);
140int sysctl_cptime2(int *, u_int, void *, size_t *, void *, size_t);
141int sysctl_audio(int *, u_int, void *, size_t *, void *, size_t);
142int sysctl_video(int *, u_int, void *, size_t *, void *, size_t);
143int sysctl_cpustats(int *, u_int, void *, size_t *, void *, size_t);
144int sysctl_utc_offset(void *, size_t *, void *, size_t);

146void fill_file(struct kinfo_file *, struct file *, struct filedesc *, int,
  struct vnode *, struct process *, struct proc *, struct socket *, int);
148void fill_kproc(struct process *, struct kinfo_proc *, struct proc *, int);

150int (*cpu_cpuspeed)(int *);

152/*
* Lock to avoid too many processes vslocking a large amount of memory
* at the same time.
*/
156struct rwlock sysctl_lock = RWLOCK_INITIALIZER("sysctllk"){ 0, "sysctllk" };
157struct rwlock sysctl_disklock = RWLOCK_INITIALIZER("sysctldlk"){ 0, "sysctldlk" };

159int
160sys_sysctl(struct proc *p, void *v, register_t *retval)
161{
struct sys_sysctl_args /* {
syscallarg(const int *) name;
syscallarg(u_int) namelen;
syscallarg(void *) old;
syscallarg(size_t *) oldlenp;
syscallarg(void *) new;
syscallarg(size_t) newlen;
} */ *uap = v;
int error, dolock = 1;
size_t savelen = 0, oldlen = 0;
sysctlfn *fn;
int name[CTL_MAXNAME12];

if (SCARG(uap, new)((uap)->new.le.datum) != NULL((void *)0) &&
   (error = suser(p)))
return (error);
/*
* all top-level sysctl names are non-terminal
*/
if (SCARG(uap, namelen)((uap)->namelen.le.datum) > CTL_MAXNAME12 || SCARG(uap, namelen)((uap)->namelen.le.datum) < 2)
return (EINVAL22);
error = copyin(SCARG(uap, name)((uap)->name.le.datum), name,
       SCARG(uap, namelen)((uap)->namelen.le.datum) * sizeof(int));
if (error)
return (error);

error = pledge_sysctl(p, SCARG(uap, namelen)((uap)->namelen.le.datum),
   name, SCARG(uap, new)((uap)->new.le.datum));
if (error)
return (error);

switch (name[0]) {
case CTL_KERN1:
fn = kern_sysctl;
break;
case CTL_HW6:
fn = hw_sysctl;
break;
case CTL_VM2:
fn = uvm_sysctl;
break;
case CTL_NET4:
fn = net_sysctl;
break;
case CTL_FS3:
fn = fs_sysctl;
break;
case CTL_VFS10:
fn = vfs_sysctl;
break;
case CTL_MACHDEP7:
fn = cpu_sysctl;
break;
215#ifdef DEBUG_SYSCTL
case CTL_DEBUG5:
fn = debug_sysctl;
break;
219#endif
220#ifdef DDB1
case CTL_DDB9:
fn = ddb_sysctl;
break;
224#endif
default:
return (EOPNOTSUPP45);
}

if (SCARG(uap, oldlenp)((uap)->oldlenp.le.datum) &&
   (error = copyin(SCARG(uap, oldlenp)((uap)->oldlenp.le.datum), &oldlen, sizeof(oldlen))))
return (error);
if (SCARG(uap, old)((uap)->old.le.datum) != NULL((void *)0)) {
if ((error = rw_enter(&sysctl_lock, RW_WRITE0x0001UL|RW_INTR0x0010UL)) != 0)
	return (error);
if (dolock) {
	if (atop(oldlen)((oldlen) >> 12) > uvmexp.wiredmax - uvmexp.wired) {
		rw_exit_write(&sysctl_lock);
		return (ENOMEM12);
	}
	error = uvm_vslock(p, SCARG(uap, old)((uap)->old.le.datum), oldlen,
	    PROT_READ0x01 | PROT_WRITE0x02);
	if (error) {
		rw_exit_write(&sysctl_lock);
		return (error);
	}
}
savelen = oldlen;
}
error = (*fn)(&name[1], SCARG(uap, namelen)((uap)->namelen.le.datum) - 1, SCARG(uap, old)((uap)->old.le.datum),
   &oldlen, SCARG(uap, new)((uap)->new.le.datum), SCARG(uap, newlen)((uap)->newlen.le.datum), p);
if (SCARG(uap, old)((uap)->old.le.datum) != NULL((void *)0)) {
if (dolock)
	uvm_vsunlock(p, SCARG(uap, old)((uap)->old.le.datum), savelen);
rw_exit_write(&sysctl_lock);
}
if (error)
return (error);
if (SCARG(uap, oldlenp)((uap)->oldlenp.le.datum))
error = copyout(&oldlen, SCARG(uap, oldlenp)((uap)->oldlenp.le.datum), sizeof(oldlen));
return (error);
261}

263/*
* Attributes stored in the kernel.
*/
266char hostname[MAXHOSTNAMELEN256];
267int hostnamelen;
268char domainname[MAXHOSTNAMELEN256];
269int domainnamelen;
270long hostid;
271char *disknames = NULL((void *)0);
272size_t disknameslen;
273struct diskstats *diskstats = NULL((void *)0);
274size_t diskstatslen;
275int securelevel;

277/* morally const values reported by sysctl_bounded_arr */
278static int arg_max = ARG_MAX(512 * 1024);
279static int openbsd = OpenBSD202110;
280static int posix_version = _POSIX_VERSION200809L;
281static int ngroups_max = NGROUPS_MAX16;
282static int int_zero = 0;
283static int int_one = 1;
284static int maxpartitions = MAXPARTITIONS16;
285static int raw_part = RAW_PART2;

287extern int somaxconn, sominconn;
288extern int nosuidcoredump;
289extern int maxlocksperuid;
290extern int uvm_wxabort;
291extern int global_ptrace;

293const struct sysctl_bounded_args kern_vars[] = {
{KERN_OSREV3, &openbsd, SYSCTL_INT_READONLY1,0},
{KERN_MAXVNODES5, &maxvnodes, 0, INT_MAX0x7fffffff},
{KERN_MAXPROC6, &maxprocess, 0, INT_MAX0x7fffffff},
{KERN_MAXFILES7, &maxfiles, 0, INT_MAX0x7fffffff},
{KERN_NFILES56, &numfiles, SYSCTL_INT_READONLY1,0},
{KERN_TTYCOUNT57, &tty_count, SYSCTL_INT_READONLY1,0},
{KERN_ARGMAX8, &arg_max, SYSCTL_INT_READONLY1,0},
{KERN_NSELCOLL43, &nselcoll, SYSCTL_INT_READONLY1,0},
{KERN_POSIX117, &posix_version, SYSCTL_INT_READONLY1,0},
{KERN_NGROUPS18, &ngroups_max, SYSCTL_INT_READONLY1,0},
{KERN_JOB_CONTROL19, &int_one, SYSCTL_INT_READONLY1,0},
{KERN_SAVED_IDS20, &int_one, SYSCTL_INT_READONLY1,0},
{KERN_MAXPARTITIONS23, &maxpartitions, SYSCTL_INT_READONLY1,0},
{KERN_RAWPARTITION24, &raw_part, SYSCTL_INT_READONLY1,0},
{KERN_MAXTHREAD25, &maxthread, 0, INT_MAX0x7fffffff},
{KERN_NTHREADS26, &nthreads, SYSCTL_INT_READONLY1,0},
{KERN_SOMAXCONN28, &somaxconn, 0, SHRT_MAX0x7fff},
{KERN_SOMINCONN29, &sominconn, 0, SHRT_MAX0x7fff},
{KERN_NOSUIDCOREDUMP32, &nosuidcoredump, 0, 3},
{KERN_FSYNC33, &int_one, SYSCTL_INT_READONLY1,0},
{KERN_SYSVMSG34,
315#ifdef SYSVMSG1
&int_one,
317#else
&int_zero,
319#endif
SYSCTL_INT_READONLY1,0},
{KERN_SYSVSEM35,
322#ifdef SYSVSEM1
&int_one,
324#else
&int_zero,
326#endif
SYSCTL_INT_READONLY1,0},
{KERN_SYSVSHM36,
329#ifdef SYSVSHM1
&int_one,
331#else
&int_zero,
333#endif
SYSCTL_INT_READONLY1,0},
{KERN_FSCALE46, &fscale, SYSCTL_INT_READONLY1,0},
{KERN_CCPU45, &ccpu, SYSCTL_INT_READONLY1,0},
{KERN_NPROCS47, &nprocesses, SYSCTL_INT_READONLY1,0},
{KERN_SPLASSERT54, &splassert_ctl, 0, 3},
{KERN_MAXLOCKSPERUID70, &maxlocksperuid, 0, INT_MAX0x7fffffff},
{KERN_WXABORT74, &uvm_wxabort, 0, 1},
{KERN_NETLIVELOCKS76, &int_zero, SYSCTL_INT_READONLY1,0},
342#ifdef PTRACE1
{KERN_GLOBAL_PTRACE81, &global_ptrace, 0, 1},
344#endif
345};

347int
348kern_sysctl_dirs(int top_name, int *name, u_int namelen,
  void *oldp, size_t *oldlenp, void *newp, size_t newlen, struct proc *p)
350{
switch (top_name) {
352#ifndef SMALL_KERNEL
case KERN_PROC66:
return (sysctl_doproc(name, namelen, oldp, oldlenp));
case KERN_PROC_ARGS55:
return (sysctl_proc_args(name, namelen, oldp, oldlenp, p));
case KERN_PROC_CWD78:
return (sysctl_proc_cwd(name, namelen, oldp, oldlenp, p));
case KERN_PROC_NOBROADCASTKILL79:
return (sysctl_proc_nobroadcastkill(name, namelen,
     newp, newlen, oldp, oldlenp, p));
case KERN_PROC_VMMAP80:
return (sysctl_proc_vmmap(name, namelen, oldp, oldlenp, p));
case KERN_FILE73:
return (sysctl_file(name, namelen, oldp, oldlenp, p));
366#endif
367#if defined(GPROF) || defined(DDBPROF)
case KERN_PROF16:
return (sysctl_doprof(name, namelen, oldp, oldlenp,
    newp, newlen));
371#endif
case KERN_MALLOCSTATS39:
return (sysctl_malloc(name, namelen, oldp, oldlenp,
    newp, newlen, p));
case KERN_TTY44:
return (sysctl_tty(name, namelen, oldp, oldlenp,
    newp, newlen));
case KERN_POOL49:
return (sysctl_dopool(name, namelen, oldp, oldlenp));
380#if defined(SYSVMSG1) || defined(SYSVSEM1) || defined(SYSVSHM1)
case KERN_SYSVIPC_INFO51:
return (sysctl_sysvipc(name, namelen, oldp, oldlenp));
383#endif
384#ifdef SYSVSEM1
case KERN_SEMINFO61:
return (sysctl_sysvsem(name, namelen, oldp, oldlenp,
    newp, newlen));
388#endif
389#ifdef SYSVSHM1
case KERN_SHMINFO62:
return (sysctl_sysvshm(name, namelen, oldp, oldlenp,
    newp, newlen));
393#endif
394#ifndef SMALL_KERNEL
case KERN_INTRCNT63:
return (sysctl_intrcnt(name, namelen, oldp, oldlenp));
case KERN_WATCHDOG64:
return (sysctl_wdog(name, namelen, oldp, oldlenp,
    newp, newlen));
400#endif
401#ifndef SMALL_KERNEL
case KERN_EVCOUNT68:
return (evcount_sysctl(name, namelen, oldp, oldlenp,
    newp, newlen));
405#endif
case KERN_TIMECOUNTER69:
return (sysctl_tc(name, namelen, oldp, oldlenp, newp, newlen));
case KERN_CPTIME271:
return (sysctl_cptime2(name, namelen, oldp, oldlenp,
    newp, newlen));
411#ifdef WITNESS
case KERN_WITNESSWATCH53:
return witness_sysctl_watch(oldp, oldlenp, newp, newlen);
case KERN_WITNESS60:
return witness_sysctl(name, namelen, oldp, oldlenp,
    newp, newlen);
417#endif
418#if NAUDIO1 > 0
case KERN_AUDIO84:
return (sysctl_audio(name, namelen, oldp, oldlenp,
    newp, newlen));
422#endif
423#if NVIDEO1 > 0
case KERN_VIDEO89:
return (sysctl_video(name, namelen, oldp, oldlenp,
    newp, newlen));
427#endif
case KERN_CPUSTATS85:
return (sysctl_cpustats(name, namelen, oldp, oldlenp,
    newp, newlen));
default:
return (ENOTDIR20);	/* overloaded */
}
434}

436/*
* kernel related system variables.
*/
439int
440kern_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
  size_t newlen, struct proc *p)
442{
int error, level, inthostid, stackgap;
dev_t dev;
extern int pool_debug;

/* dispatch the non-terminal nodes first */
if (namelen != 1) {
return kern_sysctl_dirs(name[0], name + 1, namelen - 1,
    oldp, oldlenp, newp, newlen, p);
}

switch (name[0]) {
case KERN_OSTYPE1:
return (sysctl_rdstring(oldp, oldlenp, newp, ostype));
case KERN_OSRELEASE2:
return (sysctl_rdstring(oldp, oldlenp, newp, osrelease));
case KERN_OSVERSION27:
return (sysctl_rdstring(oldp, oldlenp, newp, osversion));
case KERN_VERSION4:
return (sysctl_rdstring(oldp, oldlenp, newp, version));
case KERN_NUMVNODES58:  /* XXX numvnodes is a long */
return (sysctl_rdint(oldp, oldlenp, newp, numvnodes));
case KERN_SECURELVL9:
level = securelevel;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||
    newp == NULL((void *)0))
	return (error);
if ((securelevel > 0 || level < -1) &&
    level < securelevel && p->p_p->ps_pid != 1)
	return (EPERM1);
securelevel = level;
return (0);
474#if NDT1 > 0
case KERN_ALLOWDT65:
if (securelevel > 0)
	return (sysctl_rdint(oldp, oldlenp, newp, allowdt));
return (sysctl_int(oldp, oldlenp, newp, newlen,  &allowdt));
479#endif
case KERN_ALLOWKMEM52:
if (securelevel > 0)
	return (sysctl_rdint(oldp, oldlenp, newp, allowkmem));
return (sysctl_int(oldp, oldlenp, newp, newlen, &allowkmem));
case KERN_HOSTNAME10:
error = sysctl_tstring(oldp, oldlenp, newp, newlen,
    hostname, sizeof(hostname));
if (newp && !error)
	hostnamelen = newlen;
return (error);
case KERN_DOMAINNAME22:
error = sysctl_tstring(oldp, oldlenp, newp, newlen,
    domainname, sizeof(domainname));
if (newp && !error)
	domainnamelen = newlen;
return (error);
case KERN_HOSTID11:
inthostid = hostid;  /* XXX assumes sizeof long <= sizeof int */
error =  sysctl_int(oldp, oldlenp, newp, newlen, &inthostid);
hostid = inthostid;
return (error);
case KERN_CLOCKRATE12:
return (sysctl_clockrate(oldp, oldlenp, newp));
case KERN_BOOTTIME21: {
struct timeval bt;
memset(&bt, 0, sizeof bt)__builtin_memset((&bt), (0), (sizeof bt));
microboottime(&bt);
return (sysctl_rdstruct(oldp, oldlenp, newp, &bt, sizeof bt));
 }
case KERN_MBSTAT59: {
extern struct cpumem *mbstat;
uint64_t counters[MBSTAT_COUNT(8 + 3)];
struct mbstat mbs;
unsigned int i;

memset(&mbs, 0, sizeof(mbs))__builtin_memset((&mbs), (0), (sizeof(mbs)));
counters_read(mbstat, counters, MBSTAT_COUNT(8 + 3));
for (i = 0; i < MBSTAT_TYPES8; i++)
	mbs.m_mtypes[i] = counters[i];

mbs.m_drops = counters[MBSTAT_DROPS(8 + 0)];
mbs.m_wait = counters[MBSTAT_WAIT(8 + 1)];
mbs.m_drain = counters[MBSTAT_DRAIN(8 + 2)];

return (sysctl_rdstruct(oldp, oldlenp, newp,
    &mbs, sizeof(mbs)));
}
case KERN_MSGBUFSIZE38:
case KERN_CONSBUFSIZE82: {
struct msgbuf *mp;
mp = (name[0] == KERN_MSGBUFSIZE38) ? msgbufp : consbufp;
/*
 * deal with cases where the message buffer has
 * become corrupted.
 */
if (!mp || mp->msg_magic != MSG_MAGIC0x063061)
	return (ENXIO6);
return (sysctl_rdint(oldp, oldlenp, newp, mp->msg_bufs));
}
case KERN_CONSBUF83:
if ((error = suser(p)))
	return (error);
/* FALLTHROUGH */
case KERN_MSGBUF48: {
struct msgbuf *mp;
mp = (name[0] == KERN_MSGBUF48) ? msgbufp : consbufp;
/* see note above */
if (!mp || mp->msg_magic != MSG_MAGIC0x063061)
	return (ENXIO6);
return (sysctl_rdstruct(oldp, oldlenp, newp, mp,
    mp->msg_bufs + offsetof(struct msgbuf, msg_bufc)__builtin_offsetof(struct msgbuf, msg_bufc)));
}
case KERN_CPTIME40:
{
CPU_INFO_ITERATORint cii;
struct cpu_info *ci;
long cp_time[CPUSTATES6];
int i, n = 0;

memset(cp_time, 0, sizeof(cp_time))__builtin_memset((cp_time), (0), (sizeof(cp_time)));

CPU_INFO_FOREACH(cii, ci)for (cii = 0, ci = cpu_info_list; ci != ((void *)0); ci = ci->
ci_next) {
	if (!cpu_is_online(ci))
		continue;
	n++;
	for (i = 0; i < CPUSTATES6; i++)
		cp_time[i] += ci->ci_schedstate.spc_cp_time[i];
}

for (i = 0; i < CPUSTATES6; i++)
	cp_time[i] /= n;

return (sysctl_rdstruct(oldp, oldlenp, newp, &cp_time,
    sizeof(cp_time)));
}
case KERN_NCHSTATS41:
return (sysctl_rdstruct(oldp, oldlenp, newp, &nchstats,
    sizeof(struct nchstats)));
case KERN_FORKSTAT42:
return (sysctl_rdstruct(oldp, oldlenp, newp, &forkstat,
    sizeof(struct forkstat)));
case KERN_STACKGAPRANDOM50:
stackgap = stackgap_random;
error = sysctl_int(oldp, oldlenp, newp, newlen, &stackgap);
if (error)
	return (error);
/*
 * Safety harness.
 */
if ((stackgap < ALIGNBYTES(sizeof(long) - 1) && stackgap != 0) ||
    !powerof2(stackgap)((((stackgap)-1)&(stackgap))==0) || stackgap >= MAXSSIZ((paddr_t)32*1024*1024))
	return (EINVAL22);
stackgap_random = stackgap;
return (0);
case KERN_MAXCLUSTERS67: {
int val = nmbclust;
error = sysctl_int(oldp, oldlenp, newp, newlen, &val);
if (error == 0 && val != nmbclust)
	error = nmbclust_update(val);
return (error);
}
case KERN_CACHEPCT72: {
u_int64_t dmapages;
int opct, pgs;
opct = bufcachepercent;
error = sysctl_int(oldp, oldlenp, newp, newlen,
    &bufcachepercent);
if (error)
	return(error);
if (bufcachepercent > 90 || bufcachepercent < 5) {
	bufcachepercent = opct;
	return (EINVAL22);
}
dmapages = uvm_pagecount(&dma_constraint);
if (bufcachepercent != opct) {
	pgs = bufcachepercent * dmapages / 100;
	bufadjust(pgs); /* adjust bufpages */
	bufhighpages = bufpages; /* set high water mark */
}
return(0);
}
case KERN_CONSDEV75:
if (cn_tab != NULL((void *)0))
	dev = cn_tab->cn_dev;
else
	dev = NODEV(dev_t)(-1);
return sysctl_rdstruct(oldp, oldlenp, newp, &dev, sizeof(dev));
case KERN_POOL_DEBUG77: {
int old_pool_debug = pool_debug;

error = sysctl_int(oldp, oldlenp, newp, newlen,
    &pool_debug);
if (error == 0 && pool_debug != old_pool_debug)
	pool_reclaim_all();
return (error);
}
636#if NPF1 > 0
case KERN_PFSTATUS86:
return (pf_sysctl(oldp, oldlenp, newp, newlen));
639#endif
case KERN_TIMEOUT_STATS87:
return (timeout_sysctl(oldp, oldlenp, newp, newlen));
case KERN_UTC_OFFSET88:
return (sysctl_utc_offset(oldp, oldlenp, newp, newlen));
default:
return (sysctl_bounded_arr(kern_vars, nitems(kern_vars)(sizeof((kern_vars)) / sizeof((kern_vars)[0])), name,
    namelen, oldp, oldlenp, newp, newlen));
}
/* NOTREACHED */
649}

651/*
* hardware related system variables.
*/
654char *hw_vendor, *hw_prod, *hw_uuid, *hw_serial, *hw_ver;
655int allowpowerdown = 1;
656int hw_power = 1;

658/* morally const values reported by sysctl_bounded_arr */
659static int byte_order = BYTE_ORDER1234;
660static int page_size = PAGE_SIZE(1 << 12);

662const struct sysctl_bounded_args hw_vars[] = {
{HW_NCPU3, &ncpus, SYSCTL_INT_READONLY1,0},
{HW_NCPUFOUND21, &ncpusfound, SYSCTL_INT_READONLY1,0},
{HW_BYTEORDER4, &byte_order, SYSCTL_INT_READONLY1,0},
{HW_PAGESIZE7, &page_size, SYSCTL_INT_READONLY1,0},
{HW_DISKCOUNT10, &disk_count, SYSCTL_INT_READONLY1,0},
{HW_POWER26, &hw_power, SYSCTL_INT_READONLY1,0},
669};

671int
672hw_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
  size_t newlen, struct proc *p)
674{
extern char machine[], cpu_model[];
int err, cpuspeed;

/* all sysctl names at this level except sensors are terminal */
if (name[0] != HW_SENSORS11 && namelen != 1)
return (ENOTDIR20);		/* overloaded */

switch (name[0]) {
case HW_MACHINE1:
return (sysctl_rdstring(oldp, oldlenp, newp, machine));
case HW_MODEL2:
return (sysctl_rdstring(oldp, oldlenp, newp, cpu_model));
case HW_NCPUONLINE25:
return (sysctl_rdint(oldp, oldlenp, newp,
    sysctl_hwncpuonline()));
case HW_PHYSMEM5:
return (sysctl_rdint(oldp, oldlenp, newp, ptoa(physmem)((paddr_t)(physmem) << 12)));
case HW_USERMEM6:
return (sysctl_rdint(oldp, oldlenp, newp,
    ptoa(physmem - uvmexp.wired)((paddr_t)(physmem - uvmexp.wired) << 12)));
case HW_DISKNAMES8:
err = sysctl_diskinit(0, p);
if (err)
	return err;
if (disknames)
	return (sysctl_rdstring(oldp, oldlenp, newp,
	    disknames));
else
	return (sysctl_rdstring(oldp, oldlenp, newp, ""));
case HW_DISKSTATS9:
err = sysctl_diskinit(1, p);
if (err)
	return err;
return (sysctl_rdstruct(oldp, oldlenp, newp, diskstats,
    disk_count * sizeof(struct diskstats)));
case HW_CPUSPEED12:
if (!cpu_cpuspeed)
	return (EOPNOTSUPP45);
err = cpu_cpuspeed(&cpuspeed);
if (err)
	return err;
return (sysctl_rdint(oldp, oldlenp, newp, cpuspeed));
717#ifndef	SMALL_KERNEL
case HW_SENSORS11:
return (sysctl_sensors(name + 1, namelen - 1, oldp, oldlenp,
    newp, newlen));
case HW_SETPERF13:
return (sysctl_hwsetperf(oldp, oldlenp, newp, newlen));
case HW_PERFPOLICY23:
return (sysctl_hwperfpolicy(oldp, oldlenp, newp, newlen));
725#endif /* !SMALL_KERNEL */
case HW_VENDOR14:
if (hw_vendor)
	return (sysctl_rdstring(oldp, oldlenp, newp,
	    hw_vendor));
else
	return (EOPNOTSUPP45);
case HW_PRODUCT15:
if (hw_prod)
	return (sysctl_rdstring(oldp, oldlenp, newp, hw_prod));
else
	return (EOPNOTSUPP45);
case HW_VERSION16:
if (hw_ver)
	return (sysctl_rdstring(oldp, oldlenp, newp, hw_ver));
else
	return (EOPNOTSUPP45);
case HW_SERIALNO17:
if (hw_serial)
	return (sysctl_rdstring(oldp, oldlenp, newp,
	    hw_serial));
else
	return (EOPNOTSUPP45);
case HW_UUID18:
if (hw_uuid)
	return (sysctl_rdstring(oldp, oldlenp, newp, hw_uuid));
else
	return (EOPNOTSUPP45);
case HW_PHYSMEM6419:
return (sysctl_rdquad(oldp, oldlenp, newp,
    ptoa((psize_t)physmem)((paddr_t)((psize_t)physmem) << 12)));
case HW_USERMEM6420:
return (sysctl_rdquad(oldp, oldlenp, newp,
    ptoa((psize_t)physmem - uvmexp.wired)((paddr_t)((psize_t)physmem - uvmexp.wired) << 12)));
case HW_ALLOWPOWERDOWN22:
if (securelevel > 0)
	return (sysctl_rdint(oldp, oldlenp, newp,
	    allowpowerdown));
return (sysctl_int(oldp, oldlenp, newp, newlen,
    &allowpowerdown));
765#ifdef __HAVE_CPU_TOPOLOGY
case HW_SMT24:
return (sysctl_hwsmt(oldp, oldlenp, newp, newlen));
768#endif
default:
return sysctl_bounded_arr(hw_vars, nitems(hw_vars)(sizeof((hw_vars)) / sizeof((hw_vars)[0])), name,
    namelen, oldp, oldlenp, newp, newlen);
}
/* NOTREACHED */
774}

776#ifdef DEBUG_SYSCTL
777/*
* Debugging related system variables.
*/
780extern struct ctldebug debug_vfs_busyprt;
781struct ctldebug debug1, debug2, debug3, debug4;
782struct ctldebug debug5, debug6, debug7, debug8, debug9;
783struct ctldebug debug10, debug11, debug12, debug13, debug14;
784struct ctldebug debug15, debug16, debug17, debug18, debug19;
785static struct ctldebug *debugvars[CTL_DEBUG_MAXID20] = {
&debug_vfs_busyprt,
&debug1, &debug2, &debug3, &debug4,
&debug5, &debug6, &debug7, &debug8, &debug9,
&debug10, &debug11, &debug12, &debug13, &debug14,
&debug15, &debug16, &debug17, &debug18, &debug19,
791};
792int
793debug_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
  size_t newlen, struct proc *p)
795{
struct ctldebug *cdp;

/* all sysctl names at this level are name and field */
if (namelen != 2)
return (ENOTDIR20);		/* overloaded */
if (name[0] < 0 || name[0] >= nitems(debugvars)(sizeof((debugvars)) / sizeof((debugvars)[0])))
return (EOPNOTSUPP45);
cdp = debugvars[name[0]];
if (cdp->debugname == 0)
return (EOPNOTSUPP45);
switch (name[1]) {
case CTL_DEBUG_NAME0:
return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
case CTL_DEBUG_VALUE1:
return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
default:
return (EOPNOTSUPP45);
}
/* NOTREACHED */
815}
816#endif /* DEBUG_SYSCTL */

818/*
* Reads, or writes that lower the value
*/
821int
822sysctl_int_lower(void *oldp, size_t *oldlenp, void *newp, size_t newlen,
  int *valp)
824{
unsigned int oval = *valp, val = *valp;
int error;

if (newp == NULL((void *)0))
return (sysctl_rdint(oldp, oldlenp, newp, val));

if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)))
return (error);
if (val > oval)
return (EPERM1);		/* do not allow raising */
*(unsigned int *)valp = val;
return (0);
837}

839/*
* Validate parameters and get old / set new parameters
* for an integer-valued sysctl function.
*/
843int
844sysctl_int(void *oldp, size_t *oldlenp, void *newp, size_t newlen, int *valp)
845{
int error = 0;

if (oldp && *oldlenp < sizeof(int))
return (ENOMEM12);
if (newp && newlen != sizeof(int))
return (EINVAL22);
*oldlenp = sizeof(int);
if (oldp)
error = copyout(valp, oldp, sizeof(int));
if (error == 0 && newp)
error = copyin(newp, valp, sizeof(int));
return (error);
858}

860/*
* As above, but read-only.
*/
863int
864sysctl_rdint(void *oldp, size_t *oldlenp, void *newp, int val)
865{
int error = 0;

if (oldp && *oldlenp < sizeof(int))
return (ENOMEM12);
if (newp)
return (EPERM1);
*oldlenp = sizeof(int);
if (oldp)
error = copyout((caddr_t)&val, oldp, sizeof(int));
return (error);
876}

878/*
* Read-only or bounded integer values.
*/
881int
882sysctl_int_bounded(void *oldp, size_t *oldlenp, void *newp, size_t newlen,
  int *valp, int minimum, int maximum)
884{
int val = *valp;
int error;

/* read only */
if (newp == NULL((void *)0) || minimum > maximum)
return (sysctl_rdint(oldp, oldlenp, newp, val));

if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)))
return (error);
/* outside limits */
if (val < minimum || maximum < val)
return (EINVAL22);
*valp = val;
return (0);
899}

901/*
* Array of read-only or bounded integer values.
*/
904int
905sysctl_bounded_arr(const struct sysctl_bounded_args *valpp, u_int valplen,
  int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
  size_t newlen)
908{
u_int i;
if (namelen != 1)
return (ENOTDIR20);
for (i = 0; i < valplen; ++i) {
if (valpp[i].mib == name[0]) {
	return (sysctl_int_bounded(oldp, oldlenp, newp, newlen,
	    valpp[i].var, valpp[i].minimum, valpp[i].maximum));
}
}
return (EOPNOTSUPP45);
919}

921/*
* Validate parameters and get old / set new parameters
* for an integer-valued sysctl function.
*/
925int
926sysctl_quad(void *oldp, size_t *oldlenp, void *newp, size_t newlen,
  int64_t *valp)
928{
int error = 0;

if (oldp && *oldlenp < sizeof(int64_t))
return (ENOMEM12);
if (newp && newlen != sizeof(int64_t))
return (EINVAL22);
*oldlenp = sizeof(int64_t);
if (oldp)
error = copyout(valp, oldp, sizeof(int64_t));
if (error == 0 && newp)
error = copyin(newp, valp, sizeof(int64_t));
return (error);
941}

943/*
* As above, but read-only.
*/
946int
947sysctl_rdquad(void *oldp, size_t *oldlenp, void *newp, int64_t val)
948{
int error = 0;

if (oldp && *oldlenp < sizeof(int64_t))
return (ENOMEM12);
if (newp)
return (EPERM1);
*oldlenp = sizeof(int64_t);
if (oldp)
error = copyout((caddr_t)&val, oldp, sizeof(int64_t));
return (error);
959}

961/*
* Validate parameters and get old / set new parameters
* for a string-valued sysctl function.
*/
965int
966sysctl_string(void *oldp, size_t *oldlenp, void *newp, size_t newlen, char *str,
  size_t maxlen)
968{
return sysctl__string(oldp, oldlenp, newp, newlen, str, maxlen, 0);
970}

972int
973sysctl_tstring(void *oldp, size_t *oldlenp, void *newp, size_t newlen,
  char *str, size_t maxlen)
975{
return sysctl__string(oldp, oldlenp, newp, newlen, str, maxlen, 1);
977}

979int
980sysctl__string(void *oldp, size_t *oldlenp, void *newp, size_t newlen,
  char *str, size_t maxlen, int trunc)
982{
size_t len;
int error = 0;

len = strlen(str) + 1;
if (oldp && *oldlenp < len) {
if (trunc == 0 || *oldlenp == 0)
	return (ENOMEM12);
}
if (newp && newlen >= maxlen)
return (EINVAL22);
if (oldp) {
if (trunc && *oldlenp < len) {
	len = *oldlenp;
	error = copyout(str, oldp, len - 1);
	if (error == 0)
		error = copyout("", (char *)oldp + len - 1, 1);
} else {
	error = copyout(str, oldp, len);
}
}
*oldlenp = len;
if (error == 0 && newp) {
error = copyin(newp, str, newlen);
str[newlen] = 0;
}
return (error);
1009}

1011/*
* As above, but read-only.
*/
1014int
1015sysctl_rdstring(void *oldp, size_t *oldlenp, void *newp, const char *str)
1016{
size_t len;
int error = 0;

len = strlen(str) + 1;
if (oldp && *oldlenp < len)
return (ENOMEM12);
if (newp)
return (EPERM1);
*oldlenp = len;
if (oldp)
error = copyout(str, oldp, len);
return (error);
1029}

1031/*
* Validate parameters and get old / set new parameters
* for a structure oriented sysctl function.
*/
1035int
1036sysctl_struct(void *oldp, size_t *oldlenp, void *newp, size_t newlen, void *sp,
  size_t len)
1038{
int error = 0;

if (oldp && *oldlenp < len)
return (ENOMEM12);
if (newp && newlen > len)
return (EINVAL22);
if (oldp) {
*oldlenp = len;
error = copyout(sp, oldp, len);
}
if (error == 0 && newp)
error = copyin(newp, sp, len);
return (error);
1052}

1054/*
* Validate parameters and get old parameters
* for a structure oriented sysctl function.
*/
1058int
1059sysctl_rdstruct(void *oldp, size_t *oldlenp, void *newp, const void *sp,
  size_t len)
1061{
int error = 0;

if (oldp && *oldlenp < len)
return (ENOMEM12);
if (newp)
return (EPERM1);
*oldlenp = len;
if (oldp)
error = copyout(sp, oldp, len);
return (error);
1072}

1074#ifndef SMALL_KERNEL
1075void
1076fill_file(struct kinfo_file *kf, struct file *fp, struct filedesc *fdp,
 int fd, struct vnode *vp, struct process *pr, struct proc *p,
 struct socket *so, int show_pointers)
1079{
struct vattr va;

memset(kf, 0, sizeof(*kf))__builtin_memset((kf), (0), (sizeof(*kf)));

kf->fd_fd = fd;		/* might not really be an fd */

if (fp != NULL((void *)0)) {
1
Assuming 'fp' is equal to NULL→
2
←
Taking false branch→
if (show_pointers)
	kf->f_fileaddr = PTRTOINT64(fp)((u_int64_t)(u_long)(fp));
kf->f_flag = fp->f_flag;
kf->f_iflags = fp->f_iflags;
kf->f_type = fp->f_type;
kf->f_count = fp->f_count;
if (show_pointers)
	kf->f_ucred = PTRTOINT64(fp->f_cred)((u_int64_t)(u_long)(fp->f_cred));
kf->f_uid = fp->f_cred->cr_uid;
kf->f_gid = fp->f_cred->cr_gid;
if (show_pointers)
	kf->f_ops = PTRTOINT64(fp->f_ops)((u_int64_t)(u_long)(fp->f_ops));
if (show_pointers)
	kf->f_data = PTRTOINT64(fp->f_data)((u_int64_t)(u_long)(fp->f_data));
kf->f_usecount = 0;

if (suser(p) == 0 || p->p_ucred->cr_uid == fp->f_cred->cr_uid) {
	mtx_enter(&fp->f_mtx);
	kf->f_offset = fp->f_offset;
	kf->f_rxfer = fp->f_rxfer;
	kf->f_rwfer = fp->f_wxfer;
	kf->f_seek = fp->f_seek;
	kf->f_rbytes = fp->f_rbytes;
	kf->f_wbytes = fp->f_wbytes;
	mtx_leave(&fp->f_mtx);
} else
	kf->f_offset = -1;
} else if (vp != NULL((void *)0)) {
3
←
Assuming 'vp' is equal to NULL→
4
←
Taking false branch→
/* fake it */
kf->f_type = DTYPE_VNODE1;
kf->f_flag = FREAD0x0001;
if (fd == KERN_FILE_TRACE-4)
	kf->f_flag |= FWRITE0x0002;
} else if (so != NULL((void *)0)) {
5
←
Assuming 'so' is equal to NULL→
6
←
Taking false branch→
/* fake it */
kf->f_type = DTYPE_SOCKET2;
}

/* information about the object associated with this file */
switch (kf->f_type) {
7
←
Control jumps to 'case 1:'  at line 1127→
case DTYPE_VNODE1:
if (fp7.1
'fp' is equal to NULL
 != NULL((void *)0))
8
←
Taking false branch→
	vp = (struct vnode *)fp->f_data;

if (show_pointers)
9
←
Assuming 'show_pointers' is 0→
10
←
Taking false branch→
	kf->v_un = PTRTOINT64(vp->v_un.vu_socket)((u_int64_t)(u_long)(vp->v_un.vu_socket));
kf->v_type = vp->v_type;
11
←
Access to field 'v_type' results in a dereference of a null pointer (loaded from variable 'vp')
kf->v_tag = vp->v_tag;
kf->v_flag = vp->v_flag;
if (show_pointers)
	kf->v_data = PTRTOINT64(vp->v_data)((u_int64_t)(u_long)(vp->v_data));
if (show_pointers)
	kf->v_mount = PTRTOINT64(vp->v_mount)((u_int64_t)(u_long)(vp->v_mount));
if (vp->v_mount)
	strlcpy(kf->f_mntonname,
	    vp->v_mount->mnt_stat.f_mntonname,
	    sizeof(kf->f_mntonname));

if (VOP_GETATTR(vp, &va, p->p_ucred, p) == 0) {
	kf->va_fileid = va.va_fileid;
	kf->va_mode = MAKEIMODE(va.va_type, va.va_mode)(int)((vttoif_tab[(int)(va.va_type)]) | (va.va_mode));
	kf->va_size = va.va_size;
	kf->va_rdev = va.va_rdev;
	kf->va_fsid = va.va_fsid & 0xffffffff;
	kf->va_nlink = va.va_nlink;
}
break;

case DTYPE_SOCKET2: {
int locked = 0;

if (so == NULL((void *)0)) {
	so = (struct socket *)fp->f_data;
	/* if so is passed as parameter it is already locked */
	switch (so->so_proto->pr_domain->dom_family) {
	case AF_INET2:
	case AF_INET624:
		NET_LOCK()do { rw_enter_write(&netlock); } while (0);
		locked = 1;
		break;
	}
}

kf->so_type = so->so_type;
kf->so_state = so->so_state;
if (show_pointers)
	kf->so_pcb = PTRTOINT64(so->so_pcb)((u_int64_t)(u_long)(so->so_pcb));
else
	kf->so_pcb = -1;
kf->so_protocol = so->so_proto->pr_protocol;
kf->so_family = so->so_proto->pr_domain->dom_family;
kf->so_rcv_cc = so->so_rcv.sb_cc;
kf->so_snd_cc = so->so_snd.sb_cc;
if (isspliced(so)((so)->so_sp && (so)->so_sp->ssp_socket)) {
	if (show_pointers)
		kf->so_splice =
		    PTRTOINT64(so->so_sp->ssp_socket)((u_int64_t)(u_long)(so->so_sp->ssp_socket));
	kf->so_splicelen = so->so_sp->ssp_len;
} else if (issplicedback(so)((so)->so_sp && (so)->so_sp->ssp_soback))
	kf->so_splicelen = -1;
if (so->so_pcb == NULL((void *)0)) {
	if (locked)
		NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
	break;
}
switch (kf->so_family) {
case AF_INET2: {
	struct inpcb *inpcb = so->so_pcb;

	NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
 0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
	if (show_pointers)
		kf->inp_ppcb = PTRTOINT64(inpcb->inp_ppcb)((u_int64_t)(u_long)(inpcb->inp_ppcb));
	kf->inp_lport = inpcb->inp_lport;
	kf->inp_laddru[0] = inpcb->inp_laddrinp_laddru.iau_a4u.inaddr.s_addr;
	kf->inp_fport = inpcb->inp_fport;
	kf->inp_faddru[0] = inpcb->inp_faddrinp_faddru.iau_a4u.inaddr.s_addr;
	kf->inp_rtableid = inpcb->inp_rtableid;
	if (so->so_type == SOCK_RAW3)
		kf->inp_proto = inpcb->inp_ipinp_hu.hu_ip.ip_p;
	if (so->so_proto->pr_protocol == IPPROTO_TCP6) {
		struct tcpcb *tcpcb = (void *)inpcb->inp_ppcb;
		kf->t_rcv_wnd = tcpcb->rcv_wnd;
		kf->t_snd_wnd = tcpcb->snd_wnd;
		kf->t_snd_cwnd = tcpcb->snd_cwnd;
		kf->t_state = tcpcb->t_state;
	}
	break;
    }
case AF_INET624: {
	struct inpcb *inpcb = so->so_pcb;

	NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
 0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
	if (show_pointers)
		kf->inp_ppcb = PTRTOINT64(inpcb->inp_ppcb)((u_int64_t)(u_long)(inpcb->inp_ppcb));
	kf->inp_lport = inpcb->inp_lport;
	kf->inp_laddru[0] = inpcb->inp_laddr6inp_laddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[0];
	kf->inp_laddru[1] = inpcb->inp_laddr6inp_laddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[1];
	kf->inp_laddru[2] = inpcb->inp_laddr6inp_laddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[2];
	kf->inp_laddru[3] = inpcb->inp_laddr6inp_laddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[3];
	kf->inp_fport = inpcb->inp_fport;
	kf->inp_faddru[0] = inpcb->inp_faddr6inp_faddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[0];
	kf->inp_faddru[1] = inpcb->inp_faddr6inp_faddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[1];
	kf->inp_faddru[2] = inpcb->inp_faddr6inp_faddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[2];
	kf->inp_faddru[3] = inpcb->inp_faddr6inp_faddru.iau_addr6.s6_addr32__u6_addr.__u6_addr32[3];
	kf->inp_rtableid = inpcb->inp_rtableid;
	if (so->so_type == SOCK_RAW3)
		kf->inp_proto = inpcb->inp_ipv6inp_hu.hu_ipv6.ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt;
	if (so->so_proto->pr_protocol == IPPROTO_TCP6) {
		struct tcpcb *tcpcb = (void *)inpcb->inp_ppcb;
		kf->t_rcv_wnd = tcpcb->rcv_wnd;
		kf->t_snd_wnd = tcpcb->snd_wnd;
		kf->t_state = tcpcb->t_state;
	}
	break;
    }
case AF_UNIX1: {
	struct unpcb *unpcb = so->so_pcb;

	kf->f_msgcount = unpcb->unp_msgcount;
	if (show_pointers) {
		kf->unp_conn	= PTRTOINT64(unpcb->unp_conn)((u_int64_t)(u_long)(unpcb->unp_conn));
		kf->unp_refs	= PTRTOINT64(((u_int64_t)(u_long)(((&unpcb->unp_refs)->slh_first
)))
		    SLIST_FIRST(&unpcb->unp_refs))((u_int64_t)(u_long)(((&unpcb->unp_refs)->slh_first
)));
		kf->unp_nextref	= PTRTOINT64(((u_int64_t)(u_long)(((unpcb)->unp_nextref.sle_next)))
		    SLIST_NEXT(unpcb, unp_nextref))((u_int64_t)(u_long)(((unpcb)->unp_nextref.sle_next)));
		kf->v_un	= PTRTOINT64(unpcb->unp_vnode)((u_int64_t)(u_long)(unpcb->unp_vnode));
		kf->unp_addr	= PTRTOINT64(unpcb->unp_addr)((u_int64_t)(u_long)(unpcb->unp_addr));
	}
	if (unpcb->unp_addr != NULL((void *)0)) {
		struct sockaddr_un *un = mtod(unpcb->unp_addr,((struct sockaddr_un *)((unpcb->unp_addr)->m_hdr.mh_data
))
		    struct sockaddr_un *)((struct sockaddr_un *)((unpcb->unp_addr)->m_hdr.mh_data
));
		memcpy(kf->unp_path, un->sun_path, un->sun_len__builtin_memcpy((kf->unp_path), (un->sun_path), (un->
sun_len - __builtin_offsetof(struct sockaddr_un, sun_path)))
		    - offsetof(struct sockaddr_un,sun_path))__builtin_memcpy((kf->unp_path), (un->sun_path), (un->
sun_len - __builtin_offsetof(struct sockaddr_un, sun_path)));
	}
	break;
    }
}
if (locked)
	NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
break;
   }

case DTYPE_PIPE3: {
struct pipe *pipe = (struct pipe *)fp->f_data;

if (show_pointers)
	kf->pipe_peer = PTRTOINT64(pipe->pipe_peer)((u_int64_t)(u_long)(pipe->pipe_peer));
kf->pipe_state = pipe->pipe_state;
break;
   }

case DTYPE_KQUEUE4: {
struct kqueue *kqi = (struct kqueue *)fp->f_data;

kf->kq_count = kqi->kq_count;
kf->kq_state = kqi->kq_state;
break;
   }
}

/* per-process information for KERN_FILE_BY[PU]ID */
if (pr != NULL((void *)0)) {
kf->p_pid = pr->ps_pid;
kf->p_uid = pr->ps_ucred->cr_uid;
kf->p_gid = pr->ps_ucred->cr_gid;
kf->p_tid = -1;
strlcpy(kf->p_comm, pr->ps_comm, sizeof(kf->p_comm));
}
if (fdp != NULL((void *)0)) {
fdplock(fdp)do { do { int _s = rw_status(&netlock); if ((splassert_ctl
 > 0) && (_s == 0x0001UL)) splassert_fail(0, 0x0001UL
, __func__); } while (0); rw_enter_write(&(fdp)->fd_lock
); } while (0);
kf->fd_ofileflags = fdp->fd_ofileflags[fd];
fdpunlock(fdp)rw_exit_write(&(fdp)->fd_lock);
}
1300}

1302/*
* Get file structures.
*/
1305int
1306sysctl_file(int *name, u_int namelen, char *where, size_t *sizep,
  struct proc *p)
1308{
struct kinfo_file *kf;
struct filedesc *fdp;
struct file *fp;
struct process *pr;
size_t buflen, elem_size, elem_count, outsize;
char *dp = where;
int arg, i, error = 0, needed = 0, matched;
u_int op;
int show_pointers;

if (namelen > 4)
return (ENOTDIR20);
if (namelen < 4 || name[2] > sizeof(*kf))
return (EINVAL22);

buflen = where != NULL((void *)0) ? *sizep : 0;
op = name[0];
arg = name[1];
elem_size = name[2];
elem_count = name[3];
outsize = MIN(sizeof(*kf), elem_size)(((sizeof(*kf))<(elem_size))?(sizeof(*kf)):(elem_size));

if (elem_size < 1)
return (EINVAL22);

show_pointers = suser(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc) == 0;

kf = malloc(sizeof(*kf), M_TEMP127, M_WAITOK0x0001);

1338#define FILLIT2(fp, fdp, i, vp, pr, so)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, fp, fdp, i, vp, pr, p, so, show_pointers); error
 = copyout(kf, dp, outsize); if (error) break; dp += elem_size
; buflen -= elem_size; elem_count--; } needed += elem_size; }
 while (0) do {				\
if (buflen >= elem_size && elem_count > 0) {			\
fill_file(kf, fp, fdp, i, vp, pr, p, so, show_pointers);\
error = copyout(kf, dp, outsize);			\
if (error)						\
	break;						\
dp += elem_size;					\
buflen -= elem_size;					\
elem_count--;						\
}								\
needed += elem_size;						\
1349} while (0)
1350#define FILLIT(fp, fdp, i, vp, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, fp, fdp, i, vp, pr, p, ((void *)0), show_pointers
); error = copyout(kf, dp, outsize); if (error) break; dp += elem_size
; buflen -= elem_size; elem_count--; } needed += elem_size; }
 while (0) \
FILLIT2(fp, fdp, i, vp, pr, NULL)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, fp, fdp, i, vp, pr, p, ((void *)0), show_pointers
); error = copyout(kf, dp, outsize); if (error) break; dp += elem_size
; buflen -= elem_size; elem_count--; } needed += elem_size; }
 while (0)
1352#define FILLSO(so)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), 0, ((void *)0), ((
void *)0), p, so, show_pointers); error = copyout(kf, dp, outsize
); if (error) break; dp += elem_size; buflen -= elem_size; elem_count
--; } needed += elem_size; } while (0) \
FILLIT2(NULL, NULL, 0, NULL, NULL, so)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), 0, ((void *)0), ((
void *)0), p, so, show_pointers); error = copyout(kf, dp, outsize
); if (error) break; dp += elem_size; buflen -= elem_size; elem_count
--; } needed += elem_size; } while (0)

switch (op) {
case KERN_FILE_BYFILE1:
/* use the inp-tables to pick up closed connections, too */
if (arg == DTYPE_SOCKET2) {
	struct inpcb *inp;

	NET_LOCK()do { rw_enter_write(&netlock); } while (0);
	TAILQ_FOREACH(inp, &tcbtable.inpt_queue, inp_queue)for((inp) = ((&tcbtable.inpt_queue)->tqh_first); (inp)
 != ((void *)0); (inp) = ((inp)->inp_queue.tqe_next))
		FILLSO(inp->inp_socket)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), 0, ((void *)0), ((
void *)0), p, inp->inp_socket, show_pointers); error = copyout
(kf, dp, outsize); if (error) break; dp += elem_size; buflen -=
 elem_size; elem_count--; } needed += elem_size; } while (0);
	TAILQ_FOREACH(inp, &udbtable.inpt_queue, inp_queue)for((inp) = ((&udbtable.inpt_queue)->tqh_first); (inp)
 != ((void *)0); (inp) = ((inp)->inp_queue.tqe_next))
		FILLSO(inp->inp_socket)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), 0, ((void *)0), ((
void *)0), p, inp->inp_socket, show_pointers); error = copyout
(kf, dp, outsize); if (error) break; dp += elem_size; buflen -=
 elem_size; elem_count--; } needed += elem_size; } while (0);
	TAILQ_FOREACH(inp, &rawcbtable.inpt_queue, inp_queue)for((inp) = ((&rawcbtable.inpt_queue)->tqh_first); (inp
) != ((void *)0); (inp) = ((inp)->inp_queue.tqe_next))
		FILLSO(inp->inp_socket)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), 0, ((void *)0), ((
void *)0), p, inp->inp_socket, show_pointers); error = copyout
(kf, dp, outsize); if (error) break; dp += elem_size; buflen -=
 elem_size; elem_count--; } needed += elem_size; } while (0);
1368#ifdef INET61
	TAILQ_FOREACH(inp, &rawin6pcbtable.inpt_queue,for((inp) = ((&rawin6pcbtable.inpt_queue)->tqh_first);
 (inp) != ((void *)0); (inp) = ((inp)->inp_queue.tqe_next)
)
	    inp_queue)for((inp) = ((&rawin6pcbtable.inpt_queue)->tqh_first);
 (inp) != ((void *)0); (inp) = ((inp)->inp_queue.tqe_next)
)
		FILLSO(inp->inp_socket)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), 0, ((void *)0), ((
void *)0), p, inp->inp_socket, show_pointers); error = copyout
(kf, dp, outsize); if (error) break; dp += elem_size; buflen -=
 elem_size; elem_count--; } needed += elem_size; } while (0);
1372#endif
	NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
}
fp = NULL((void *)0);
while ((fp = fd_iterfile(fp, p)) != NULL((void *)0)) {
	if ((arg == 0 || fp->f_type == arg)) {
		int af, skip = 0;
		if (arg == DTYPE_SOCKET2 && fp->f_type == arg) {
			af = ((struct socket *)fp->f_data)->
			    so_proto->pr_domain->dom_family;
			if (af == AF_INET2 || af == AF_INET624)
				skip = 1;
		}
		if (!skip)
			FILLIT(fp, NULL, 0, NULL, NULL)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, fp, ((void *)0), 0, ((void *)0), ((void *)0)
, p, ((void *)0), show_pointers); error = copyout(kf, dp, outsize
); if (error) break; dp += elem_size; buflen -= elem_size; elem_count
--; } needed += elem_size; } while (0);
	}
}
break;
case KERN_FILE_BYPID2:
/* A arg of -1 indicates all processes */
if (arg < -1) {
	error = EINVAL22;
	break;
}
matched = 0;
LIST_FOREACH(pr, &allprocess, ps_list)for((pr) = ((&allprocess)->lh_first); (pr)!= ((void *)
0); (pr) = ((pr)->ps_list.le_next)) {
	/*
	 * skip system, exiting, embryonic and undead
	 * processes
	 */
	if (pr->ps_flags & (PS_SYSTEM0x00010000 | PS_EMBRYO0x00020000 | PS_EXITING0x00000008))
		continue;
	if (arg > 0 && pr->ps_pid != (pid_t)arg) {
		/* not the pid we are looking for */
		continue;
	}
	matched = 1;
	fdp = pr->ps_fd;
	if (pr->ps_textvp)
		FILLIT(NULL, NULL, KERN_FILE_TEXT, pr->ps_textvp, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -1, pr->ps_textvp
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	if (fdp->fd_cdir)
		FILLIT(NULL, NULL, KERN_FILE_CDIR, fdp->fd_cdir, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -2, fdp->fd_cdir
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	if (fdp->fd_rdir)
		FILLIT(NULL, NULL, KERN_FILE_RDIR, fdp->fd_rdir, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -3, fdp->fd_rdir
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	if (pr->ps_tracevp)
		FILLIT(NULL, NULL, KERN_FILE_TRACE, pr->ps_tracevp, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -4, pr->ps_tracevp
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	for (i = 0; i < fdp->fd_nfiles; i++) {
		if ((fp = fd_getfile(fdp, i)) == NULL((void *)0))
			continue;
		FILLIT(fp, fdp, i, NULL, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, fp, fdp, i, ((void *)0), pr, p, ((void *)0),
 show_pointers); error = copyout(kf, dp, outsize); if (error)
 break; dp += elem_size; buflen -= elem_size; elem_count--; }
 needed += elem_size; } while (0);
		FRELE(fp, p)(_atomic_sub_int_nv((&fp->f_count), 1) == 0 ? fdrop(fp
, p) : 0);
	}
}
if (!matched)
	error = ESRCH3;
break;
case KERN_FILE_BYUID3:
LIST_FOREACH(pr, &allprocess, ps_list)for((pr) = ((&allprocess)->lh_first); (pr)!= ((void *)
0); (pr) = ((pr)->ps_list.le_next)) {
	/*
	 * skip system, exiting, embryonic and undead
	 * processes
	 */
	if (pr->ps_flags & (PS_SYSTEM0x00010000 | PS_EMBRYO0x00020000 | PS_EXITING0x00000008))
		continue;
	if (arg >= 0 && pr->ps_ucred->cr_uid != (uid_t)arg) {
		/* not the uid we are looking for */
		continue;
	}
	fdp = pr->ps_fd;
	if (fdp->fd_cdir)
		FILLIT(NULL, NULL, KERN_FILE_CDIR, fdp->fd_cdir, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -2, fdp->fd_cdir
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	if (fdp->fd_rdir)
		FILLIT(NULL, NULL, KERN_FILE_RDIR, fdp->fd_rdir, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -3, fdp->fd_rdir
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	if (pr->ps_tracevp)
		FILLIT(NULL, NULL, KERN_FILE_TRACE, pr->ps_tracevp, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, ((void *)0), ((void *)0), -4, pr->ps_tracevp
, pr, p, ((void *)0), show_pointers); error = copyout(kf, dp,
 outsize); if (error) break; dp += elem_size; buflen -= elem_size
; elem_count--; } needed += elem_size; } while (0);
	for (i = 0; i < fdp->fd_nfiles; i++) {
		if ((fp = fd_getfile(fdp, i)) == NULL((void *)0))
			continue;
		FILLIT(fp, fdp, i, NULL, pr)do { if (buflen >= elem_size && elem_count > 0)
 { fill_file(kf, fp, fdp, i, ((void *)0), pr, p, ((void *)0),
 show_pointers); error = copyout(kf, dp, outsize); if (error)
 break; dp += elem_size; buflen -= elem_size; elem_count--; }
 needed += elem_size; } while (0);
		FRELE(fp, p)(_atomic_sub_int_nv((&fp->f_count), 1) == 0 ? fdrop(fp
, p) : 0);
	}
}
break;
default:
error = EINVAL22;
break;
}
free(kf, M_TEMP127, sizeof(*kf));

if (!error) {
if (where == NULL((void *)0))
	needed += KERN_FILESLOP10 * elem_size;
else if (*sizep < needed)
	error = ENOMEM12;
*sizep = needed;
}

return (error);
1470}

1472/*
* try over estimating by 5 procs
*/
1475#define KERN_PROCSLOP5	5

1477int
1478sysctl_doproc(int *name, u_int namelen, char *where, size_t *sizep)
1479{
struct kinfo_proc *kproc = NULL((void *)0);
struct proc *p;
struct process *pr;
char *dp;
int arg, buflen, doingzomb, elem_size, elem_count;
int error, needed, op;
int dothreads = 0;
int show_pointers;

dp = where;
buflen = where != NULL((void *)0) ? *sizep : 0;
needed = error = 0;

if (namelen != 4 || name[2] <= 0 || name[3] < 0 ||
   name[2] > sizeof(*kproc))
return (EINVAL22);
op = name[0];
arg = name[1];
elem_size = name[2];
elem_count = name[3];

dothreads = op & KERN_PROC_SHOW_THREADS0x40000000;
op &= ~KERN_PROC_SHOW_THREADS0x40000000;

show_pointers = suser(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc) == 0;

if (where != NULL((void *)0))
kproc = malloc(sizeof(*kproc), M_TEMP127, M_WAITOK0x0001);

pr = LIST_FIRST(&allprocess)((&allprocess)->lh_first);
doingzomb = 0;
1511again:
for (; pr != NULL((void *)0); pr = LIST_NEXT(pr, ps_list)((pr)->ps_list.le_next)) {
/* XXX skip processes in the middle of being zapped */
if (pr->ps_pgrp == NULL((void *)0))
	continue;

/*
 * Skip embryonic processes.
 */
if (pr->ps_flags & PS_EMBRYO0x00020000)
	continue;

/*
 * TODO - make more efficient (see notes below).
 */
switch (op) {

case KERN_PROC_PID1:
	/* could do this with just a lookup */
	if (pr->ps_pid != (pid_t)arg)
		continue;
	break;

case KERN_PROC_PGRP2:
	/* could do this by traversing pgrp */
	if (pr->ps_pgrp->pg_id != (pid_t)arg)
		continue;
	break;

case KERN_PROC_SESSION3:
	if (pr->ps_sessionps_pgrp->pg_session->s_leader == NULL((void *)0) ||
	    pr->ps_sessionps_pgrp->pg_session->s_leader->ps_pid != (pid_t)arg)
		continue;
	break;

case KERN_PROC_TTY4:
	if ((pr->ps_flags & PS_CONTROLT0x00000001) == 0 ||
	    pr->ps_sessionps_pgrp->pg_session->s_ttyp == NULL((void *)0) ||
	    pr->ps_sessionps_pgrp->pg_session->s_ttyp->t_dev != (dev_t)arg)
		continue;
	break;

case KERN_PROC_UID5:
	if (pr->ps_ucred->cr_uid != (uid_t)arg)
		continue;
	break;

case KERN_PROC_RUID6:
	if (pr->ps_ucred->cr_ruid != (uid_t)arg)
		continue;
	break;

case KERN_PROC_ALL0:
	if (pr->ps_flags & PS_SYSTEM0x00010000)
		continue;
	break;

case KERN_PROC_KTHREAD7:
	/* no filtering */
	break;

default:
	error = EINVAL22;
	goto err;
}

if (buflen >= elem_size && elem_count > 0) {
	fill_kproc(pr, kproc, NULL((void *)0), show_pointers);
	error = copyout(kproc, dp, elem_size);
	if (error)
		goto err;
	dp += elem_size;
	buflen -= elem_size;
	elem_count--;
}
needed += elem_size;

/* Skip per-thread entries if not required by op */
if (!dothreads)
	continue;

TAILQ_FOREACH(p, &pr->ps_threads, p_thr_link)for((p) = ((&pr->ps_threads)->tqh_first); (p) != ((
void *)0); (p) = ((p)->p_thr_link.tqe_next)) {
	if (buflen >= elem_size && elem_count > 0) {
		fill_kproc(pr, kproc, p, show_pointers);
		error = copyout(kproc, dp, elem_size);
		if (error)
			goto err;
		dp += elem_size;
		buflen -= elem_size;
		elem_count--;
	}
	needed += elem_size;
}
}
if (doingzomb == 0) {
pr = LIST_FIRST(&zombprocess)((&zombprocess)->lh_first);
doingzomb++;
goto again;
}
if (where != NULL((void *)0)) {
*sizep = dp - where;
if (needed > *sizep) {
	error = ENOMEM12;
	goto err;
}
} else {
needed += KERN_PROCSLOP5 * elem_size;
*sizep = needed;
}
1620err:
if (kproc)
free(kproc, M_TEMP127, sizeof(*kproc));
return (error);
1624}

1626/*
* Fill in a kproc structure for the specified process.
*/
1629void
1630fill_kproc(struct process *pr, struct kinfo_proc *ki, struct proc *p,
  int show_pointers)
1632{
struct session *s = pr->ps_sessionps_pgrp->pg_session;
struct tty *tp;
struct vmspace *vm = pr->ps_vmspace;
struct timespec booted, st, ut, utc;
int isthread;

isthread = p != NULL((void *)0);
if (!isthread)
p = pr->ps_mainproc;		/* XXX */

FILL_KPROC(ki, strlcpy, p, pr, pr->ps_ucred, pr->ps_pgrp,do { __builtin_memset(((ki)), (0), (sizeof(*(ki)))); if (show_pointers
) { (ki)->p_paddr = ((u_int64_t)(u_long)(p)); (ki)->p_fd
 = ((u_int64_t)(u_long)((pr)->ps_fd)); (ki)->p_limit = (
(u_int64_t)(u_long)((pr)->ps_limit)); (ki)->p_vmspace =
 ((u_int64_t)(u_long)((pr)->ps_vmspace)); (ki)->p_sigacts
 = ((u_int64_t)(u_long)((pr)->ps_sigacts)); (ki)->p_sess
 = ((u_int64_t)(u_long)((pr->ps_pgrp)->pg_session)); (ki
)->p_ru = ((u_int64_t)(u_long)((pr)->ps_ru)); } (ki)->
p_stats = 0; (ki)->p_exitsig = 0; (ki)->p_flag = (p)->
p_flag; (ki)->p_pid = (pr)->ps_pid; (ki)->p_psflags =
 (pr)->ps_flags; (ki)->p__pgid = (pr->ps_pgrp)->pg_id
; (ki)->p_uid = (pr->ps_ucred)->cr_uid; (ki)->p_ruid
 = (pr->ps_ucred)->cr_ruid; (ki)->p_gid = (pr->ps_ucred
)->cr_gid; (ki)->p_rgid = (pr->ps_ucred)->cr_rgid
; (ki)->p_svuid = (pr->ps_ucred)->cr_svuid; (ki)->
p_svgid = (pr->ps_ucred)->cr_svgid; __builtin_memcpy(((
ki)->p_groups), ((pr->ps_ucred)->cr_groups), ((((sizeof
((ki)->p_groups))<(sizeof((pr->ps_ucred)->cr_groups
)))?(sizeof((ki)->p_groups)):(sizeof((pr->ps_ucred)->
cr_groups))))); (ki)->p_ngroups = (pr->ps_ucred)->cr_ngroups
; (ki)->p_jobc = (pr->ps_pgrp)->pg_jobc; (ki)->p_estcpu
 = (p)->p_estcpu; if (isthread) { (ki)->p_rtime_sec = (
p)->p_tu.tu_runtime.tv_sec; (ki)->p_rtime_usec = (p)->
p_tu.tu_runtime.tv_nsec/1000; (ki)->p_tid = (p)->p_tid +
 100000; (ki)->p_uticks = (p)->p_tu.tu_uticks; (ki)->
p_sticks = (p)->p_tu.tu_sticks; (ki)->p_iticks = (p)->
p_tu.tu_iticks; } else { (ki)->p_rtime_sec = (pr)->ps_tu
.tu_runtime.tv_sec; (ki)->p_rtime_usec = (pr)->ps_tu.tu_runtime
.tv_nsec/1000; (ki)->p_tid = -1; (ki)->p_uticks = (pr)->
ps_tu.tu_uticks; (ki)->p_sticks = (pr)->ps_tu.tu_sticks
; (ki)->p_iticks = (pr)->ps_tu.tu_iticks; } (ki)->p_cpticks
 = (p)->p_cpticks; if (show_pointers) (ki)->p_tracep = (
(u_int64_t)(u_long)((pr)->ps_tracevp)); (ki)->p_traceflag
 = (pr)->ps_traceflag; (ki)->p_siglist = (p)->p_siglist
 | (pr)->ps_siglist; (ki)->p_sigmask = (p)->p_sigmask
; (ki)->p_sigignore = (pr->ps_sigacts) ? (pr->ps_sigacts
)->ps_sigignore : 0; (ki)->p_sigcatch = (pr->ps_sigacts
) ? (pr->ps_sigacts)->ps_sigcatch : 0; (ki)->p_stat =
 (p)->p_stat; (ki)->p_nice = (pr)->ps_nice; (ki)->
p_xstat = (((pr)->ps_xexit) << 8 | ((pr)->ps_xsig
)); (ki)->p_acflag = (pr)->ps_acflag; (ki)->p_pledge
 = (pr)->ps_pledge; strlcpy((ki)->p_emul, "native", sizeof
((ki)->p_emul)); strlcpy((ki)->p_comm, (pr)->ps_comm
, sizeof((ki)->p_comm)); strlcpy((ki)->p_login, (s)->
s_login, (((sizeof((ki)->p_login))<(sizeof((s)->s_login
)))?(sizeof((ki)->p_login)):(sizeof((s)->s_login)))); if
 ((s)->s_ttyvp) (ki)->p_eflag |= 0x01; if ((pr)->ps_uvpaths
) (ki)->p_eflag |= 0x04; if ((pr)->ps_uvdone || (((pr)->
ps_flags & 0x00100000) && ((pr)->ps_pledge &
 0x0000001000000000ULL) == 0)) (ki)->p_eflag |= 0x08; if (
((pr)->ps_flags & (0x00020000 | 0x00040000)) == 0) { if
 ((vm) != ((void *)0)) { (ki)->p_vm_rssize = (vm)->vm_rssize
; (ki)->p_vm_tsize = (vm)->vm_tsize; (ki)->p_vm_dsize
 = (vm)->vm_dused; (ki)->p_vm_ssize = (vm)->vm_ssize
; } (ki)->p_addr = ((u_int64_t)(u_long)((p)->p_addr)); (
ki)->p_stat = (p)->p_stat; (ki)->p_slptime = (p)->
p_slptime; (ki)->p_holdcnt = 1; (ki)->p_priority = ((p)
->p_stat == 2 ? (p)->p_runpri : ((p)->p_stat == 3) ?
 (p)->p_slppri : (p)->p_usrpri); (ki)->p_usrpri = (p
)->p_usrpri; if ((p)->p_wchan && (p)->p_wmesg
) strlcpy((ki)->p_wmesg, (p)->p_wmesg, sizeof((ki)->
p_wmesg)); if (show_pointers) (ki)->p_wchan = ((u_int64_t)
(u_long)((p)->p_wchan)); } mtx_enter(&(pr)->ps_mtx)
; if (pr->ps_limit) (ki)->p_rlim_rss_cur = (pr->ps_limit
)->pl_rlimit[5].rlim_cur; mtx_leave(&(pr)->ps_mtx);
 if (((pr)->ps_flags & 0x00040000) == 0) { struct timeval
 __tv; (ki)->p_uvalid = 1; (ki)->p_uru_maxrss = (p)->
p_ru.ru_maxrss; (ki)->p_uru_ixrss = (p)->p_ru.ru_ixrss;
 (ki)->p_uru_idrss = (p)->p_ru.ru_idrss; (ki)->p_uru_isrss
 = (p)->p_ru.ru_isrss; (ki)->p_uru_minflt = (p)->p_ru
.ru_minflt; (ki)->p_uru_majflt = (p)->p_ru.ru_majflt; (
ki)->p_uru_nswap = (p)->p_ru.ru_nswap; (ki)->p_uru_inblock
 = (p)->p_ru.ru_inblock; (ki)->p_uru_oublock = (p)->
p_ru.ru_oublock; (ki)->p_uru_msgsnd = (p)->p_ru.ru_msgsnd
; (ki)->p_uru_msgrcv = (p)->p_ru.ru_msgrcv; (ki)->p_uru_nsignals
 = (p)->p_ru.ru_nsignals; (ki)->p_uru_nvcsw = (p)->p_ru
.ru_nvcsw; (ki)->p_uru_nivcsw = (p)->p_ru.ru_nivcsw; do
 { (&__tv)->tv_sec = (&(pr)->ps_cru.ru_utime)->
tv_sec + (&(pr)->ps_cru.ru_stime)->tv_sec; (&__tv
)->tv_usec = (&(pr)->ps_cru.ru_utime)->tv_usec +
 (&(pr)->ps_cru.ru_stime)->tv_usec; if ((&__tv)
->tv_usec >= 1000000) { (&__tv)->tv_sec++; (&
__tv)->tv_usec -= 1000000; } } while (0); (ki)->p_uctime_sec
 = __tv.tv_sec; (ki)->p_uctime_usec = __tv.tv_usec; } (ki)
->p_cpuid = (~(u_int64_t)0); (ki)->p_rtableid = (pr)->
ps_rtableid; } while (0)
   p, pr, s, vm, pr->ps_limit, pr->ps_sigacts, isthread,do { __builtin_memset(((ki)), (0), (sizeof(*(ki)))); if (show_pointers
) { (ki)->p_paddr = ((u_int64_t)(u_long)(p)); (ki)->p_fd
 = ((u_int64_t)(u_long)((pr)->ps_fd)); (ki)->p_limit = (
(u_int64_t)(u_long)((pr)->ps_limit)); (ki)->p_vmspace =
 ((u_int64_t)(u_long)((pr)->ps_vmspace)); (ki)->p_sigacts
 = ((u_int64_t)(u_long)((pr)->ps_sigacts)); (ki)->p_sess
 = ((u_int64_t)(u_long)((pr->ps_pgrp)->pg_session)); (ki
)->p_ru = ((u_int64_t)(u_long)((pr)->ps_ru)); } (ki)->
p_stats = 0; (ki)->p_exitsig = 0; (ki)->p_flag = (p)->
p_flag; (ki)->p_pid = (pr)->ps_pid; (ki)->p_psflags =
 (pr)->ps_flags; (ki)->p__pgid = (pr->ps_pgrp)->pg_id
; (ki)->p_uid = (pr->ps_ucred)->cr_uid; (ki)->p_ruid
 = (pr->ps_ucred)->cr_ruid; (ki)->p_gid = (pr->ps_ucred
)->cr_gid; (ki)->p_rgid = (pr->ps_ucred)->cr_rgid
; (ki)->p_svuid = (pr->ps_ucred)->cr_svuid; (ki)->
p_svgid = (pr->ps_ucred)->cr_svgid; __builtin_memcpy(((
ki)->p_groups), ((pr->ps_ucred)->cr_groups), ((((sizeof
((ki)->p_groups))<(sizeof((pr->ps_ucred)->cr_groups
)))?(sizeof((ki)->p_groups)):(sizeof((pr->ps_ucred)->
cr_groups))))); (ki)->p_ngroups = (pr->ps_ucred)->cr_ngroups
; (ki)->p_jobc = (pr->ps_pgrp)->pg_jobc; (ki)->p_estcpu
 = (p)->p_estcpu; if (isthread) { (ki)->p_rtime_sec = (
p)->p_tu.tu_runtime.tv_sec; (ki)->p_rtime_usec = (p)->
p_tu.tu_runtime.tv_nsec/1000; (ki)->p_tid = (p)->p_tid +
 100000; (ki)->p_uticks = (p)->p_tu.tu_uticks; (ki)->
p_sticks = (p)->p_tu.tu_sticks; (ki)->p_iticks = (p)->
p_tu.tu_iticks; } else { (ki)->p_rtime_sec = (pr)->ps_tu
.tu_runtime.tv_sec; (ki)->p_rtime_usec = (pr)->ps_tu.tu_runtime
.tv_nsec/1000; (ki)->p_tid = -1; (ki)->p_uticks = (pr)->
ps_tu.tu_uticks; (ki)->p_sticks = (pr)->ps_tu.tu_sticks
; (ki)->p_iticks = (pr)->ps_tu.tu_iticks; } (ki)->p_cpticks
 = (p)->p_cpticks; if (show_pointers) (ki)->p_tracep = (
(u_int64_t)(u_long)((pr)->ps_tracevp)); (ki)->p_traceflag
 = (pr)->ps_traceflag; (ki)->p_siglist = (p)->p_siglist
 | (pr)->ps_siglist; (ki)->p_sigmask = (p)->p_sigmask
; (ki)->p_sigignore = (pr->ps_sigacts) ? (pr->ps_sigacts
)->ps_sigignore : 0; (ki)->p_sigcatch = (pr->ps_sigacts
) ? (pr->ps_sigacts)->ps_sigcatch : 0; (ki)->p_stat =
 (p)->p_stat; (ki)->p_nice = (pr)->ps_nice; (ki)->
p_xstat = (((pr)->ps_xexit) << 8 | ((pr)->ps_xsig
)); (ki)->p_acflag = (pr)->ps_acflag; (ki)->p_pledge
 = (pr)->ps_pledge; strlcpy((ki)->p_emul, "native", sizeof
((ki)->p_emul)); strlcpy((ki)->p_comm, (pr)->ps_comm
, sizeof((ki)->p_comm)); strlcpy((ki)->p_login, (s)->
s_login, (((sizeof((ki)->p_login))<(sizeof((s)->s_login
)))?(sizeof((ki)->p_login)):(sizeof((s)->s_login)))); if
 ((s)->s_ttyvp) (ki)->p_eflag |= 0x01; if ((pr)->ps_uvpaths
) (ki)->p_eflag |= 0x04; if ((pr)->ps_uvdone || (((pr)->
ps_flags & 0x00100000) && ((pr)->ps_pledge &
 0x0000001000000000ULL) == 0)) (ki)->p_eflag |= 0x08; if (
((pr)->ps_flags & (0x00020000 | 0x00040000)) == 0) { if
 ((vm) != ((void *)0)) { (ki)->p_vm_rssize = (vm)->vm_rssize
; (ki)->p_vm_tsize = (vm)->vm_tsize; (ki)->p_vm_dsize
 = (vm)->vm_dused; (ki)->p_vm_ssize = (vm)->vm_ssize
; } (ki)->p_addr = ((u_int64_t)(u_long)((p)->p_addr)); (
ki)->p_stat = (p)->p_stat; (ki)->p_slptime = (p)->
p_slptime; (ki)->p_holdcnt = 1; (ki)->p_priority = ((p)
->p_stat == 2 ? (p)->p_runpri : ((p)->p_stat == 3) ?
 (p)->p_slppri : (p)->p_usrpri); (ki)->p_usrpri = (p
)->p_usrpri; if ((p)->p_wchan && (p)->p_wmesg
) strlcpy((ki)->p_wmesg, (p)->p_wmesg, sizeof((ki)->
p_wmesg)); if (show_pointers) (ki)->p_wchan = ((u_int64_t)
(u_long)((p)->p_wchan)); } mtx_enter(&(pr)->ps_mtx)
; if (pr->ps_limit) (ki)->p_rlim_rss_cur = (pr->ps_limit
)->pl_rlimit[5].rlim_cur; mtx_leave(&(pr)->ps_mtx);
 if (((pr)->ps_flags & 0x00040000) == 0) { struct timeval
 __tv; (ki)->p_uvalid = 1; (ki)->p_uru_maxrss = (p)->
p_ru.ru_maxrss; (ki)->p_uru_ixrss = (p)->p_ru.ru_ixrss;
 (ki)->p_uru_idrss = (p)->p_ru.ru_idrss; (ki)->p_uru_isrss
 = (p)->p_ru.ru_isrss; (ki)->p_uru_minflt = (p)->p_ru
.ru_minflt; (ki)->p_uru_majflt = (p)->p_ru.ru_majflt; (
ki)->p_uru_nswap = (p)->p_ru.ru_nswap; (ki)->p_uru_inblock
 = (p)->p_ru.ru_inblock; (ki)->p_uru_oublock = (p)->
p_ru.ru_oublock; (ki)->p_uru_msgsnd = (p)->p_ru.ru_msgsnd
; (ki)->p_uru_msgrcv = (p)->p_ru.ru_msgrcv; (ki)->p_uru_nsignals
 = (p)->p_ru.ru_nsignals; (ki)->p_uru_nvcsw = (p)->p_ru
.ru_nvcsw; (ki)->p_uru_nivcsw = (p)->p_ru.ru_nivcsw; do
 { (&__tv)->tv_sec = (&(pr)->ps_cru.ru_utime)->
tv_sec + (&(pr)->ps_cru.ru_stime)->tv_sec; (&__tv
)->tv_usec = (&(pr)->ps_cru.ru_utime)->tv_usec +
 (&(pr)->ps_cru.ru_stime)->tv_usec; if ((&__tv)
->tv_usec >= 1000000) { (&__tv)->tv_sec++; (&
__tv)->tv_usec -= 1000000; } } while (0); (ki)->p_uctime_sec
 = __tv.tv_sec; (ki)->p_uctime_usec = __tv.tv_usec; } (ki)
->p_cpuid = (~(u_int64_t)0); (ki)->p_rtableid = (pr)->
ps_rtableid; } while (0)
   show_pointers)do { __builtin_memset(((ki)), (0), (sizeof(*(ki)))); if (show_pointers
) { (ki)->p_paddr = ((u_int64_t)(u_long)(p)); (ki)->p_fd
 = ((u_int64_t)(u_long)((pr)->ps_fd)); (ki)->p_limit = (
(u_int64_t)(u_long)((pr)->ps_limit)); (ki)->p_vmspace =
 ((u_int64_t)(u_long)((pr)->ps_vmspace)); (ki)->p_sigacts
 = ((u_int64_t)(u_long)((pr)->ps_sigacts)); (ki)->p_sess
 = ((u_int64_t)(u_long)((pr->ps_pgrp)->pg_session)); (ki
)->p_ru = ((u_int64_t)(u_long)((pr)->ps_ru)); } (ki)->
p_stats = 0; (ki)->p_exitsig = 0; (ki)->p_flag = (p)->
p_flag; (ki)->p_pid = (pr)->ps_pid; (ki)->p_psflags =
 (pr)->ps_flags; (ki)->p__pgid = (pr->ps_pgrp)->pg_id
; (ki)->p_uid = (pr->ps_ucred)->cr_uid; (ki)->p_ruid
 = (pr->ps_ucred)->cr_ruid; (ki)->p_gid = (pr->ps_ucred
)->cr_gid; (ki)->p_rgid = (pr->ps_ucred)->cr_rgid
; (ki)->p_svuid = (pr->ps_ucred)->cr_svuid; (ki)->
p_svgid = (pr->ps_ucred)->cr_svgid; __builtin_memcpy(((
ki)->p_groups), ((pr->ps_ucred)->cr_groups), ((((sizeof
((ki)->p_groups))<(sizeof((pr->ps_ucred)->cr_groups
)))?(sizeof((ki)->p_groups)):(sizeof((pr->ps_ucred)->
cr_groups))))); (ki)->p_ngroups = (pr->ps_ucred)->cr_ngroups
; (ki)->p_jobc = (pr->ps_pgrp)->pg_jobc; (ki)->p_estcpu
 = (p)->p_estcpu; if (isthread) { (ki)->p_rtime_sec = (
p)->p_tu.tu_runtime.tv_sec; (ki)->p_rtime_usec = (p)->
p_tu.tu_runtime.tv_nsec/1000; (ki)->p_tid = (p)->p_tid +
 100000; (ki)->p_uticks = (p)->p_tu.tu_uticks; (ki)->
p_sticks = (p)->p_tu.tu_sticks; (ki)->p_iticks = (p)->
p_tu.tu_iticks; } else { (ki)->p_rtime_sec = (pr)->ps_tu
.tu_runtime.tv_sec; (ki)->p_rtime_usec = (pr)->ps_tu.tu_runtime
.tv_nsec/1000; (ki)->p_tid = -1; (ki)->p_uticks = (pr)->
ps_tu.tu_uticks; (ki)->p_sticks = (pr)->ps_tu.tu_sticks
; (ki)->p_iticks = (pr)->ps_tu.tu_iticks; } (ki)->p_cpticks
 = (p)->p_cpticks; if (show_pointers) (ki)->p_tracep = (
(u_int64_t)(u_long)((pr)->ps_tracevp)); (ki)->p_traceflag
 = (pr)->ps_traceflag; (ki)->p_siglist = (p)->p_siglist
 | (pr)->ps_siglist; (ki)->p_sigmask = (p)->p_sigmask
; (ki)->p_sigignore = (pr->ps_sigacts) ? (pr->ps_sigacts
)->ps_sigignore : 0; (ki)->p_sigcatch = (pr->ps_sigacts
) ? (pr->ps_sigacts)->ps_sigcatch : 0; (ki)->p_stat =
 (p)->p_stat; (ki)->p_nice = (pr)->ps_nice; (ki)->
p_xstat = (((pr)->ps_xexit) << 8 | ((pr)->ps_xsig
)); (ki)->p_acflag = (pr)->ps_acflag; (ki)->p_pledge
 = (pr)->ps_pledge; strlcpy((ki)->p_emul, "native", sizeof
((ki)->p_emul)); strlcpy((ki)->p_comm, (pr)->ps_comm
, sizeof((ki)->p_comm)); strlcpy((ki)->p_login, (s)->
s_login, (((sizeof((ki)->p_login))<(sizeof((s)->s_login
)))?(sizeof((ki)->p_login)):(sizeof((s)->s_login)))); if
 ((s)->s_ttyvp) (ki)->p_eflag |= 0x01; if ((pr)->ps_uvpaths
) (ki)->p_eflag |= 0x04; if ((pr)->ps_uvdone || (((pr)->
ps_flags & 0x00100000) && ((pr)->ps_pledge &
 0x0000001000000000ULL) == 0)) (ki)->p_eflag |= 0x08; if (
((pr)->ps_flags & (0x00020000 | 0x00040000)) == 0) { if
 ((vm) != ((void *)0)) { (ki)->p_vm_rssize = (vm)->vm_rssize
; (ki)->p_vm_tsize = (vm)->vm_tsize; (ki)->p_vm_dsize
 = (vm)->vm_dused; (ki)->p_vm_ssize = (vm)->vm_ssize
; } (ki)->p_addr = ((u_int64_t)(u_long)((p)->p_addr)); (
ki)->p_stat = (p)->p_stat; (ki)->p_slptime = (p)->
p_slptime; (ki)->p_holdcnt = 1; (ki)->p_priority = ((p)
->p_stat == 2 ? (p)->p_runpri : ((p)->p_stat == 3) ?
 (p)->p_slppri : (p)->p_usrpri); (ki)->p_usrpri = (p
)->p_usrpri; if ((p)->p_wchan && (p)->p_wmesg
) strlcpy((ki)->p_wmesg, (p)->p_wmesg, sizeof((ki)->
p_wmesg)); if (show_pointers) (ki)->p_wchan = ((u_int64_t)
(u_long)((p)->p_wchan)); } mtx_enter(&(pr)->ps_mtx)
; if (pr->ps_limit) (ki)->p_rlim_rss_cur = (pr->ps_limit
)->pl_rlimit[5].rlim_cur; mtx_leave(&(pr)->ps_mtx);
 if (((pr)->ps_flags & 0x00040000) == 0) { struct timeval
 __tv; (ki)->p_uvalid = 1; (ki)->p_uru_maxrss = (p)->
p_ru.ru_maxrss; (ki)->p_uru_ixrss = (p)->p_ru.ru_ixrss;
 (ki)->p_uru_idrss = (p)->p_ru.ru_idrss; (ki)->p_uru_isrss
 = (p)->p_ru.ru_isrss; (ki)->p_uru_minflt = (p)->p_ru
.ru_minflt; (ki)->p_uru_majflt = (p)->p_ru.ru_majflt; (
ki)->p_uru_nswap = (p)->p_ru.ru_nswap; (ki)->p_uru_inblock
 = (p)->p_ru.ru_inblock; (ki)->p_uru_oublock = (p)->
p_ru.ru_oublock; (ki)->p_uru_msgsnd = (p)->p_ru.ru_msgsnd
; (ki)->p_uru_msgrcv = (p)->p_ru.ru_msgrcv; (ki)->p_uru_nsignals
 = (p)->p_ru.ru_nsignals; (ki)->p_uru_nvcsw = (p)->p_ru
.ru_nvcsw; (ki)->p_uru_nivcsw = (p)->p_ru.ru_nivcsw; do
 { (&__tv)->tv_sec = (&(pr)->ps_cru.ru_utime)->
tv_sec + (&(pr)->ps_cru.ru_stime)->tv_sec; (&__tv
)->tv_usec = (&(pr)->ps_cru.ru_utime)->tv_usec +
 (&(pr)->ps_cru.ru_stime)->tv_usec; if ((&__tv)
->tv_usec >= 1000000) { (&__tv)->tv_sec++; (&
__tv)->tv_usec -= 1000000; } } while (0); (ki)->p_uctime_sec
 = __tv.tv_sec; (ki)->p_uctime_usec = __tv.tv_usec; } (ki)
->p_cpuid = (~(u_int64_t)0); (ki)->p_rtableid = (pr)->
ps_rtableid; } while (0);

/* stuff that's too painful to generalize into the macros */
if (pr->ps_pptr)
ki->p_ppid = pr->ps_ppid;
if (s->s_leader)
ki->p_sid = s->s_leader->ps_pid;

if ((pr->ps_flags & PS_CONTROLT0x00000001) && (tp = s->s_ttyp)) {
ki->p_tdev = tp->t_dev;
ki->p_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : -1;
if (show_pointers)
	ki->p_tsess = PTRTOINT64(tp->t_session)((u_int64_t)(u_long)(tp->t_session));
} else {
ki->p_tdev = NODEV(dev_t)(-1);
ki->p_tpgid = -1;
}

/* fixups that can only be done in the kernel */
if ((pr->ps_flags & PS_ZOMBIE0x00040000) == 0) {
if ((pr->ps_flags & PS_EMBRYO0x00020000) == 0 && vm != NULL((void *)0))
	ki->p_vm_rssize = vm_resident_count(vm)((((vm)->vm_map.pmap)->pm_stats.resident_count));
calctsru(isthread ? &p->p_tu : &pr->ps_tu, &ut, &st, NULL((void *)0));
ki->p_uutime_sec = ut.tv_sec;
ki->p_uutime_usec = ut.tv_nsec/1000;
ki->p_ustime_sec = st.tv_sec;
ki->p_ustime_usec = st.tv_nsec/1000;

/* Convert starting uptime to a starting UTC time. */
nanoboottime(&booted);
timespecadd(&booted, &pr->ps_start, &utc)do { (&utc)->tv_sec = (&booted)->tv_sec + (&
pr->ps_start)->tv_sec; (&utc)->tv_nsec = (&booted
)->tv_nsec + (&pr->ps_start)->tv_nsec; if ((&
utc)->tv_nsec >= 1000000000L) { (&utc)->tv_sec++
; (&utc)->tv_nsec -= 1000000000L; } } while (0);
ki->p_ustart_sec = utc.tv_sec;
ki->p_ustart_usec = utc.tv_nsec / 1000;

1679#ifdef MULTIPROCESSOR1
if (p->p_cpu != NULL((void *)0))
	ki->p_cpuid = CPU_INFO_UNIT(p->p_cpu)((p->p_cpu)->ci_dev ? (p->p_cpu)->ci_dev->dv_unit
 : 0);
1682#endif
}

/* get %cpu and schedule state: just one thread or sum of all? */
if (isthread) {
ki->p_pctcpu = p->p_pctcpu;
ki->p_stat   = p->p_stat;
} else {
ki->p_pctcpu = 0;
ki->p_stat = (pr->ps_flags & PS_ZOMBIE0x00040000) ? SDEAD6 : SIDL1;
TAILQ_FOREACH(p, &pr->ps_threads, p_thr_link)for((p) = ((&pr->ps_threads)->tqh_first); (p) != ((
void *)0); (p) = ((p)->p_thr_link.tqe_next)) {
	ki->p_pctcpu += p->p_pctcpu;
	/* find best state: ONPROC > RUN > STOP > SLEEP > .. */
	if (p->p_stat == SONPROC7 || ki->p_stat == SONPROC7)
		ki->p_stat = SONPROC7;
	else if (p->p_stat == SRUN2 || ki->p_stat == SRUN2)
		ki->p_stat = SRUN2;
	else if (p->p_stat == SSTOP4 || ki->p_stat == SSTOP4)
		ki->p_stat = SSTOP4;
	else if (p->p_stat == SSLEEP3)
		ki->p_stat = SSLEEP3;
}
}
1705}

1707int
1708sysctl_proc_args(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  struct proc *cp)
1710{
struct process *vpr;
pid_t pid;
struct ps_strings pss;
struct iovec iov;
struct uio uio;
int error, cnt, op;
size_t limit;
char **rargv, **vargv;		/* reader vs. victim */
char *rarg, *varg, *buf;
struct vmspace *vm;
vaddr_t ps_strings;

if (namelen > 2)
return (ENOTDIR20);
if (namelen < 2)
return (EINVAL22);

pid = name[0];
op = name[1];

switch (op) {
case KERN_PROC_ARGV1:
case KERN_PROC_NARGV2:
case KERN_PROC_ENV3:
case KERN_PROC_NENV4:
break;
default:
return (EOPNOTSUPP45);
}

if ((vpr = prfind(pid)) == NULL((void *)0))
return (ESRCH3);

if (oldp == NULL((void *)0)) {
if (op == KERN_PROC_NARGV2 || op == KERN_PROC_NENV4)
	*oldlenp = sizeof(int);
else
	*oldlenp = ARG_MAX(512 * 1024);	/* XXX XXX XXX */
return (0);
}

/* Either system process or exiting/zombie */
if (vpr->ps_flags & (PS_SYSTEM0x00010000 | PS_EXITING0x00000008))
return (EINVAL22);

/* Execing - danger. */
if ((vpr->ps_flags & PS_INEXEC0x00000004))
return (EBUSY16);

/* Only owner or root can get env */
if ((op == KERN_PROC_NENV4 || op == KERN_PROC_ENV3) &&
   (vpr->ps_ucred->cr_uid != cp->p_ucred->cr_uid &&
   (error = suser(cp)) != 0))
return (error);

ps_strings = vpr->ps_strings;
vm = vpr->ps_vmspace;
uvmspace_addref(vm);
vpr = NULL((void *)0);

buf = malloc(PAGE_SIZE(1 << 12), M_TEMP127, M_WAITOK0x0001);

iov.iov_base = &pss;
iov.iov_len = sizeof(pss);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_offset = (off_t)ps_strings;
uio.uio_resid = sizeof(pss);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = UIO_READ;
uio.uio_procp = cp;

if ((error = uvm_io(&vm->vm_map, &uio, 0)) != 0)
goto out;

if (op == KERN_PROC_NARGV2) {
error = sysctl_rdint(oldp, oldlenp, NULL((void *)0), pss.ps_nargvstr);
goto out;
}
if (op == KERN_PROC_NENV4) {
error = sysctl_rdint(oldp, oldlenp, NULL((void *)0), pss.ps_nenvstr);
goto out;
}

if (op == KERN_PROC_ARGV1) {
cnt = pss.ps_nargvstr;
vargv = pss.ps_argvstr;
} else {
cnt = pss.ps_nenvstr;
vargv = pss.ps_envstr;
}

/* -1 to have space for a terminating NUL */
limit = *oldlenp - 1;
*oldlenp = 0;

rargv = oldp;

/*
* *oldlenp - number of bytes copied out into readers buffer.
* limit - maximal number of bytes allowed into readers buffer.
* rarg - pointer into readers buffer where next arg will be stored.
* rargv - pointer into readers buffer where the next rarg pointer
*  will be stored.
* vargv - pointer into victim address space where the next argument
*  will be read.
*/

/* space for cnt pointers and a NULL */
rarg = (char *)(rargv + cnt + 1);
*oldlenp += (cnt + 1) * sizeof(char **);

while (cnt > 0 && *oldlenp < limit) {
size_t len, vstrlen;

/* Write to readers argv */
if ((error = copyout(&rarg, rargv, sizeof(rarg))) != 0)
	goto out;

/* read the victim argv */
iov.iov_base = &varg;
iov.iov_len = sizeof(varg);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_offset = (off_t)(vaddr_t)vargv;
uio.uio_resid = sizeof(varg);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = UIO_READ;
uio.uio_procp = cp;
if ((error = uvm_io(&vm->vm_map, &uio, 0)) != 0)
	goto out;

if (varg == NULL((void *)0))
	break;

/*
 * read the victim arg. We must jump through hoops to avoid
 * crossing a page boundary too much and returning an error.
 */
1850more:
len = PAGE_SIZE(1 << 12) - (((vaddr_t)varg) & PAGE_MASK((1 << 12) - 1));
/* leave space for the terminating NUL */
iov.iov_base = buf;
iov.iov_len = len;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_offset = (off_t)(vaddr_t)varg;
uio.uio_resid = len;
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = UIO_READ;
uio.uio_procp = cp;
if ((error = uvm_io(&vm->vm_map, &uio, 0)) != 0)
	goto out;

for (vstrlen = 0; vstrlen < len; vstrlen++) {
	if (buf[vstrlen] == '\0')
		break;
}

/* Don't overflow readers buffer. */
if (*oldlenp + vstrlen + 1 >= limit) {
	error = ENOMEM12;
	goto out;
}

if ((error = copyout(buf, rarg, vstrlen)) != 0)
	goto out;

*oldlenp += vstrlen;
rarg += vstrlen;

/* The string didn't end in this page? */
if (vstrlen == len) {
	varg += vstrlen;
	goto more;
}

/* End of string. Terminate it with a NUL */
buf[0] = '\0';
if ((error = copyout(buf, rarg, 1)) != 0)
	goto out;
*oldlenp += 1;
rarg += 1;

vargv++;
rargv++;
cnt--;
}

if (*oldlenp >= limit) {
error = ENOMEM12;
goto out;
}

/* Write the terminating null */
rarg = NULL((void *)0);
error = copyout(&rarg, rargv, sizeof(rarg));

1909out:
uvmspace_free(vm);
free(buf, M_TEMP127, PAGE_SIZE(1 << 12));
return (error);
1913}

1915int
1916sysctl_proc_cwd(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  struct proc *cp)
1918{
struct process *findpr;
struct vnode *vp;
pid_t pid;
int error;
size_t lenused, len;
char *path, *bp, *bend;

if (namelen > 1)
return (ENOTDIR20);
if (namelen < 1)
return (EINVAL22);

pid = name[0];
if ((findpr = prfind(pid)) == NULL((void *)0))
return (ESRCH3);

if (oldp == NULL((void *)0)) {
*oldlenp = MAXPATHLEN1024 * 4;
return (0);
}

/* Either system process or exiting/zombie */
if (findpr->ps_flags & (PS_SYSTEM0x00010000 | PS_EXITING0x00000008))
return (EINVAL22);

/* Only owner or root can get cwd */
if (findpr->ps_ucred->cr_uid != cp->p_ucred->cr_uid &&
   (error = suser(cp)) != 0)
return (error);

len = *oldlenp;
if (len > MAXPATHLEN1024 * 4)
len = MAXPATHLEN1024 * 4;
else if (len < 2)
return (ERANGE34);
*oldlenp = 0;

/* snag a reference to the vnode before we can sleep */
vp = findpr->ps_fd->fd_cdir;
vref(vp);

path = malloc(len, M_TEMP127, M_WAITOK0x0001);

bp = &path[len];
bend = bp;
*(--bp) = '\0';

/* Same as sys__getcwd */
error = vfs_getcwd_common(vp, NULL((void *)0),
   &bp, path, len / 2, GETCWD_CHECK_ACCESS0x0001, cp);
if (error == 0) {
*oldlenp = lenused = bend - bp;
error = copyout(bp, oldp, lenused);
}

vrele(vp);
free(path, M_TEMP127, len);

return (error);
1978}

1980int
1981sysctl_proc_nobroadcastkill(int *name, u_int namelen, void *newp, size_t newlen,
  void *oldp, size_t *oldlenp, struct proc *cp)
1983{
struct process *findpr;
pid_t pid;
int error, flag;

if (namelen > 1)
return (ENOTDIR20);
if (namelen < 1)
return (EINVAL22);

pid = name[0];
if ((findpr = prfind(pid)) == NULL((void *)0))
return (ESRCH3);

/* Either system process or exiting/zombie */
if (findpr->ps_flags & (PS_SYSTEM0x00010000 | PS_EXITING0x00000008))
return (EINVAL22);

/* Only root can change PS_NOBROADCASTKILL */
if (newp != NULL((void *)0) && (error = suser(cp)) != 0)
return (error);

/* get the PS_NOBROADCASTKILL flag */
flag = findpr->ps_flags & PS_NOBROADCASTKILL0x00080000 ? 1 : 0;

error = sysctl_int(oldp, oldlenp, newp, newlen, &flag);
if (error == 0 && newp) {
if (flag)
	atomic_setbits_intx86_atomic_setbits_u32(&findpr->ps_flags,
	    PS_NOBROADCASTKILL0x00080000);
else
	atomic_clearbits_intx86_atomic_clearbits_u32(&findpr->ps_flags,
	    PS_NOBROADCASTKILL0x00080000);
}

return (error);
2019}

2021/* Arbitrary but reasonable limit for one iteration. */
2022#define	VMMAP_MAXLEN(64 * 1024)	MAXPHYS(64 * 1024)

2024int
2025sysctl_proc_vmmap(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  struct proc *cp)
2027{
struct process *findpr;
pid_t pid;
int error;
size_t oldlen, len;
struct kinfo_vmentry *kve, *ukve;
u_long *ustart, start;

if (namelen > 1)
return (ENOTDIR20);
if (namelen < 1)
return (EINVAL22);

/* Provide max buffer length as hint. */
if (oldp == NULL((void *)0)) {
if (oldlenp == NULL((void *)0))
	return (EINVAL22);
else {
	*oldlenp = VMMAP_MAXLEN(64 * 1024);
	return (0);
}
}

pid = name[0];
if (pid == cp->p_p->ps_pid) {
/* Self process mapping. */
findpr = cp->p_p;
} else if (pid > 0) {
if ((findpr = prfind(pid)) == NULL((void *)0))
	return (ESRCH3);

/* Either system process or exiting/zombie */
if (findpr->ps_flags & (PS_SYSTEM0x00010000 | PS_EXITING0x00000008))
	return (EINVAL22);

2062#if 1
/* XXX Allow only root for now */
if ((error = suser(cp)) != 0)
	return (error);
2066#else
/* Only owner or root can get vmmap */
if (findpr->ps_ucred->cr_uid != cp->p_ucred->cr_uid &&
    (error = suser(cp)) != 0)
	return (error);
2071#endif
} else {
/* Only root can get kernel_map */
if ((error = suser(cp)) != 0)
	return (error);
findpr = NULL((void *)0);
}

/* Check the given size. */
oldlen = *oldlenp;
if (oldlen == 0 || oldlen % sizeof(*kve) != 0)
return (EINVAL22);

/* Deny huge allocation. */
if (oldlen > VMMAP_MAXLEN(64 * 1024))
return (EINVAL22);

/*
* Iterate from the given address passed as the first element's
* kve_start via oldp.
*/
ukve = (struct kinfo_vmentry *)oldp;
ustart = &ukve->kve_start;
error = copyin(ustart, &start, sizeof(start));
if (error != 0)
return (error);

/* Allocate wired memory to not block. */
kve = malloc(oldlen, M_TEMP127, M_WAITOK0x0001);

/* Set the base address and read entries. */
kve[0].kve_start = start;
len = oldlen;
error = fill_vmmap(findpr, kve, &len);
if (error != 0 && error != ENOMEM12)
goto done;
if (len == 0)
goto done;

KASSERT(len <= oldlen)((len <= oldlen) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/kern_sysctl.c"
, 2110, "len <= oldlen"));
KASSERT((len % sizeof(struct kinfo_vmentry)) == 0)(((len % sizeof(struct kinfo_vmentry)) == 0) ? (void)0 : __assert
("diagnostic ", "/usr/src/sys/kern/kern_sysctl.c", 2111, "(len % sizeof(struct kinfo_vmentry)) == 0"
));

error = copyout(kve, oldp, len);

2115done:
*oldlenp = len;

free(kve, M_TEMP127, oldlen);

return (error);
2121}
2122#endif

2124/*
* Initialize disknames/diskstats for export by sysctl. If update is set,
* then we simply update the disk statistics information.
*/
2128int
2129sysctl_diskinit(int update, struct proc *p)
2130{
struct diskstats *sdk;
struct disk *dk;
const char *duid;
int error, changed = 0;

KERNEL_ASSERT_LOCKED()((_kernel_lock_held()) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/kern_sysctl.c"
, 2136, "_kernel_lock_held()"));

if ((error = rw_enter(&sysctl_disklock, RW_WRITE0x0001UL|RW_INTR0x0010UL)) != 0)
return error;

/* Run in a loop, disks may change while malloc sleeps. */
while (disk_change) {
int tlen;

disk_change = 0;

tlen = 0;
TAILQ_FOREACH(dk, &disklist, dk_link)for((dk) = ((&disklist)->tqh_first); (dk) != ((void *)
0); (dk) = ((dk)->dk_link.tqe_next)) {
	if (dk->dk_name)
		tlen += strlen(dk->dk_name);
	tlen += 18;	/* label uid + separators */
}
tlen++;

/*
 * The sysctl_disklock ensures that no other process can
 * allocate disknames and diskstats while our malloc sleeps.
 */
free(disknames, M_SYSCTL11, disknameslen);
free(diskstats, M_SYSCTL11, diskstatslen);
diskstats = NULL((void *)0);
disknames = NULL((void *)0);
diskstats = mallocarray(disk_count, sizeof(struct diskstats),
    M_SYSCTL11, M_WAITOK0x0001|M_ZERO0x0008);
diskstatslen = disk_count * sizeof(struct diskstats);
disknames = malloc(tlen, M_SYSCTL11, M_WAITOK0x0001|M_ZERO0x0008);
disknameslen = tlen;
disknames[0] = '\0';
changed = 1;
}

if (changed) {
int l;

l = 0;
sdk = diskstats;
TAILQ_FOREACH(dk, &disklist, dk_link)for((dk) = ((&disklist)->tqh_first); (dk) != ((void *)
0); (dk) = ((dk)->dk_link.tqe_next)) {
	duid = NULL((void *)0);
	if (dk->dk_label && !duid_iszero(dk->dk_label->d_uid))
		duid = duid_format(dk->dk_label->d_uid);
	snprintf(disknames + l, disknameslen - l, "%s:%s,",
	    dk->dk_name ? dk->dk_name : "",
	    duid ? duid : "");
	l += strlen(disknames + l);
	strlcpy(sdk->ds_name, dk->dk_name,
	    sizeof(sdk->ds_name));
	mtx_enter(&dk->dk_mtx);
	sdk->ds_busy = dk->dk_busy;
	sdk->ds_rxfer = dk->dk_rxfer;
	sdk->ds_wxfer = dk->dk_wxfer;
	sdk->ds_seek = dk->dk_seek;
	sdk->ds_rbytes = dk->dk_rbytes;
	sdk->ds_wbytes = dk->dk_wbytes;
	sdk->ds_attachtime = dk->dk_attachtime;
	sdk->ds_timestamp = dk->dk_timestamp;
	sdk->ds_time = dk->dk_time;
	mtx_leave(&dk->dk_mtx);
	sdk++;
}

/* Eliminate trailing comma */
if (l != 0)
	disknames[l - 1] = '\0';
} else if (update) {
/* Just update, number of drives hasn't changed */
sdk = diskstats;
TAILQ_FOREACH(dk, &disklist, dk_link)for((dk) = ((&disklist)->tqh_first); (dk) != ((void *)
0); (dk) = ((dk)->dk_link.tqe_next)) {
	strlcpy(sdk->ds_name, dk->dk_name,
	    sizeof(sdk->ds_name));
	mtx_enter(&dk->dk_mtx);
	sdk->ds_busy = dk->dk_busy;
	sdk->ds_rxfer = dk->dk_rxfer;
	sdk->ds_wxfer = dk->dk_wxfer;
	sdk->ds_seek = dk->dk_seek;
	sdk->ds_rbytes = dk->dk_rbytes;
	sdk->ds_wbytes = dk->dk_wbytes;
	sdk->ds_attachtime = dk->dk_attachtime;
	sdk->ds_timestamp = dk->dk_timestamp;
	sdk->ds_time = dk->dk_time;
	mtx_leave(&dk->dk_mtx);
	sdk++;
}
}
rw_exit_write(&sysctl_disklock);
return 0;
2226}

2228#if defined(SYSVMSG1) || defined(SYSVSEM1) || defined(SYSVSHM1)
2229int
2230sysctl_sysvipc(int *name, u_int namelen, void *where, size_t *sizep)
2231{
2232#ifdef SYSVSEM1
struct sem_sysctl_info *semsi;
2234#endif
2235#ifdef SYSVSHM1
struct shm_sysctl_info *shmsi;
2237#endif
size_t infosize, dssize, tsize, buflen, bufsiz;
int i, nds, error, ret;
void *buf;

if (namelen != 1)
return (EINVAL22);

buflen = *sizep;

switch (*name) {
case KERN_SYSVIPC_MSG_INFO1:
2249#ifdef SYSVMSG1
return (sysctl_sysvmsg(name, namelen, where, sizep));
2251#else
return (EOPNOTSUPP45);
2253#endif
case KERN_SYSVIPC_SEM_INFO2:
2255#ifdef SYSVSEM1
infosize = sizeof(semsi->seminfo);
nds = seminfo.semmni;
dssize = sizeof(semsi->semids[0]);
break;
2260#else
return (EOPNOTSUPP45);
2262#endif
case KERN_SYSVIPC_SHM_INFO3:
2264#ifdef SYSVSHM1
infosize = sizeof(shmsi->shminfo);
nds = shminfo.shmmni;
dssize = sizeof(shmsi->shmids[0]);
break;
2269#else
return (EOPNOTSUPP45);
2271#endif
default:
return (EINVAL22);
}
tsize = infosize + (nds * dssize);

/* Return just the total size required. */
if (where == NULL((void *)0)) {
*sizep = tsize;
return (0);
}

/* Not enough room for even the info struct. */
if (buflen < infosize) {
*sizep = 0;
return (ENOMEM12);
}
bufsiz = min(tsize, buflen);
buf = malloc(bufsiz, M_TEMP127, M_WAITOK0x0001|M_ZERO0x0008);

switch (*name) {
2292#ifdef SYSVSEM1
case KERN_SYSVIPC_SEM_INFO2:
semsi = (struct sem_sysctl_info *)buf;
semsi->seminfo = seminfo;
break;
2297#endif
2298#ifdef SYSVSHM1
case KERN_SYSVIPC_SHM_INFO3:
shmsi = (struct shm_sysctl_info *)buf;
shmsi->shminfo = shminfo;
break;
2303#endif
}
buflen -= infosize;

ret = 0;
if (buflen > 0) {
/* Fill in the IPC data structures.  */
for (i = 0; i < nds; i++) {
	if (buflen < dssize) {
		ret = ENOMEM12;
		break;
	}
	switch (*name) {
2316#ifdef SYSVSEM1
	case KERN_SYSVIPC_SEM_INFO2:
		if (sema[i] != NULL((void *)0))
			memcpy(&semsi->semids[i], sema[i],__builtin_memcpy((&semsi->semids[i]), (sema[i]), (dssize
))
			    dssize)__builtin_memcpy((&semsi->semids[i]), (sema[i]), (dssize
));
		else
			memset(&semsi->semids[i], 0, dssize)__builtin_memset((&semsi->semids[i]), (0), (dssize));
		break;
2324#endif
2325#ifdef SYSVSHM1
	case KERN_SYSVIPC_SHM_INFO3:
		if (shmsegs[i] != NULL((void *)0))
			memcpy(&shmsi->shmids[i], shmsegs[i],__builtin_memcpy((&shmsi->shmids[i]), (shmsegs[i]), (dssize
))
			    dssize)__builtin_memcpy((&shmsi->shmids[i]), (shmsegs[i]), (dssize
));
		else
			memset(&shmsi->shmids[i], 0, dssize)__builtin_memset((&shmsi->shmids[i]), (0), (dssize));
		break;
2333#endif
	}
	buflen -= dssize;
}
}
*sizep -= buflen;
error = copyout(buf, where, *sizep);
free(buf, M_TEMP127, bufsiz);
/* If copyout succeeded, use return code set earlier. */
return (error ? error : ret);
2343}
2344#endif /* SYSVMSG || SYSVSEM || SYSVSHM */

2346#ifndef	SMALL_KERNEL

2348int
2349sysctl_intrcnt(int *name, u_int namelen, void *oldp, size_t *oldlenp)
2350{
return (evcount_sysctl(name, namelen, oldp, oldlenp, NULL((void *)0), 0));
2352}


2355int
2356sysctl_sensors(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
2358{
struct ksensor *ks;
struct sensor *us;
struct ksensordev *ksd;
struct sensordev *usd;
int dev, numt, ret;
enum sensor_type type;

if (namelen != 1 && namelen != 3)
return (ENOTDIR20);

dev = name[0];
if (namelen == 1) {
ret = sensordev_get(dev, &ksd);
if (ret)
	return (ret);

/* Grab a copy, to clear the kernel pointers */
usd = malloc(sizeof(*usd), M_TEMP127, M_WAITOK0x0001|M_ZERO0x0008);
usd->num = ksd->num;
strlcpy(usd->xname, ksd->xname, sizeof(usd->xname));
memcpy(usd->maxnumt, ksd->maxnumt, sizeof(usd->maxnumt))__builtin_memcpy((usd->maxnumt), (ksd->maxnumt), (sizeof
(usd->maxnumt)));
usd->sensors_count = ksd->sensors_count;

ret = sysctl_rdstruct(oldp, oldlenp, newp, usd,
    sizeof(struct sensordev));

free(usd, M_TEMP127, sizeof(*usd));
return (ret);
}

type = name[1];
numt = name[2];

ret = sensor_find(dev, type, numt, &ks);
if (ret)
return (ret);

/* Grab a copy, to clear the kernel pointers */
us = malloc(sizeof(*us), M_TEMP127, M_WAITOK0x0001|M_ZERO0x0008);
memcpy(us->desc, ks->desc, sizeof(us->desc))__builtin_memcpy((us->desc), (ks->desc), (sizeof(us->
desc)));
us->tv = ks->tv;
us->value = ks->value;
us->type = ks->type;
us->status = ks->status;
us->numt = ks->numt;
us->flags = ks->flags;

ret = sysctl_rdstruct(oldp, oldlenp, newp, us,
   sizeof(struct sensor));
free(us, M_TEMP127, sizeof(*us));
return (ret);
2410}
2411#endif	/* SMALL_KERNEL */

2413int
2414sysctl_cptime2(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
2416{
CPU_INFO_ITERATORint cii;
struct cpu_info *ci;
int found = 0;

if (namelen != 1)
return (ENOTDIR20);

CPU_INFO_FOREACH(cii, ci)for (cii = 0, ci = cpu_info_list; ci != ((void *)0); ci = ci->
ci_next) {
if (name[0] == CPU_INFO_UNIT(ci)((ci)->ci_dev ? (ci)->ci_dev->dv_unit : 0)) {
	found = 1;
	break;
}
}
if (!found)
return (ENOENT2);

return (sysctl_rdstruct(oldp, oldlenp, newp,
   &ci->ci_schedstate.spc_cp_time,
   sizeof(ci->ci_schedstate.spc_cp_time)));
2436}

2438#if NAUDIO1 > 0
2439int
2440sysctl_audio(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
2442{
if (namelen != 1)
return (ENOTDIR20);

if (name[0] != KERN_AUDIO_RECORD1)
return (ENOENT2);

return (sysctl_int(oldp, oldlenp, newp, newlen, &audio_record_enable));
2450}
2451#endif

2453#if NVIDEO1 > 0
2454int
2455sysctl_video(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
2457{
if (namelen != 1)
return (ENOTDIR20);

if (name[0] != KERN_VIDEO_RECORD1)
return (ENOENT2);

return (sysctl_int(oldp, oldlenp, newp, newlen, &video_record_enable));
2465}
2466#endif

2468int
2469sysctl_cpustats(int *name, u_int namelen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
2471{
CPU_INFO_ITERATORint cii;
struct cpustats cs;
struct cpu_info *ci;
int found = 0;

if (namelen != 1)
return (ENOTDIR20);

CPU_INFO_FOREACH(cii, ci)for (cii = 0, ci = cpu_info_list; ci != ((void *)0); ci = ci->
ci_next) {
if (name[0] == CPU_INFO_UNIT(ci)((ci)->ci_dev ? (ci)->ci_dev->dv_unit : 0)) {
	found = 1;
	break;
}
}
if (!found)
return (ENOENT2);

memcpy(&cs.cs_time, &ci->ci_schedstate.spc_cp_time, sizeof(cs.cs_time))__builtin_memcpy((&cs.cs_time), (&ci->ci_schedstate
.spc_cp_time), (sizeof(cs.cs_time)));
cs.cs_flags = 0;
if (cpu_is_online(ci))
cs.cs_flags |= CPUSTATS_ONLINE0x0001;

return (sysctl_rdstruct(oldp, oldlenp, newp, &cs, sizeof(cs)));
2495}

2497int
2498sysctl_utc_offset(void *oldp, size_t *oldlenp, void *newp, size_t newlen)
2499{
struct timespec adjusted, now;
int adjustment_seconds, error, new_offset_minutes, old_offset_minutes;

old_offset_minutes = utc_offset / 60;	/* seconds -> minutes */
if (securelevel > 0)
return sysctl_rdint(oldp, oldlenp, newp, old_offset_minutes);

new_offset_minutes = old_offset_minutes;
error = sysctl_int(oldp, oldlenp, newp, newlen, &new_offset_minutes);
if (error)
return error;
if (new_offset_minutes < -24 * 60 || new_offset_minutes > 24 * 60)
return EINVAL22;
if (new_offset_minutes == old_offset_minutes)
return 0;

utc_offset = new_offset_minutes * 60;	/* minutes -> seconds */
adjustment_seconds = (new_offset_minutes - old_offset_minutes) * 60;

nanotime(&now);
adjusted = now;
adjusted.tv_sec -= adjustment_seconds;
tc_setrealtimeclock(&adjusted);
resettodr();

return 0;
2526}