 @@ -1,14 +1,14 @@
-/*	$NetBSD: init_main.c,v 1.541 2022/10/26 23:20:47 riastradh Exp $	*/
+/*	$NetBSD: init_main.c,v 1.541.2.1 2024/04/18 18:22:10 martin Exp $	*/
 /*-
  * Copyright (c) 2008, 2009, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * 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.
 @@ -87,27 +87,27 @@
  * 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.
+ *
  *	@(#)init_main.c	8.16 (Berkeley) 5/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: init_main.c,v 1.541 2022/10/26 23:20:47 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: init_main.c,v 1.541.2.1 2024/04/18 18:22:10 martin Exp $");
 #include "opt_cnmagic.h"
 #include "opt_ddb.h"
 #include "opt_inet.h"
 #include "opt_ipsec.h"
 #include "opt_modular.h"
 #include "opt_ntp.h"
 #include "opt_pipe.h"
 #include "opt_syscall_debug.h"
 #include "opt_sysv.h"
 #include "opt_fileassoc.h"
 #include "opt_ktrace.h"
 #include "opt_pax.h"
 @@ -399,26 +399,29 @@ main(void)
 	 * The following things must be done before autoconfiguration.
 	 */
 	rnd_init();		/* initialize entropy pool */
 	cprng_init();		/* initialize cryptographic PRNG */
 	/* Initialize process and pgrp structures. */
 	procinit();
 	lwpinit();
 	/* Must be called after lwpinit (lwpinit_specificdata) */
 	psref_init();
 	/* Initialize exec structures */
 	exec_init(1);		/* signal_init calls exechook_establish() */
 	/* Initialize signal-related data structures. */
 	signal_init();
 	/* Initialize resource management. */
 	resource_init();
 	/* Create process 0. */
 	proc0_init();
 	lwp0_init();
 	/* Disable preemption during boot. */
 	kpreempt_disable();
 @@ -568,29 +571,26 @@ main(void)
 	/* Initialize the rest of ipi(9) after CPUs have been detected. */
 	ipi_percpu_init();
 	futex_sys_init();
 	/* Now timer is working.  Enable preemption. */
 	kpreempt_enable();
 	/* Get the threads going and into any sleeps before continuing. */
 	yield();
 	vmem_rehash_start();	/* must be before exec_init */
 	/* Initialize exec structures */
 	exec_init(1);		/* seminit calls exithook_establish() */
 #if NVERIEXEC > 0
 	/*
 	 * Initialise the Veriexec subsystem.
 	 */
 	veriexec_init();
 #endif /* NVERIEXEC > 0 */
 	pax_init();
 #ifdef	IPSEC
 	/* Attach network crypto subsystem */
 	ipsec_attach();
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_hook.c,v 1.14 2022/10/26 23:21:06 riastradh Exp $	*/
+/*	$NetBSD: kern_hook.c,v 1.14.2.1 2024/04/18 18:22:10 martin Exp $	*/
 /*-
  * Copyright (c) 1997, 1998, 1999, 2002, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Luke Mewburn.
+ *
  * 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
 @@ -21,37 +21,38 @@
  * ``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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_hook.c,v 1.14 2022/10/26 23:21:06 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_hook.c,v 1.14.2.1 2024/04/18 18:22:10 martin Exp $");
 #include <sys/param.h>
 #include <sys/condvar.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/exec.h>
 #include <sys/hook.h>
 #include <sys/kmem.h>
 #include <sys/malloc.h>
 #include <sys/once.h>
 #include <sys/rwlock.h>
 #include <sys/systm.h>
 /*
  * A generic linear hook.
  */
 struct hook_desc {
 	LIST_ENTRY(hook_desc) hk_list;
 	void	(*hk_fn)(void *);
 	void	*hk_arg;
 };
 typedef LIST_HEAD(, hook_desc) hook_list_t;
 @@ -64,105 +65,136 @@ struct khook_list {
 	hook_list_t	 hl_list;
 	kmutex_t	 hl_lock;
 	kmutex_t	*hl_cvlock;
 	struct lwp	*hl_lwp;
 	kcondvar_t	 hl_cv;
 	enum hook_list_st
 			 hl_state;
 	khook_t		*hl_active_hk;
 	char		 hl_namebuf[HOOKNAMSIZ];
 };
 int	powerhook_debug = 0;
 static ONCE_DECL(hook_control);
 static krwlock_t exithook_lock;
 static krwlock_t forkhook_lock;
 static int
 hook_init(void)
+{
 	rw_init(&exithook_lock);
 	rw_init(&forkhook_lock);
 	return 0;
+}
 static void *
-hook_establish(hook_list_t *list, void (*fn)(void *), void *arg)
+hook_establish(hook_list_t *list, krwlock_t *lock,
     void (*fn)(void *), void *arg)
+{
 	struct hook_desc *hd;
-	hd = malloc(sizeof(*hd), M_DEVBUF, M_NOWAIT);
+	RUN_ONCE(&hook_control, hook_init);
 	if (hd == NULL)
 		return (NULL);
-	hd->hk_fn = fn;
+	hd = malloc(sizeof(*hd), M_DEVBUF, M_NOWAIT);
-	hd->hk_arg = arg;
+	if (hd != NULL) {
-	LIST_INSERT_HEAD(list, hd, hk_list);
+		if (lock)
 			rw_enter(lock, RW_WRITER);
 		hd->hk_fn = fn;
 		hd->hk_arg = arg;
 		LIST_INSERT_HEAD(list, hd, hk_list);
 		if (lock)
 			rw_exit(lock);
+	}
 	return (hd);
+}
 static void
-hook_disestablish(hook_list_t *list, void *vhook)
+hook_disestablish(hook_list_t *list, krwlock_t *lock, void *vhook)
+{
 	if (lock)
 		rw_enter(lock, RW_WRITER);
 #ifdef DIAGNOSTIC
 	struct hook_desc *hd;
 	LIST_FOREACH(hd, list, hk_list) {
                 if (hd == vhook)
 			break;
+	}
 	if (hd == NULL)
 		panic("hook_disestablish: hook %p not established", vhook);
 #endif
 	LIST_REMOVE((struct hook_desc *)vhook, hk_list);
 	free(vhook, M_DEVBUF);
 	if (lock)
 		rw_exit(lock);
+}
 static void
 hook_destroy(hook_list_t *list)
+{
 	struct hook_desc *hd;
 	while ((hd = LIST_FIRST(list)) != NULL) {
 		LIST_REMOVE(hd, hk_list);
 		free(hd, M_DEVBUF);
+	}
+}
 static void
-hook_proc_run(hook_list_t *list, struct proc *p)
+hook_proc_run(hook_list_t *list, krwlock_t *lock, struct proc *p)
+{
 	struct hook_desc *hd;
 	RUN_ONCE(&hook_control, hook_init);
 	if (lock)
 		rw_enter(lock, RW_READER);
 	LIST_FOREACH(hd, list, hk_list) {
 		__FPTRCAST(void (*)(struct proc *, void *), *hd->hk_fn)(p,
 		    hd->hk_arg);
+	}
 	if (lock)
 		rw_exit(lock);
+}
 /*
  * "Shutdown hook" types, functions, and variables.
+ *
  * Should be invoked immediately before the
  * system is halted or rebooted, i.e. after file systems unmounted,
  * after crash dump done, etc.
+ *
  * Each shutdown hook is removed from the list before it's run, so that
  * it won't be run again.
  */
 static hook_list_t shutdownhook_list = LIST_HEAD_INITIALIZER(shutdownhook_list);
 void *
 shutdownhook_establish(void (*fn)(void *), void *arg)
+{
-	return hook_establish(&shutdownhook_list, fn, arg);
+	return hook_establish(&shutdownhook_list, NULL, fn, arg);
+}
 void
 shutdownhook_disestablish(void *vhook)
+{
-	hook_disestablish(&shutdownhook_list, vhook);
+	hook_disestablish(&shutdownhook_list, NULL, vhook);
+}
 /*
  * Run shutdown hooks.  Should be invoked immediately before the
  * system is halted or rebooted, i.e. after file systems unmounted,
  * after crash dump done, etc.
+ *
  * Each shutdown hook is removed from the list before it's run, so that
  * it won't be run again.
  */
 void
 doshutdownhooks(void)
+{
 @@ -183,152 +215,152 @@ doshutdownhooks(void)
 #endif
+	}
+}
 /*
  * "Mountroot hook" types, functions, and variables.
  */
 static hook_list_t mountroothook_list=LIST_HEAD_INITIALIZER(mountroothook_list);
 void *
 mountroothook_establish(void (*fn)(device_t), device_t dev)
+{
-	return hook_establish(&mountroothook_list, __FPTRCAST(void (*), fn),
+	return hook_establish(&mountroothook_list, NULL,
-	    dev);
+	    __FPTRCAST(void (*), fn), dev);
+}
 void
 mountroothook_disestablish(void *vhook)
+{
-	hook_disestablish(&mountroothook_list, vhook);
+	hook_disestablish(&mountroothook_list, NULL, vhook);
+}
 void
 mountroothook_destroy(void)
+{
 	hook_destroy(&mountroothook_list);
+}
 void
 domountroothook(device_t therootdev)
+{
 	struct hook_desc *hd;
 	LIST_FOREACH(hd, &mountroothook_list, hk_list) {
 		if (hd->hk_arg == therootdev) {
 			(*hd->hk_fn)(hd->hk_arg);
 			return;
+		}
+	}
+}
 static hook_list_t exechook_list = LIST_HEAD_INITIALIZER(exechook_list);
 void *
 exechook_establish(void (*fn)(struct proc *, void *), void *arg)
+{
-	return hook_establish(&exechook_list, __FPTRCAST(void (*)(void *), fn),
+	return hook_establish(&exechook_list, &exec_lock,
-	    arg);
+		__FPTRCAST(void (*)(void *), fn), arg);
+}
 void
 exechook_disestablish(void *vhook)
+{
-	hook_disestablish(&exechook_list, vhook);
+	hook_disestablish(&exechook_list, &exec_lock, vhook);
+}
 /*
  * Run exec hooks.
  */
 void
 doexechooks(struct proc *p)
+{
-	hook_proc_run(&exechook_list, p);
+	KASSERT(rw_lock_held(&exec_lock));
 	hook_proc_run(&exechook_list, NULL, p);
+}
 static hook_list_t exithook_list = LIST_HEAD_INITIALIZER(exithook_list);
 void *
 exithook_establish(void (*fn)(struct proc *, void *), void *arg)
+{
 	void *rv;
-	rw_enter(&exec_lock, RW_WRITER);
+	return hook_establish(&exithook_list, &exithook_lock,
-	rv = hook_establish(&exithook_list, __FPTRCAST(void (*)(void *), fn),
+	    __FPTRCAST(void (*)(void *), fn), arg);
 	    arg);
 	rw_exit(&exec_lock);
 	return rv;
+}
 void
 exithook_disestablish(void *vhook)
+{
-	rw_enter(&exec_lock, RW_WRITER);
+	hook_disestablish(&exithook_list, &exithook_lock, vhook);
 	hook_disestablish(&exithook_list, vhook);
 	rw_exit(&exec_lock);
+}
 /*
  * Run exit hooks.
  */
 void
 doexithooks(struct proc *p)
+{
-	hook_proc_run(&exithook_list, p);
+	hook_proc_run(&exithook_list, &exithook_lock, p);
+}
 static hook_list_t forkhook_list = LIST_HEAD_INITIALIZER(forkhook_list);
 void *
 forkhook_establish(void (*fn)(struct proc *, struct proc *))
+{
-	return hook_establish(&forkhook_list, __FPTRCAST(void (*)(void *), fn),
+	return hook_establish(&forkhook_list, &forkhook_lock,
-	    NULL);
+	    __FPTRCAST(void (*)(void *), fn), NULL);
+}
 void
 forkhook_disestablish(void *vhook)
+{
-	hook_disestablish(&forkhook_list, vhook);
+	hook_disestablish(&forkhook_list, &forkhook_lock, vhook);
+}
 /*
  * Run fork hooks.
  */
 void
 doforkhooks(struct proc *p2, struct proc *p1)
+{
 	struct hook_desc *hd;
 	RUN_ONCE(&hook_control, hook_init);
 	rw_enter(&forkhook_lock, RW_READER);
 	LIST_FOREACH(hd, &forkhook_list, hk_list) {
 		__FPTRCAST(void (*)(struct proc *, struct proc *), *hd->hk_fn)
 		    (p2, p1);
+	}
 	rw_exit(&forkhook_lock);
+}
 static hook_list_t critpollhook_list = LIST_HEAD_INITIALIZER(critpollhook_list);
 void *
 critpollhook_establish(void (*fn)(void *), void *arg)
+{
-	return hook_establish(&critpollhook_list, fn, arg);
+	return hook_establish(&critpollhook_list, NULL, fn, arg);
+}
 void
 critpollhook_disestablish(void *vhook)
+{
-	hook_disestablish(&critpollhook_list, vhook);
+	hook_disestablish(&critpollhook_list, NULL, vhook);
+}
 /*
  * Run critical polling hooks.
  */
 void
 docritpollhooks(void)
+{
 	struct hook_desc *hd;
 	LIST_FOREACH(hd, &critpollhook_list, hk_list) {
 		(*hd->hk_fn)(hd->hk_arg);
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_mount.c,v 1.101 2022/12/09 10:33:18 hannken Exp $	*/
+/*	$NetBSD: vfs_mount.c,v 1.101.2.1 2024/04/18 18:22:10 martin Exp $	*/
 /*-
  * Copyright (c) 1997-2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, and by Andrew Doran.
+ *
  * 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
 @@ -57,27 +57,27 @@
  * 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.
+ *
  *	@(#)vfs_subr.c	8.13 (Berkeley) 4/18/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_mount.c,v 1.101 2022/12/09 10:33:18 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_mount.c,v 1.101.2.1 2024/04/18 18:22:10 martin Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/fcntl.h>
 #include <sys/filedesc.h>
 #include <sys/device.h>
 #include <sys/kauth.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 @@ -927,27 +927,27 @@ err_mounted:
 	return error;
+}
 /*
  * Do the actual file system unmount.  File system is assumed to have
  * been locked by the caller.
+ *
  * => Caller hold reference to the mount, explicitly for dounmount().
  */
 int
 dounmount(struct mount *mp, int flags, struct lwp *l)
+{
-	vnode_t *coveredvp;
+	vnode_t *coveredvp, *vp;
 	int error, async, used_syncer, used_extattr;
 	const bool was_suspended = fstrans_is_owner(mp);
 #if NVERIEXEC > 0
 	error = veriexec_unmountchk(mp);
 	if (error)
 		return (error);
 #endif /* NVERIEXEC > 0 */
 	if (!was_suspended) {
 		error = vfs_suspend(mp, 0);
 		if (error) {
 			return error;
 @@ -994,28 +994,30 @@ dounmount(struct mount *mp, int flags, s
 	/*
 	 * mark filesystem as gone to prevent further umounts
 	 * after mnt_umounting lock is gone, this also prevents
 	 * vfs_busy() from succeeding.
 	 */
 	mp->mnt_iflag |= IMNT_GONE;
 	if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) {
 		coveredvp->v_mountedhere = NULL;
+	}
 	if (!was_suspended)
 		vfs_resume(mp);
 	mountlist_remove(mp);
-	if (TAILQ_FIRST(&mp->mnt_vnodelist) != NULL)
+	if ((vp = VIMPL_TO_VNODE(TAILQ_FIRST(&mp->mnt_vnodelist))) != NULL) {
 		vprint("dangling", vp);
 		panic("unmount: dangling vnode");
+	}
 	vfs_hooks_unmount(mp);
 	vfs_set_lowermount(mp, NULL);
 	vfs_rele(mp);	/* reference from mount() */
 	if (coveredvp != NULLVP) {
 		vrele(coveredvp);
+	}
 	return (0);
+}
 /*
  * Unmount all file systems.
  * We traverse the list in reverse order under the assumption that doing so

 @@ -1,14 +1,14 @@
-/*	$NetBSD: procfs.h,v 1.82 2022/01/19 10:23:00 martin Exp $	*/
+/*	$NetBSD: procfs.h,v 1.82.4.1 2024/04/18 18:22:10 martin Exp $	*/
 /*
  * Copyright (c) 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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.
 @@ -119,27 +119,29 @@ typedef enum {
 #endif
 	PFSlast,	/* track number of types */
 } pfstype;
 /*
  * control data for the proc file system.
  */
 struct pfskey {
 	pfstype		pk_type;	/* type of procfs node */
 	pid_t		pk_pid;		/* associated process */
 	int		pk_fd;		/* associated fd if not -1 */
 };
 struct pfsnode {
 	LIST_ENTRY(pfsnode) pfs_hash;	/* per pid hash list */
 	struct vnode	*pfs_vnode;	/* vnode associated with this pfsnode */
 	struct mount	*pfs_mount;	/* mount associated with this pfsnode */
 	struct pfskey	pfs_key;
 #define pfs_type pfs_key.pk_type
 #define pfs_pid pfs_key.pk_pid
 #define pfs_fd pfs_key.pk_fd
 	mode_t		pfs_mode;	/* mode bits for stat() */
 	u_long		pfs_flags;	/* open flags */
 	uint64_t	pfs_fileno;	/* unique file id */
 };
 #define PROCFS_NOTELEN	64	/* max length of a note (/proc/$pid/note) */
 #define PROCFS_MAXNAMLEN	255
 #endif /* _KERNEL */
 @@ -180,27 +182,26 @@ procfs_fileno(pid_t _pid, pfstype _type,
 	default:
 		_ino = _pid + 1;
 		if (_fd != -1)
 			_ino = _ino << 32 | _fd;
 		return _ino * PFSlast + _type;
+	}
+}
 #define PROCFS_FILENO(pid, type, fd) procfs_fileno(pid, type, fd)
 #define PROCFS_TYPE(type)	((type) % PFSlast)
 struct procfsmount {
 	void *pmnt_exechook;
 	int pmnt_flags;
 };
 #define VFSTOPROC(mp)	((struct procfsmount *)(mp)->mnt_data)
 /*
  * Convert between pfsnode vnode
  */
 #define VTOPFS(vp)	((struct pfsnode *)(vp)->v_data)
 #define PFSTOV(pfs)	((pfs)->pfs_vnode)
 typedef struct vfs_namemap vfs_namemap_t;
 struct vfs_namemap {
 @@ -259,27 +260,27 @@ int procfs_dofd(struct lwp *, struct pro
 int procfs_douptime(struct lwp *, struct proc *, struct pfsnode *,
     struct uio *);
 int procfs_domounts(struct lwp *, struct proc *, struct pfsnode *,
     struct uio *);
 int procfs_doemul(struct lwp *, struct proc *, struct pfsnode *,
     struct uio *);
 int procfs_doversion(struct lwp *, struct proc *, struct pfsnode *,
     struct uio *);
 int procfs_doauxv(struct lwp *, struct proc *, struct pfsnode *,
     struct uio *);
 int procfs_dolimit(struct lwp *, struct proc *, struct pfsnode *,
     struct uio *);
-void procfs_revoke_vnodes(struct proc *, void *);
+void procfs_hashrem(struct pfsnode *);
 int procfs_getfp(struct pfsnode *, struct proc *, struct file **);
 /* functions to check whether or not files should be displayed */
 int procfs_validauxv(struct lwp *, struct mount *);
 int procfs_validfile(struct lwp *, struct mount *);
 int procfs_validfpregs(struct lwp *, struct mount *);
 int procfs_validregs(struct lwp *, struct mount *);
 int procfs_validmap(struct lwp *, struct mount *);
 int procfs_rw(void *);
 int procfs_getcpuinfstr(char *, size_t *);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: procfs_subr.c,v 1.116 2020/05/23 23:42:43 ad Exp $	*/
+/*	$NetBSD: procfs_subr.c,v 1.116.20.1 2024/04/18 18:22:10 martin Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -92,27 +92,27 @@
  * 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.
+ *
  *	@(#)procfs_subr.c	8.6 (Berkeley) 5/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: procfs_subr.c,v 1.116 2020/05/23 23:42:43 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: procfs_subr.c,v 1.116.20.1 2024/04/18 18:22:10 martin Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/fstrans.h>
 #include <sys/vnode.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/kauth.h>
 #include <sys/sysctl.h>
 @@ -348,77 +348,26 @@ vfs_getuserstr(struct uio *uio, char *bf
+}
 const vfs_namemap_t *
 vfs_findname(const vfs_namemap_t *nm, const char *bf, int buflen)
+{
 	for (; nm->nm_name; nm++)
 		if (memcmp(bf, nm->nm_name, buflen+1) == 0)
 			return (nm);
 	return (0);
+}
 static bool
 procfs_revoke_selector(void *arg, struct vnode *vp)
 	struct proc *p = arg;
 	struct pfsnode *pfs;
 	KASSERT(mutex_owned(vp->v_interlock));
 	pfs = VTOPFS(vp);
 	return (pfs != NULL && pfs->pfs_pid == p->p_pid);
 void
 procfs_revoke_vnodes(struct proc *p, void *arg)
 	int error;
 	bool suspended;
 	struct vnode *vp;
 	struct vnode_iterator *marker;
 	struct mount *mp = (struct mount *)arg;
 	if (!(p->p_flag & PK_SUGID))
 		return;
 	suspended = false;
 	vfs_vnode_iterator_init(mp, &marker);
 	while ((vp = vfs_vnode_iterator_next(marker,
 	    procfs_revoke_selector, p)) != NULL) {
 		if (vrecycle(vp))
 			continue;
 		/* Vnode is busy, we have to suspend the mount for vgone(). */
 		while (! suspended) {
 			error = vfs_suspend(mp, 0);
 			if (error == 0) {
 				suspended = true;
 			} else if (error != EINTR && error != ERESTART) {
 				KASSERT(error == EOPNOTSUPP);
 				break;
 		vgone(vp);
 	if (suspended)
 		vfs_resume(mp);
 	vfs_vnode_iterator_destroy(marker);
 bool
 procfs_use_linux_compat(struct mount *mp)
+{
 	const int flags = VFSTOPROC(mp)->pmnt_flags;
 	return (flags & PROCFSMNT_LINUXCOMPAT) ? true : false;
+}
 struct proc *
 procfs_proc_find(struct mount *mp, pid_t pid)
+{
 	KASSERT(mutex_owned(&proc_lock));

 @@ -1,14 +1,14 @@
-/*	$NetBSD: procfs_vfsops.c,v 1.111 2022/01/17 11:20:00 bouyer Exp $	*/
+/*	$NetBSD: procfs_vfsops.c,v 1.111.4.1 2024/04/18 18:22:10 martin Exp $	*/
 /*
  * Copyright (c) 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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.
 @@ -66,61 +66,88 @@
  * 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.
+ *
  *	@(#)procfs_vfsops.c	8.7 (Berkeley) 5/10/95
  */
 /*
  * procfs VFS interface
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: procfs_vfsops.c,v 1.111 2022/01/17 11:20:00 bouyer Exp $");
+__KERNEL_RCSID(0, "$NetBSD: procfs_vfsops.c,v 1.111.4.1 2024/04/18 18:22:10 martin Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_compat_netbsd.h"
 #endif
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/dirent.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/fstrans.h>
 #include <sys/kauth.h>
 #include <sys/kernel.h>
 #include <sys/module.h>
 #include <sys/mount.h>
 #include <sys/proc.h>
 #include <sys/signalvar.h>
 #include <sys/sysctl.h>
 #include <sys/syslog.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/vnode.h>
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/procfs/procfs.h>
 #include <uvm/uvm_extern.h>			/* for PAGE_SIZE */
 MODULE(MODULE_CLASS_VFS, procfs, "ptrace_common");
 VFS_PROTOS(procfs);
 #define PROCFS_HASHSIZE	256
 #define PROCFS_EXEC_HOOK ((void *)1)
 #define PROCFS_EXIT_HOOK ((void *)2)
 static kauth_listener_t procfs_listener;
 static void *procfs_exechook;
 static void *procfs_exithook;
 LIST_HEAD(hashhead, pfsnode);
 static u_long procfs_hashmask;
 static struct hashhead *procfs_hashtab;
 static kmutex_t procfs_hashlock;
 static struct hashhead *
 procfs_hashhead(pid_t pid)
+{
 	return &procfs_hashtab[pid & procfs_hashmask];
+}
 void
 procfs_hashrem(struct pfsnode *pfs)
+{
 	mutex_enter(&procfs_hashlock);
 	LIST_REMOVE(pfs, pfs_hash);
 	mutex_exit(&procfs_hashlock);
+}
 /*
  * VFS Operations.
+ *
  * mount system call
  */
 /* ARGSUSED */
 int
 procfs_mount(
     struct mount *mp,
     const char *path,
     void *data,
     size_t *data_len)
 @@ -156,53 +183,50 @@ procfs_mount(
 	if (*data_len >= sizeof *args && args->version != PROCFS_ARGSVERSION)
 		return EINVAL;
 	pmnt = kmem_zalloc(sizeof(struct procfsmount), KM_SLEEP);
 	mp->mnt_stat.f_namemax = PROCFS_MAXNAMLEN;
 	mp->mnt_flag |= MNT_LOCAL;
 	mp->mnt_data = pmnt;
 	vfs_getnewfsid(mp);
 	error = set_statvfs_info(path, UIO_USERSPACE, "procfs", UIO_SYSSPACE,
 	    mp->mnt_op->vfs_name, mp, l);
 	pmnt->pmnt_exechook = exechook_establish(procfs_revoke_vnodes, mp);
 	if (*data_len >= sizeof *args)
 		pmnt->pmnt_flags = args->flags;
 	else
 		pmnt->pmnt_flags = 0;
 	mp->mnt_iflag |= IMNT_MPSAFE | IMNT_SHRLOOKUP;
 	return error;
+}
 /*
  * unmount system call
  */
 int
 procfs_unmount(struct mount *mp, int mntflags)
+{
 	int error;
 	int flags = 0;
 	if (mntflags & MNT_FORCE)
 		flags |= FORCECLOSE;
 	if ((error = vflush(mp, 0, flags)) != 0)
 		return (error);
 	exechook_disestablish(VFSTOPROC(mp)->pmnt_exechook);
 	kmem_free(mp->mnt_data, sizeof(struct procfsmount));
 	mp->mnt_data = NULL;
 	return 0;
+}
 int
 procfs_root(struct mount *mp, int lktype, struct vnode **vpp)
+{
 	int error;
 	error = procfs_allocvp(mp, vpp, 0, PFSroot, -1);
 	if (error == 0) {
 @@ -269,26 +293,27 @@ procfs_loadvnode(struct mount *mp, struc
+{
 	int error;
 	struct pfskey pfskey;
 	struct pfsnode *pfs;
 	KASSERT(key_len == sizeof(pfskey));
 	memcpy(&pfskey, key, key_len);
 	pfs = kmem_alloc(sizeof(*pfs), KM_SLEEP);
 	pfs->pfs_pid = pfskey.pk_pid;
 	pfs->pfs_type = pfskey.pk_type;
 	pfs->pfs_fd = pfskey.pk_fd;
 	pfs->pfs_vnode = vp;
 	pfs->pfs_mount = mp;
 	pfs->pfs_flags = 0;
 	pfs->pfs_fileno =
 	    PROCFS_FILENO(pfs->pfs_pid, pfs->pfs_type, pfs->pfs_fd);
 	vp->v_tag = VT_PROCFS;
 	vp->v_op = procfs_vnodeop_p;
 	vp->v_data = pfs;
 	switch (pfs->pfs_type) {
 	case PFSroot:	/* /proc = dr-xr-xr-x */
 		vp->v_vflag |= VV_ROOT;
 		/*FALLTHROUGH*/
 	case PFSproc:	/* /proc/N = dr-xr-xr-x */
 		pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
 @@ -411,26 +436,30 @@ procfs_loadvnode(struct mount *mp, struc
 		vp->v_type = VREG;
 		break;
 #ifdef __HAVE_PROCFS_MACHDEP
 	PROCFS_MACHDEP_NODETYPE_CASES
 		procfs_machdep_allocvp(vp);
 		break;
 #endif
 	default:
 		panic("procfs_allocvp");
+	}
 	mutex_enter(&procfs_hashlock);
 	LIST_INSERT_HEAD(procfs_hashhead(pfs->pfs_pid), pfs, pfs_hash);
 	mutex_exit(&procfs_hashlock);
 	uvm_vnp_setsize(vp, 0);
 	*new_key = &pfs->pfs_key;
 	return 0;
 bad:
 	vp->v_tag =VT_NON;
 	vp->v_type = VNON;
 	vp->v_op = NULL;
 	vp->v_data = NULL;
 	kmem_free(pfs, sizeof(*pfs));
 	return error;
+}
 @@ -476,26 +505,68 @@ struct vfsops procfs_vfsops = {
 	.vfs_vptofh = (void *)eopnotsupp,
 	.vfs_init = procfs_init,
 	.vfs_reinit = procfs_reinit,
 	.vfs_done = procfs_done,
 	.vfs_snapshot = (void *)eopnotsupp,
 	.vfs_extattrctl = vfs_stdextattrctl,
 	.vfs_suspendctl = genfs_suspendctl,
 	.vfs_renamelock_enter = genfs_renamelock_enter,
 	.vfs_renamelock_exit = genfs_renamelock_exit,
 	.vfs_fsync = (void *)eopnotsupp,
 	.vfs_opv_descs = procfs_vnodeopv_descs
 };
 static void
 procfs_exechook_cb(struct proc *p, void *arg)
+{
 	struct hashhead *head;
 	struct pfsnode *pfs;
 	struct mount *mp;
 	struct pfskey key;
 	struct vnode *vp;
 	int error;
 	if (arg == PROCFS_EXEC_HOOK && !(p->p_flag & PK_SUGID))
 		return;
 	head = procfs_hashhead(p->p_pid);
 again:
 	mutex_enter(&procfs_hashlock);
 	LIST_FOREACH(pfs, head, pfs_hash) {
 		if (pfs->pfs_pid != p->p_pid)
 			continue;
 		mp = pfs->pfs_mount;
 		key = pfs->pfs_key;
 		vfs_ref(mp);
 		mutex_exit(&procfs_hashlock);
 		error = vcache_get(mp, &key, sizeof(key), &vp);
 		vfs_rele(mp);
 		if (error != 0)
 			goto again;
 		if (vrecycle(vp))
 			goto again;
 		do {
 			error = vfs_suspend(mp, 0);
 		} while (error == EINTR || error == ERESTART);
 		vgone(vp);
 		if (error == 0)
 			vfs_resume(mp);
 		goto again;
+	}
 	mutex_exit(&procfs_hashlock);
+}
 static int
 procfs_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
     void *arg0, void *arg1, void *arg2, void *arg3)
+{
 	struct proc *p;
 	struct pfsnode *pfs;
 	int result;
 	result = KAUTH_RESULT_DEFER;
 	p = arg0;
 	pfs = arg1;
 	if (action != KAUTH_PROCESS_PROCFS)
 @@ -538,27 +609,40 @@ static int
 procfs_modcmd(modcmd_t cmd, void *arg)
+{
 	int error;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		error = vfs_attach(&procfs_vfsops);
 		if (error != 0)
 			break;
 		procfs_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS,
 		    procfs_listener_cb, NULL);
 		procfs_exechook = exechook_establish(procfs_exechook_cb,
 		    PROCFS_EXEC_HOOK);
 		procfs_exithook = exithook_establish(procfs_exechook_cb,
 		    PROCFS_EXIT_HOOK);
 		mutex_init(&procfs_hashlock, MUTEX_DEFAULT, IPL_NONE);
 		procfs_hashtab = hashinit(PROCFS_HASHSIZE, HASH_LIST, true,
 		    &procfs_hashmask);
 		break;
 	case MODULE_CMD_FINI:
 		error = vfs_detach(&procfs_vfsops);
 		if (error != 0)
 			break;
 		kauth_unlisten_scope(procfs_listener);
 		exechook_disestablish(procfs_exechook);
 		exithook_disestablish(procfs_exithook);
 		mutex_destroy(&procfs_hashlock);
 		hashdone(procfs_hashtab, HASH_LIST, procfs_hashmask);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 	return (error);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: procfs_vnops.c,v 1.229 2022/06/17 14:30:37 shm Exp $	*/
+/*	$NetBSD: procfs_vnops.c,v 1.229.4.1 2024/04/18 18:22:10 martin Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -95,27 +95,27 @@
  * 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.
+ *
  *	@(#)procfs_vnops.c	8.18 (Berkeley) 5/21/95
  */
 /*
  * procfs vnode interface
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: procfs_vnops.c,v 1.229 2022/06/17 14:30:37 shm Exp $");
+__KERNEL_RCSID(0, "$NetBSD: procfs_vnops.c,v 1.229.4.1 2024/04/18 18:22:10 martin Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/namei.h>
 #include <sys/malloc.h>
 #include <sys/mount.h>
 @@ -427,26 +427,27 @@ procfs_reclaim(void *v)
 		struct vnode *a_vp;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct pfsnode *pfs = VTOPFS(vp);
 	VOP_UNLOCK(vp);
 	/*
 	 * To interlock with procfs_revoke_vnodes().
 	 */
 	mutex_enter(vp->v_interlock);
 	vp->v_data = NULL;
 	mutex_exit(vp->v_interlock);
 	procfs_hashrem(pfs);
 	kmem_free(pfs, sizeof(*pfs));
 	return 0;
+}
 /*
  * Return POSIX pathconf information applicable to special devices.
  */
 int
 procfs_pathconf(void *v)
+{
 	struct vop_pathconf_args /* {
 		struct vnode *a_vp;
 		int a_name;