 @@ -1,1029 +1,1029 @@
-/*	$NetBSD: netbsd32_netbsd.c,v 1.234 2023/07/30 05:10:47 rin Exp $	*/
+/*	$NetBSD: netbsd32_netbsd.c,v 1.235 2023/07/30 05:30:45 rin Exp $	*/
 /*
  * Copyright (c) 1998, 2001, 2008, 2018 Matthew R. Green
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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: netbsd32_netbsd.c,v 1.234 2023/07/30 05:10:47 rin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: netbsd32_netbsd.c,v 1.235 2023/07/30 05:30:45 rin Exp $");
 /*
  * below are all the standard NetBSD system calls, in the 32bit
  * environment, with the necessary conversions to 64bit before calling
  * the real syscall.  anything that needs special attention is handled
  * elsewhere - this file should only contain structure assignment and
  * calls to the original function.
  */
 /*
  * below are all the standard NetBSD system calls, in the 32bit
  * environment, with the necessary conversions to 64bit before calling
  * the real syscall.  anything that needs special attention is handled
  * elsewhere - this file should only contain structure assignment and
  * calls to the original function.
  */
 #if defined(_KERNEL_OPT)
 #include "opt_compat_43.h"
 #include "opt_compat_netbsd.h"
 #include "opt_ddb.h"
 #include "opt_ktrace.h"
 #include "opt_ntp.h"
 #include "opt_quota.h"
 #include "opt_syscall_debug.h"
 #include "opt_sysv.h"
 #endif
 #include <sys/param.h>
 #include <sys/acct.h>
 #include <sys/dirent.h>
 #include <sys/exec.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/kernel.h>
 #include <sys/ktrace.h>
 #include <sys/mbuf.h>
 #include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/ptrace.h>
 #include <sys/quotactl.h>
 #include <sys/resourcevar.h>
 #include <sys/signalvar.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/sockio.h>
 #include <sys/stat.h>
 #include <sys/swap.h>
 #include <sys/syscallargs.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/trace.h>
 #include <sys/vfs_syscalls.h>
 #include <uvm/uvm_extern.h>
 #include <uvm/uvm_swap.h>
 #include <net/if.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_conv.h>
 #include <compat/netbsd32/netbsd32_exec.h>
 #include <compat/netbsd32/netbsd32_syscall.h>
 #include <compat/netbsd32/netbsd32_syscallargs.h>
 #include <compat/sys/mman.h>
 #if defined(DDB)
 #include <ddb/ddbvar.h>
 #endif
 #ifdef __HAVE_SYSCALL_INTERN
 void netbsd32_syscall_intern(struct proc *);
 #else
 void syscall(void);
 #endif
 #ifdef MODULAR
 #include <compat/netbsd32/netbsd32_syscalls_autoload.c>
 #endif
 struct emul emul_netbsd32 = {
 	.e_name =		"netbsd32",
 	.e_path =		"/emul/netbsd32",
 #ifndef __HAVE_MINIMAL_EMUL
 	.e_flags =		0,
 	.e_errno =		NULL,
 	.e_nosys =		NETBSD32_SYS_netbsd32_syscall,
 	.e_nsysent =		NETBSD32_SYS_NSYSENT,
 #endif
 	.e_sysent =		netbsd32_sysent,
 	.e_nomodbits =		netbsd32_sysent_nomodbits,
 #ifdef SYSCALL_DEBUG
 	.e_syscallnames =	netbsd32_syscallnames,
 #else
 	.e_syscallnames =	NULL,
 #endif
 #ifdef MODULAR
 	.e_sc_autoload =	netbsd32_syscalls_autoload,
 #endif
 	.e_sendsig =		netbsd32_sendsig,
 	.e_trapsignal =		trapsignal,
 	.e_sigcode =		NULL,
 	.e_esigcode =		NULL,
 	.e_sigobject =		NULL,
 	.e_setregs =		netbsd32_setregs,
 	.e_proc_exec =		NULL,
 	.e_proc_fork =		NULL,
 	.e_proc_exit =		NULL,
 	.e_lwp_fork =		NULL,
 	.e_lwp_exit =		NULL,
 #ifdef __HAVE_SYSCALL_INTERN
 	.e_syscall_intern =	netbsd32_syscall_intern,
 #else
 	.e_syscall =		syscall,
 #endif
 	.e_sysctlovly =		&netbsd32_sysctl_root,
 	.e_vm_default_addr =	netbsd32_vm_default_addr,
 	.e_usertrap =		NULL,
 	.e_ucsize =		sizeof(ucontext32_t),
 	.e_startlwp =		startlwp32,
 #ifdef notyet
 	.e_ktrpsig =		netbsd32_ktrpsig,
 #else
 	.e_ktrpsig =		NULL,
 #endif
 };
 int
 netbsd32_exit(struct lwp *l, const struct netbsd32_exit_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) rval;
 	} */
 	struct sys_exit_args ua;
 	NETBSD32TO64_UAP(rval);
 	return sys_exit(l, &ua, retval);
+}
 int
 netbsd32_read(struct lwp *l, const struct netbsd32_read_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(netbsd32_voidp) buf;
 		syscallarg(netbsd32_size_t) nbyte;
 	} */
 	struct sys_read_args ua;
 	if (SCARG(uap, nbyte) > NETBSD32_SSIZE_MAX)
 		return EINVAL;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TOP_UAP(buf, void *);
 	NETBSD32TOX_UAP(nbyte, size_t);
 	return sys_read(l, &ua, retval);
+}
 int
 netbsd32_write(struct lwp *l, const struct netbsd32_write_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_voidp) buf;
 		syscallarg(netbsd32_size_t) nbyte;
 	} */
 	struct sys_write_args ua;
 	if (SCARG(uap, nbyte) > NETBSD32_SSIZE_MAX)
 		return EINVAL;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TOP_UAP(buf, void *);
 	NETBSD32TOX_UAP(nbyte, size_t);
 	return sys_write(l, &ua, retval);
+}
 int
 netbsd32_close(struct lwp *l, const struct netbsd32_close_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 	} */
 	struct sys_close_args ua;
 	NETBSD32TO64_UAP(fd);
 	return sys_close(l, &ua, retval);
+}
 int
 netbsd32_open(struct lwp *l, const struct netbsd32_open_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) flags;
 		syscallarg(mode_t) mode;
 	} */
 	struct sys_open_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(flags);
 	NETBSD32TO64_UAP(mode);
 	return sys_open(l, &ua, retval);
+}
 int
 netbsd32_link(struct lwp *l, const struct netbsd32_link_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) link;
 	} */
 	struct sys_link_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(link, const char);
 	return sys_link(l, &ua, retval);
+}
 int
 netbsd32_unlink(struct lwp *l, const struct netbsd32_unlink_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct sys_unlink_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	return sys_unlink(l, &ua, retval);
+}
 int
 netbsd32_chdir(struct lwp *l, const struct netbsd32_chdir_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct sys_chdir_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	return sys_chdir(l, &ua, retval);
+}
 int
 netbsd32_fchdir(struct lwp *l, const struct netbsd32_fchdir_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 	} */
 	struct sys_fchdir_args ua;
 	NETBSD32TO64_UAP(fd);
 	return sys_fchdir(l, &ua, retval);
+}
 int
 netbsd32___mknod50(struct lwp *l, const struct netbsd32___mknod50_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(mode_t) mode;
 		syscallarg(netbsd32_dev_t) dev;
 	} */
 	return do_posix_mknodat(l, AT_FDCWD, SCARG_P32(uap, path),
 	    SCARG(uap, mode), SCARG(uap, dev));
+}
 int
 netbsd32_chmod(struct lwp *l, const struct netbsd32_chmod_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(mode_t) mode;
 	} */
 	struct sys_chmod_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(mode);
 	return sys_chmod(l, &ua, retval);
+}
 int
 netbsd32_chown(struct lwp *l, const struct netbsd32_chown_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(uid_t) uid;
 		syscallarg(gid_t) gid;
 	} */
 	struct sys_chown_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(uid);
 	NETBSD32TO64_UAP(gid);
 	return sys_chown(l, &ua, retval);
+}
 int
 netbsd32_break(struct lwp *l, const struct netbsd32_break_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_charp) nsize;
 	} */
 	struct sys_obreak_args ua;
 	NETBSD32TOP_UAP(nsize, char);
 	return sys_obreak(l, &ua, retval);
+}
 int
 netbsd32_unmount(struct lwp *l, const struct netbsd32_unmount_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) flags;
 	} */
 	struct sys_unmount_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(flags);
 	return sys_unmount(l, &ua, retval);
+}
 int
 netbsd32_setuid(struct lwp *l, const struct netbsd32_setuid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(uid_t) uid;
 	} */
 	struct sys_setuid_args ua;
 	NETBSD32TO64_UAP(uid);
 	return sys_setuid(l, &ua, retval);
+}
 int
 netbsd32_accept(struct lwp *l, const struct netbsd32_accept_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) s;
 		syscallarg(netbsd32_sockaddrp_t) name;
 		syscallarg(netbsd32_intp) anamelen;
 	} */
 	struct sys_accept_args ua;
 	NETBSD32TO64_UAP(s);
 	NETBSD32TOP_UAP(name, struct sockaddr);
 	NETBSD32TOP_UAP(anamelen, socklen_t);
 	return sys_accept(l, &ua, retval);
+}
 int
 netbsd32_getpeername(struct lwp *l, const struct netbsd32_getpeername_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fdes;
 		syscallarg(netbsd32_sockaddrp_t) asa;
 		syscallarg(netbsd32_intp) alen;
 	} */
 	struct sys_getpeername_args ua;
 	NETBSD32TO64_UAP(fdes);
 	NETBSD32TOP_UAP(asa, struct sockaddr);
 	NETBSD32TOP_UAP(alen, socklen_t);
 /* NB: do the protocol specific sockaddrs need to be converted? */
 	return sys_getpeername(l, &ua, retval);
+}
 int
 netbsd32_getsockname(struct lwp *l, const struct netbsd32_getsockname_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fdes;
 		syscallarg(netbsd32_sockaddrp_t) asa;
 		syscallarg(netbsd32_intp) alen;
 	} */
 	struct sys_getsockname_args ua;
 	NETBSD32TO64_UAP(fdes);
 	NETBSD32TOP_UAP(asa, struct sockaddr);
 	NETBSD32TOP_UAP(alen, socklen_t);
 	return sys_getsockname(l, &ua, retval);
+}
 int
 netbsd32_access(struct lwp *l, const struct netbsd32_access_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) flags;
 	} */
 	struct sys_access_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(flags);
 	return sys_access(l, &ua, retval);
+}
 int
 netbsd32_chflags(struct lwp *l, const struct netbsd32_chflags_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(netbsd32_u_long) flags;
 	} */
 	struct sys_chflags_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(flags);
 	return sys_chflags(l, &ua, retval);
+}
 int
 netbsd32_fchflags(struct lwp *l, const struct netbsd32_fchflags_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(netbsd32_u_long) flags;
 	} */
 	struct sys_fchflags_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(flags);
 	return sys_fchflags(l, &ua, retval);
+}
 int
 netbsd32_lchflags(struct lwp *l, const struct netbsd32_lchflags_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(netbsd32_u_long) flags;
 	} */
 	struct sys_lchflags_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(flags);
 	return sys_lchflags(l, &ua, retval);
+}
 int
 netbsd32_kill(struct lwp *l, const struct netbsd32_kill_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) pid;
 		syscallarg(int) signum;
 	} */
 	struct sys_kill_args ua;
 	NETBSD32TO64_UAP(pid);
 	NETBSD32TO64_UAP(signum);
 	return sys_kill(l, &ua, retval);
+}
 int
 netbsd32_dup(struct lwp *l, const struct netbsd32_dup_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 	} */
 	struct sys_dup_args ua;
 	NETBSD32TO64_UAP(fd);
 	return sys_dup(l, &ua, retval);
+}
 int
 netbsd32_profil(struct lwp *l, const struct netbsd32_profil_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp) samples;
 		syscallarg(netbsd32_size_t) size;
 		syscallarg(netbsd32_u_long) offset;
 		syscallarg(u_int) scale;
 	} */
 	struct sys_profil_args ua;
 	NETBSD32TOP_UAP(samples, void *);
 	NETBSD32TOX_UAP(size, size_t);
 	NETBSD32TOX_UAP(offset, u_long);
 	NETBSD32TO64_UAP(scale);
 	return sys_profil(l, &ua, retval);
+}
 int
 netbsd32_ktrace(struct lwp *l, const struct netbsd32_ktrace_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) fname;
 		syscallarg(int) ops;
 		syscallarg(int) facs;
 		syscallarg(int) pid;
 	} */
 	struct sys_ktrace_args ua;
 	NETBSD32TOP_UAP(fname, const char);
 	NETBSD32TO64_UAP(ops);
 	NETBSD32TO64_UAP(facs);
 	NETBSD32TO64_UAP(pid);
 	return sys_ktrace(l, &ua, retval);
+}
 int
 netbsd32_utrace(struct lwp *l, const struct netbsd32_utrace_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) label;
 		syscallarg(netbsd32_voidp) addr;
 		syscallarg(netbsd32_size_t) len;
 	} */
 	struct sys_utrace_args ua;
 	NETBSD32TOP_UAP(label, const char);
 	NETBSD32TOP_UAP(addr, void);
 	NETBSD32TO64_UAP(len);
 	return sys_utrace(l, &ua, retval);
+}
 int
 netbsd32___getlogin(struct lwp *l, const struct netbsd32___getlogin_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_charp) namebuf;
 		syscallarg(u_int) namelen;
 	} */
 	struct sys___getlogin_args ua;
 	NETBSD32TOP_UAP(namebuf, char);
 	NETBSD32TO64_UAP(namelen);
 	return sys___getlogin(l, &ua, retval);
+}
 int
 netbsd32_setlogin(struct lwp *l, const struct netbsd32_setlogin_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) namebuf;
 	} */
 	struct sys___setlogin_args ua;
 	NETBSD32TOP_UAP(namebuf, char);
 	return sys___setlogin(l, &ua, retval);
+}
 int
 netbsd32_acct(struct lwp *l, const struct netbsd32_acct_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct sys_acct_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	return sys_acct(l, &ua, retval);
+}
 int
 netbsd32_revoke(struct lwp *l, const struct netbsd32_revoke_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct sys_revoke_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	return sys_revoke(l, &ua, retval);
+}
 int
 netbsd32_symlink(struct lwp *l, const struct netbsd32_symlink_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) link;
 	} */
 	struct sys_symlink_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(link, const char);
 	return sys_symlink(l, &ua, retval);
+}
 int
 netbsd32_readlink(struct lwp *l, const struct netbsd32_readlink_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(netbsd32_charp) buf;
 		syscallarg(netbsd32_size_t) count;
 	} */
 	struct sys_readlink_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(buf, char);
 	NETBSD32TOX_UAP(count, size_t);
 	return sys_readlink(l, &ua, retval);
+}
 int
 netbsd32_umask(struct lwp *l, const struct netbsd32_umask_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(mode_t) newmask;
 	} */
 	struct sys_umask_args ua;
 	NETBSD32TO64_UAP(newmask);
 	return sys_umask(l, &ua, retval);
+}
 int
 netbsd32_chroot(struct lwp *l, const struct netbsd32_chroot_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct sys_chroot_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	return sys_chroot(l, &ua, retval);
+}
 int
 netbsd32_munmap(struct lwp *l, const struct netbsd32_munmap_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp) addr;
 		syscallarg(netbsd32_size_t) len;
 	} */
 	struct sys_munmap_args ua;
 	NETBSD32TOP_UAP(addr, void);
 	NETBSD32TOX_UAP(len, size_t);
 	return sys_munmap(l, &ua, retval);
+}
 int
 netbsd32_mprotect(struct lwp *l, const struct netbsd32_mprotect_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp) addr;
 		syscallarg(netbsd32_size_t) len;
 		syscallarg(int) prot;
 	} */
 	struct sys_mprotect_args ua;
 	NETBSD32TOP_UAP(addr, void);
 	NETBSD32TOX_UAP(len, size_t);
 	NETBSD32TO64_UAP(prot);
 	return sys_mprotect(l, &ua, retval);
+}
 int
 netbsd32_madvise(struct lwp *l, const struct netbsd32_madvise_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp) addr;
 		syscallarg(netbsd32_size_t) len;
 		syscallarg(int) behav;
 	} */
 	struct sys_madvise_args ua;
 	NETBSD32TOP_UAP(addr, void);
 	NETBSD32TOX_UAP(len, size_t);
 	NETBSD32TO64_UAP(behav);
 	return sys_madvise(l, &ua, retval);
+}
 int
 netbsd32_mincore(struct lwp *l, const struct netbsd32_mincore_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp) addr;
 		syscallarg(netbsd32_size_t) len;
 		syscallarg(netbsd32_charp) vec;
 	} */
 	struct sys_mincore_args ua;
 	NETBSD32TOP_UAP(addr, void *);
 	NETBSD32TOX_UAP(len, size_t);
 	NETBSD32TOP_UAP(vec, char);
 	return sys_mincore(l, &ua, retval);
+}
 int
 netbsd32_getgroups(struct lwp *l, const struct netbsd32_getgroups_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) gidsetsize;
 		syscallarg(netbsd32_gid_tp) gidset;
 	} */
 	struct sys_getgroups_args ua;
 	/* Since sizeof (gid_t) == sizeof (netbsd32_gid_t) ... */
 	NETBSD32TO64_UAP(gidsetsize);
 	NETBSD32TOP_UAP(gidset, gid_t);
 	return sys_getgroups(l, &ua, retval);
+}
 int
 netbsd32_setgroups(struct lwp *l, const struct netbsd32_setgroups_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) gidsetsize;
 		syscallarg(const netbsd32_gid_tp) gidset;
 	} */
 	struct sys_setgroups_args ua;
 	NETBSD32TO64_UAP(gidsetsize);
 	NETBSD32TOP_UAP(gidset, gid_t);
 	return sys_setgroups(l, &ua, retval);
+}
 int
 netbsd32_setpgid(struct lwp *l, const struct netbsd32_setpgid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) pid;
 		syscallarg(int) pgid;
 	} */
 	struct sys_setpgid_args ua;
 	NETBSD32TO64_UAP(pid);
 	NETBSD32TO64_UAP(pgid);
 	return sys_setpgid(l, &ua, retval);
+}
 int
 netbsd32_fcntl(struct lwp *l, const struct netbsd32_fcntl_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) cmd;
 		syscallarg(netbsd32_voidp) arg;
 	} */
 	struct sys_fcntl_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(cmd);
 	/* we can do this because `struct flock' doesn't change */
 	NETBSD32TOP_UAP(arg, void);
 	return sys_fcntl(l, &ua, retval);
+}
 int
 netbsd32_dup2(struct lwp *l, const struct netbsd32_dup2_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) from;
 		syscallarg(int) to;
 	} */
 	struct sys_dup2_args ua;
 	NETBSD32TO64_UAP(from);
 	NETBSD32TO64_UAP(to);
 	return sys_dup2(l, &ua, retval);
+}
 int
 netbsd32_fsync(struct lwp *l, const struct netbsd32_fsync_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 	} */
 	struct sys_fsync_args ua;
 	NETBSD32TO64_UAP(fd);
 	return sys_fsync(l, &ua, retval);
+}
 int
 netbsd32_setpriority(struct lwp *l, const struct netbsd32_setpriority_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) which;
 		syscallarg(int) who;
 		syscallarg(int) prio;
 	} */
 	struct sys_setpriority_args ua;
 	NETBSD32TO64_UAP(which);
 	NETBSD32TO64_UAP(who);
 	NETBSD32TO64_UAP(prio);
 	return sys_setpriority(l, &ua, retval);
+}
 int
 netbsd32___socket30(struct lwp *l, const struct netbsd32___socket30_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) domain;
 		syscallarg(int) type;
 		syscallarg(int) protocol;
 	} */
 	struct sys___socket30_args ua;
 	NETBSD32TO64_UAP(domain);
 	NETBSD32TO64_UAP(type);
 	NETBSD32TO64_UAP(protocol);
 	return sys___socket30(l, &ua, retval);
+}
 int
 netbsd32_connect(struct lwp *l, const struct netbsd32_connect_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) s;
 		syscallarg(const netbsd32_sockaddrp_t) name;
 		syscallarg(int) namelen;
 	} */
 	struct sys_connect_args ua;
 	NETBSD32TO64_UAP(s);
 	NETBSD32TOP_UAP(name, struct sockaddr);
 	NETBSD32TO64_UAP(namelen);
 	return sys_connect(l, &ua, retval);
+}
 int
 netbsd32_getpriority(struct lwp *l, const struct netbsd32_getpriority_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) which;
 		syscallarg(int) who;
 	} */
 	struct sys_getpriority_args ua;
 	NETBSD32TO64_UAP(which);
 	NETBSD32TO64_UAP(who);
 	return sys_getpriority(l, &ua, retval);
+}
 int
 netbsd32_bind(struct lwp *l, const struct netbsd32_bind_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) s;
 		syscallarg(const netbsd32_sockaddrp_t) name;
 		syscallarg(int) namelen;
 	} */
 	struct sys_bind_args ua;
 	NETBSD32TO64_UAP(s);
 	NETBSD32TOP_UAP(name, struct sockaddr);
 	NETBSD32TO64_UAP(namelen);
 	return sys_bind(l, &ua, retval);
+}
 int
 netbsd32_setsockopt(struct lwp *l, const struct netbsd32_setsockopt_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) s;
 		syscallarg(int) level;
 		syscallarg(int) name;
 		syscallarg(const netbsd32_voidp) val;
 		syscallarg(int) valsize;
 	} */
 	struct sys_setsockopt_args ua;
 	NETBSD32TO64_UAP(s);
 	NETBSD32TO64_UAP(level);
 	NETBSD32TO64_UAP(name);
 	NETBSD32TOP_UAP(val, void);
 	NETBSD32TO64_UAP(valsize);
 	/* may be more efficient to do this inline. */
 	return sys_setsockopt(l, &ua, retval);
+}
 int
 netbsd32_listen(struct lwp *l, const struct netbsd32_listen_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) s;
 		syscallarg(int) backlog;
 	} */
 	struct sys_listen_args ua;
 	NETBSD32TO64_UAP(s);
 	NETBSD32TO64_UAP(backlog);
 	return sys_listen(l, &ua, retval);
+}
 int
 netbsd32_fchown(struct lwp *l, const struct netbsd32_fchown_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(uid_t) uid;
 		syscallarg(gid_t) gid;
 	} */
 	struct sys_fchown_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(uid);
 	NETBSD32TO64_UAP(gid);
 	return sys_fchown(l, &ua, retval);
+}
 int
 netbsd32_fchmod(struct lwp *l, const struct netbsd32_fchmod_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(mode_t) mode;
 	} */
 	struct sys_fchmod_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(mode);
 	return sys_fchmod(l, &ua, retval);
+}
 int
 netbsd32_setreuid(struct lwp *l, const struct netbsd32_setreuid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(uid_t) ruid;
 		syscallarg(uid_t) euid;
 	} */
 	struct sys_setreuid_args ua;
 	NETBSD32TO64_UAP(ruid);
 	NETBSD32TO64_UAP(euid);
 	return sys_setreuid(l, &ua, retval);
+}
 int
 netbsd32_setregid(struct lwp *l, const struct netbsd32_setregid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(gid_t) rgid;
 		syscallarg(gid_t) egid;
 	} */
 	struct sys_setregid_args ua;
 	NETBSD32TO64_UAP(rgid);
 	NETBSD32TO64_UAP(egid);
 	return sys_setregid(l, &ua, retval);
+}
 int
 netbsd32_getsockopt(struct lwp *l, const struct netbsd32_getsockopt_args *uap, register_t *retval)
+{
 @@ -1652,1015 +1652,1030 @@ netbsd32___posix_fchown(struct lwp *l, c
 	NETBSD32TO64_UAP(gid);
 	return sys___posix_fchown(l, &ua, retval);
+}
 int
 netbsd32___posix_lchown(struct lwp *l, const struct netbsd32___posix_lchown_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(uid_t) uid;
 		syscallarg(gid_t) gid;
 	} */
 	struct sys___posix_lchown_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(uid);
 	NETBSD32TO64_UAP(gid);
 	return sys___posix_lchown(l, &ua, retval);
+}
 int
 netbsd32_getsid(struct lwp *l, const struct netbsd32_getsid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(pid_t) pid;
 	} */
 	struct sys_getsid_args ua;
 	NETBSD32TO64_UAP(pid);
 	return sys_getsid(l, &ua, retval);
+}
 int
 netbsd32_fktrace(struct lwp *l, const struct netbsd32_fktrace_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) ops;
 		syscallarg(int) facs;
 		syscallarg(int) pid;
 	} */
 	struct sys_fktrace_args ua;
 	NETBSD32TOX_UAP(fd, int);
 	NETBSD32TO64_UAP(ops);
 	NETBSD32TO64_UAP(facs);
 	NETBSD32TO64_UAP(pid);
 	return sys_fktrace(l, &ua, retval);
+}
 int
 netbsd32___sigpending14(struct lwp *l, const struct netbsd32___sigpending14_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(sigset_t *) set;
 	} */
 	struct sys___sigpending14_args ua;
 	NETBSD32TOP_UAP(set, sigset_t);
 	return sys___sigpending14(l, &ua, retval);
+}
 int
 netbsd32___sigprocmask14(struct lwp *l, const struct netbsd32___sigprocmask14_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) how;
 		syscallarg(const sigset_t *) set;
 		syscallarg(sigset_t *) oset;
 	} */
 	struct sys___sigprocmask14_args ua;
 	NETBSD32TO64_UAP(how);
 	NETBSD32TOP_UAP(set, sigset_t);
 	NETBSD32TOP_UAP(oset, sigset_t);
 	return sys___sigprocmask14(l, &ua, retval);
+}
 int
 netbsd32___sigsuspend14(struct lwp *l, const struct netbsd32___sigsuspend14_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const sigset_t *) set;
 	} */
 	struct sys___sigsuspend14_args ua;
 	NETBSD32TOP_UAP(set, sigset_t);
 	return sys___sigsuspend14(l, &ua, retval);
+}
 int
 netbsd32_fchroot(struct lwp *l, const struct netbsd32_fchroot_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 	} */
 	struct sys_fchroot_args ua;
 	NETBSD32TO64_UAP(fd);
 	return sys_fchroot(l, &ua, retval);
+}
 /*
  * Open a file given a file handle.
+ *
  * Check permissions, allocate an open file structure,
  * and call the device open routine if any.
  */
 int
 netbsd32___fhopen40(struct lwp *l, const struct netbsd32___fhopen40_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_pointer_t *) fhp;
 		syscallarg(netbsd32_size_t) fh_size;
 		syscallarg(int) flags;
 	} */
 	struct sys___fhopen40_args ua;
 	NETBSD32TOP_UAP(fhp, fhandle_t);
 	NETBSD32TO64_UAP(fh_size);
 	NETBSD32TO64_UAP(flags);
 	return sys___fhopen40(l, &ua, retval);
+}
 /* virtual memory syscalls */
 int
 netbsd32_ovadvise(struct lwp *l, const struct netbsd32_ovadvise_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) anom;
 	} */
 	struct sys_ovadvise_args ua;
 	NETBSD32TO64_UAP(anom);
 	return sys_ovadvise(l, &ua, retval);
+}
 int
 netbsd32_uuidgen(struct lwp *l, const struct netbsd32_uuidgen_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_uuidp_t) store;
 		syscallarg(int) count;
 	} */
 	struct sys_uuidgen_args ua;
 	NETBSD32TOP_UAP(store, struct uuid);
 	NETBSD32TO64_UAP(count);
 	return sys_uuidgen(l, &ua, retval);
+}
 int
 netbsd32_extattrctl(struct lwp *l, const struct netbsd32_extattrctl_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) cmd;
 		syscallarg(const netbsd32_charp) filename;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 	} */
 	struct sys_extattrctl_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(cmd);
 	NETBSD32TOP_UAP(filename, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	return sys_extattrctl(l, &ua, retval);
+}
 int
 netbsd32_extattr_set_fd(struct lwp *l, const struct netbsd32_extattr_set_fd_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 		syscallarg(const netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_set_fd_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	NETBSD32TOP_UAP(data, const void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_set_fd(l, &ua, retval);
+}
 int
 netbsd32_extattr_set_file(struct lwp *l, const struct netbsd32_extattr_set_file_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 		syscallarg(const netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_set_file_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	NETBSD32TOP_UAP(data, const void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_set_file(l, &ua, retval);
+}
 int
 netbsd32_extattr_set_link(struct lwp *l, const struct netbsd32_extattr_set_link_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 		syscallarg(const netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_set_link_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	NETBSD32TOP_UAP(data, const void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_set_link(l, &ua, retval);
+}
 int
 netbsd32_extattr_get_fd(struct lwp *l, const struct netbsd32_extattr_get_fd_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 		syscallarg(netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_get_fd_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	NETBSD32TOP_UAP(data, void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_get_fd(l, &ua, retval);
+}
 int
 netbsd32_extattr_get_file(struct lwp *l, const struct netbsd32_extattr_get_file_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 		syscallarg(netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_get_file_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	NETBSD32TOP_UAP(data, void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_get_file(l, &ua, retval);
+}
 int
 netbsd32_extattr_get_link(struct lwp *l, const struct netbsd32_extattr_get_link_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 		syscallarg(netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_get_link_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	NETBSD32TOP_UAP(data, void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_get_link(l, &ua, retval);
+}
 int
 netbsd32_extattr_delete_fd(struct lwp *l, const struct netbsd32_extattr_delete_fd_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 	} */
 	struct sys_extattr_delete_fd_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	return sys_extattr_delete_fd(l, &ua, retval);
+}
 int
 netbsd32_extattr_delete_file(struct lwp *l, const struct netbsd32_extattr_delete_file_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 	} */
 	struct sys_extattr_delete_file_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	return sys_extattr_delete_file(l, &ua, retval);
+}
 int
 netbsd32_extattr_delete_link(struct lwp *l, const struct netbsd32_extattr_delete_link_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(const netbsd32_charp) attrname;
 	} */
 	struct sys_extattr_delete_link_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(attrname, const char);
 	return sys_extattr_delete_link(l, &ua, retval);
+}
 int
 netbsd32_extattr_list_fd(struct lwp *l, const struct netbsd32_extattr_list_fd_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) attrnamespace;
 		syscallarg(netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_list_fd_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(data, void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_list_fd(l, &ua, retval);
+}
 int
 netbsd32_extattr_list_file(struct lwp *l, const struct netbsd32_extattr_list_file_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_list_file_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(data, void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_list_file(l, &ua, retval);
+}
 int
 netbsd32_extattr_list_link(struct lwp *l, const struct netbsd32_extattr_list_link_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) attrnamespace;
 		syscallarg(netbsd32_voidp) data;
 		syscallarg(netbsd32_size_t) nbytes;
 	} */
 	struct sys_extattr_list_link_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(attrnamespace);
 	NETBSD32TOP_UAP(data, void);
 	NETBSD32TOX_UAP(nbytes, size_t);
 	return sys_extattr_list_link(l, &ua, retval);
+}
 int
 netbsd32_mlockall(struct lwp *l, const struct netbsd32_mlockall_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) flags;
 	} */
 	struct sys_mlockall_args ua;
 	NETBSD32TO64_UAP(flags);
 	return sys_mlockall(l, &ua, retval);
+}
 int
 netbsd32___clone(struct lwp *l, const struct netbsd32___clone_args *uap, register_t *retval)
+{
 	/*  {
 		syscallarg(int) flags;
 		syscallarg(netbsd32_voidp) stack;
 	} */
 	struct sys___clone_args ua;
 	NETBSD32TO64_UAP(flags);
 	NETBSD32TOP_UAP(stack, void);
 	return sys___clone(l, &ua, retval);
+}
 int
 netbsd32_fsync_range(struct lwp *l, const struct netbsd32_fsync_range_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) flags;
 		syscallarg(off_t) start;
 		syscallarg(off_t) length;
 	} */
 	struct sys_fsync_range_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(flags);
 	NETBSD32TO64_UAP(start);
 	NETBSD32TO64_UAP(length);
 	return sys_fsync_range(l, &ua, retval);
+}
 int
 netbsd32_rasctl(struct lwp *l, const struct netbsd32_rasctl_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp) addr;
 		syscallarg(netbsd32_size_t) len;
 		syscallarg(int) op;
 	} */
 	struct sys_rasctl_args ua;
 	NETBSD32TOP_UAP(addr, void *);
 	NETBSD32TOX_UAP(len, size_t);
 	NETBSD32TO64_UAP(op);
 	return sys_rasctl(l, &ua, retval);
+}
 int
 netbsd32_setxattr(struct lwp *l, const struct netbsd32_setxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) name;
 		syscallarg(netbsd32_voidp) value;
 		syscallarg(netbsd32_size_t) size;
 		syscallarg(int) flags;
 	} */
 	struct sys_setxattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TOP_UAP(value, void);
 	NETBSD32TOX_UAP(size, size_t);
 	NETBSD32TO64_UAP(flags);
 	return sys_setxattr(l, &ua, retval);
+}
 int
 netbsd32_lsetxattr(struct lwp *l, const struct netbsd32_lsetxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) name;
 		syscallarg(netbsd32_voidp) value;
 		syscallarg(netbsd32_size_t) size;
 		syscallarg(int) flags;
 	} */
 	struct sys_lsetxattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TOP_UAP(value, void);
 	NETBSD32TOX_UAP(size, size_t);
 	NETBSD32TO64_UAP(flags);
 	return sys_lsetxattr(l, &ua, retval);
+}
 int
 netbsd32_fsetxattr(struct lwp *l, const struct netbsd32_fsetxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_charp) name;
 		syscallarg(netbsd32_voidp) value;
 		syscallarg(netbsd32_size_t) size;
 		syscallarg(int) flags;
 	} */
 	struct sys_fsetxattr_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TOP_UAP(value, void);
 	NETBSD32TOX_UAP(size, size_t);
 	NETBSD32TO64_UAP(flags);
 	return sys_fsetxattr(l, &ua, retval);
+}
 int
 netbsd32_getxattr(struct lwp *l, const struct netbsd32_getxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) name;
 		syscallarg(netbsd32_voidp) value;
 		syscallarg(netbsd32_size_t) size;
 	} */
 	struct sys_getxattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TOP_UAP(value, void);
 	NETBSD32TOX_UAP(size, size_t);
 	return sys_getxattr(l, &ua, retval);
+}
 int
 netbsd32_lgetxattr(struct lwp *l, const struct netbsd32_lgetxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) name;
 		syscallarg(netbsd32_voidp) value;
 		syscallarg(netbsd32_size_t) size;
 	} */
 	struct sys_lgetxattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TOP_UAP(value, void);
 	NETBSD32TOX_UAP(size, size_t);
 	return sys_lgetxattr(l, &ua, retval);
+}
 int
 netbsd32_fgetxattr(struct lwp *l, const struct netbsd32_fgetxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_charp) name;
 		syscallarg(netbsd32_voidp) value;
 		syscallarg(netbsd32_size_t) size;
 	} */
 	struct sys_fgetxattr_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TOP_UAP(value, void);
 	NETBSD32TOX_UAP(size, size_t);
 	return sys_fgetxattr(l, &ua, retval);
+}
 int
 netbsd32_listxattr(struct lwp *l, const struct netbsd32_listxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(netbsd32_charp) list;
 		syscallarg(netbsd32_size_t) size;
 	} */
 	struct sys_listxattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(list, char);
 	NETBSD32TOX_UAP(size, size_t);
 	return sys_listxattr(l, &ua, retval);
+}
 int
 netbsd32_llistxattr(struct lwp *l, const struct netbsd32_llistxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(netbsd32_charp) list;
 		syscallarg(netbsd32_size_t) size;
 	} */
 	struct sys_llistxattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(list, char);
 	NETBSD32TOX_UAP(size, size_t);
 	return sys_llistxattr(l, &ua, retval);
+}
 int
 netbsd32_flistxattr(struct lwp *l, const struct netbsd32_flistxattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(netbsd32_charp) list;
 		syscallarg(netbsd32_size_t) size;
 	} */
 	struct sys_flistxattr_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TOP_UAP(list, char);
 	NETBSD32TOX_UAP(size, size_t);
 	return sys_flistxattr(l, &ua, retval);
+}
 int
 netbsd32_removexattr(struct lwp *l, const struct netbsd32_removexattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) name;
 	} */
 	struct sys_removexattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(name, const char);
 	return sys_removexattr(l, &ua, retval);
+}
 int
 netbsd32_lremovexattr(struct lwp *l, const struct netbsd32_lremovexattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(const netbsd32_charp) name;
 	} */
 	struct sys_lremovexattr_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TOP_UAP(name, const char);
 	return sys_lremovexattr(l, &ua, retval);
+}
 int
 netbsd32_fremovexattr(struct lwp *l, const struct netbsd32_fremovexattr_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_charp) name;
 	} */
 	struct sys_fremovexattr_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TOP_UAP(name, const char);
 	return sys_fremovexattr(l, &ua, retval);
+}
 int
 netbsd32___posix_fadvise50(struct lwp *l,
 	const struct netbsd32___posix_fadvise50_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) PAD;
 		syscallarg(netbsd32_off_t) offset;
 		syscallarg(netbsd32_off_t) len;
 		syscallarg(int) advice;
 	} */
 	*retval = do_posix_fadvise(SCARG(uap, fd), SCARG(uap, offset),
 	    SCARG(uap, len), SCARG(uap, advice));
 	return 0;
+}
 int
 netbsd32__sched_setparam(struct lwp *l,
 			 const struct netbsd32__sched_setparam_args *uap,
 			 register_t *retval)
+{
 	/* {
 		syscallarg(pid_t) pid;
 		syscallarg(lwpid_t) lid;
 		syscallarg(int) policy;
 		syscallarg(const netbsd32_sched_paramp_t) params;
 	} */
 	struct sys__sched_setparam_args ua;
 	NETBSD32TO64_UAP(pid);
 	NETBSD32TO64_UAP(lid);
 	NETBSD32TO64_UAP(policy);
 	NETBSD32TOP_UAP(params, const struct sched_param *);
 	return sys__sched_setparam(l, &ua, retval);
+}
 int
 netbsd32__sched_getparam(struct lwp *l,
 			 const struct netbsd32__sched_getparam_args *uap,
 			 register_t *retval)
+{
 	/* {
 		syscallarg(pid_t) pid;
 		syscallarg(lwpid_t) lid;
 		syscallarg(netbsd32_intp) policy;
 		syscallarg(netbsd32_sched_paramp_t) params;
 	} */
 	struct sys__sched_getparam_args ua;
 	NETBSD32TO64_UAP(pid);
 	NETBSD32TO64_UAP(lid);
 	NETBSD32TOP_UAP(policy, int *);
 	NETBSD32TOP_UAP(params, struct sched_param *);
 	return sys__sched_getparam(l, &ua, retval);
+}
 int
 netbsd32__sched_setaffinity(struct lwp *l,
 			    const struct netbsd32__sched_setaffinity_args *uap,
 			    register_t *retval)
+{
 	/* {
 		syscallarg(pid_t) pid;
 		syscallarg(lwpid_t) lid;
 		syscallarg(netbsd_size_t) size;
 		syscallarg(const netbsd32_cpusetp_t) cpuset;
 	} */
 	struct sys__sched_setaffinity_args ua;
 	NETBSD32TO64_UAP(pid);
 	NETBSD32TO64_UAP(lid);
 	NETBSD32TOX_UAP(size, size_t);
 	NETBSD32TOP_UAP(cpuset, const cpuset_t *);
 	return sys__sched_setaffinity(l, &ua, retval);
+}
 int
 netbsd32__sched_getaffinity(struct lwp *l,
 			    const struct netbsd32__sched_getaffinity_args *uap,
 			    register_t *retval)
+{
 	/* {
 		syscallarg(pid_t) pid;
 		syscallarg(lwpid_t) lid;
 		syscallarg(netbsd_size_t) size;
 		syscallarg(netbsd32_cpusetp_t) cpuset;
 	} */
 	struct sys__sched_getaffinity_args ua;
 	NETBSD32TO64_UAP(pid);
 	NETBSD32TO64_UAP(lid);
 	NETBSD32TOX_UAP(size, size_t);
 	NETBSD32TOP_UAP(cpuset, cpuset_t *);
 	return sys__sched_getaffinity(l, &ua, retval);
+}
 int
 netbsd32__sched_protect(struct lwp *l,
 			const struct netbsd32__sched_protect_args *uap,
 			register_t *retval)
+{
 	/* {
 		syscallarg(int) priority;
 	} */
 	struct sys__sched_protect_args ua;
 	NETBSD32TO64_UAP(priority);
 	return sys__sched_protect(l, &ua, retval);
+}
 int
 netbsd32_dup3(struct lwp *l, const struct netbsd32_dup3_args *uap,
 	      register_t *retval)
+{
 	/* {
 		syscallarg(int) from;
 		syscallarg(int) to;
 		syscallarg(int) flags;
 	} */
 	struct sys_dup3_args ua;
 	NETBSD32TO64_UAP(from);
 	NETBSD32TO64_UAP(to);
 	NETBSD32TO64_UAP(flags);
 	return sys_dup3(l, &ua, retval);
+}
 int
 netbsd32_kqueue1(struct lwp *l, const struct netbsd32_kqueue1_args *uap,
 		 register_t *retval)
+{
 	/* {
 		syscallarg(int) flags;
 	} */
 	struct sys_kqueue1_args ua;
 	NETBSD32TO64_UAP(flags);
 	return sys_kqueue1(l, &ua, retval);
+}
 int
 netbsd32_paccept(struct lwp *l, const struct netbsd32_paccept_args *uap,
 		 register_t *retval)
+{
 	/* {
 		syscallarg(int) s;
 		syscallarg(netbsd32_sockaddrp_t) name;
 		syscallarg(netbsd32_socklenp_t) anamelen;
 		syscallarg(const netbsd32_sigsetp_t) mask;
 		syscallarg(int) flags;
 	} */
 	struct sys_paccept_args ua;
 	NETBSD32TO64_UAP(s);
 	NETBSD32TOP_UAP(name, struct sockaddr *);
 	NETBSD32TOP_UAP(anamelen, socklen_t *);
 	NETBSD32TOP_UAP(mask, const sigset_t *);
 	NETBSD32TO64_UAP(flags);
 	return sys_paccept(l, &ua, retval);
+}
 int
 netbsd32_fdiscard(struct lwp *l, const struct netbsd32_fdiscard_args *uap,
 	register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(netbsd32_off_t) pos;
 		syscallarg(netbsd32_off_t) len;
 	} */
 	struct sys_fdiscard_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(pos);
 	NETBSD32TO64_UAP(len);
 	return sys_fdiscard(l, &ua, retval);
+}
 int
 netbsd32_posix_fallocate(struct lwp *l, const struct netbsd32_posix_fallocate_args *uap,
 	register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(netbsd32_off_t) pos;
 		syscallarg(netbsd32_off_t) len;
 	} */
 	struct sys_posix_fallocate_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(pos);
 	NETBSD32TO64_UAP(len);
 	return sys_posix_fallocate(l, &ua, retval);
+}
 int
 netbsd32_pset_create(struct lwp *l,
     const struct netbsd32_pset_create_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_psetidp_t) psid;
 	}; */
 	struct sys_pset_create_args ua;
 	NETBSD32TOP_UAP(psid, psetid_t);
 	return sys_pset_create(l, &ua, retval);
+}
 int
 netbsd32_pset_destroy(struct lwp *l,
      const struct netbsd32_pset_destroy_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(psetid_t) psid;
 	}; */
 	return sys_pset_destroy(l, (const void *)uap, retval);
+}
 int
 netbsd32_pset_assign(struct lwp *l,
      const struct netbsd32_pset_assign_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(psetid_t) psid;
 		syscallarg(cpuid_t) cpuid;
 		syscallarg(netbsd32_psetidp_t) opsid;
 	}; */
 	struct sys_pset_assign_args ua;
 	SCARG(&ua, psid) = SCARG(uap, psid);
 	NETBSD32TO64_UAP(cpuid);
 	NETBSD32TOP_UAP(opsid, psetid_t);
 	return sys_pset_assign(l, &ua, retval);
+}
 int
 netbsd32__pset_bind(struct lwp *l,
      const struct netbsd32__pset_bind_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(idtype_t) idtype;
 		syscallarg(id_t) first_id;
 		syscallarg(id_t) second_id;
 		syscallarg(psetid_t) psid;
 		syscallarg(netbsd32_psetidp_t) opsid;
 	}; */
 	struct sys__pset_bind_args ua;
 	SCARG(&ua, idtype) = SCARG(uap, idtype);
 	SCARG(&ua, first_id) = SCARG(uap, first_id);
 	SCARG(&ua, second_id) = SCARG(uap, second_id);
 	SCARG(&ua, psid) = SCARG(uap, psid);
 	NETBSD32TOP_UAP(opsid, psetid_t);
 	return sys__pset_bind(l, &ua, retval);
+}
 int
 netbsd32_getrandom(struct lwp *l, const struct netbsd32_getrandom_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_voidp)	buf;
 		syscallarg(netbsd32_size_t)	buflen;
 		syscallarg(unsigned)		flags;
 	} */
 	struct sys_getrandom_args ua;
 	NETBSD32TOP_UAP(buf, void *);
 	NETBSD32TOX_UAP(buflen, size_t);
 	NETBSD32TO64_UAP(flags);
 	return sys_getrandom(l, &ua, retval);
+}
 int
 netbsd32_eventfd(struct lwp *l,
     const struct netbsd32_eventfd_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(unsigned int)	val;
 		syscallarg(int)			flags;
 	} */
 	struct sys_eventfd_args ua;
 	NETBSD32TO64_UAP(val);
 	NETBSD32TO64_UAP(flags);
 	return sys_eventfd(l, &ua, retval);
+}
 int
 netbsd32_memfd_create(struct lwp *l,
     const struct netbsd32_memfd_create_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp)	name;
 		syscallarg(unsigned int)		flags;
 	} */
 	struct sys_memfd_create_args ua;
 	NETBSD32TOP_UAP(name, const char);
 	NETBSD32TO64_UAP(flags);
 	return sys_memfd_create(l, &ua, retval);
+}
 /*
  * MI indirect system call support.
  * Only used if the MD netbsd32_syscall.c doesn't intercept the calls.
  */
 #define NETBSD32_SYSCALL
 #undef SYS_NSYSENT
 #define SYS_NSYSENT NETBSD32_SYS_NSYSENT
 #define SYS_SYSCALL netbsd32_syscall
 #include "../../kern/sys_syscall.c"
 #undef SYS_SYSCALL
 #define SYS_SYSCALL netbsd32____syscall
 #include "../../kern/sys_syscall.c"
 #undef SYS_SYSCALL

 @@ -1,1226 +1,1227 @@
-	$NetBSD: syscalls.master,v 1.142 2023/07/29 12:38:25 rin Exp $
+	$NetBSD: syscalls.master,v 1.143 2023/07/30 05:30:45 rin Exp $
 ;	from: NetBSD: syscalls.master,v 1.81 1998/07/05 08:49:50 jonathan Exp
 ;	@(#)syscalls.master	8.2 (Berkeley) 1/13/94
 ; NetBSD system call name/number "master" file.
 ; (See syscalls.conf to see what it is processed into.)
+;
 ; Fields: number type [type-dependent ...]
 ;	number	system call number, must be in order
 ;	type	one of STD, OBSOL, UNIMPL, IGNORED, NODEF, NOARGS, or one of
 ;		the compatibility options defined in syscalls.conf.
+;
 ; types:
 ;	STD	always included
 ;	OBSOL	obsolete, not included in system
 ;	IGNORED	syscall is a null op, but always succeeds
 ;	UNIMPL	unimplemented, not included in system
 ;	EXCL	implemented, but not included in system
 ;	NODEF	included, but don't define the syscall number
 ;	NOARGS	included, but don't define the syscall args structure
 ;	INDIR	included, but don't define the syscall args structure,
 ;		and allow it to be "really" varargs.
+;
 ; The compat options are defined in the syscalls.conf file, and the
 ; compat option name is prefixed to the syscall name.  Other than
 ; that, they're like NODEF (for 'compat' options), or STD (for
 ; 'libcompat' options).
+;
 ; The type-dependent arguments are as follows:
 ; For STD, NODEF, NOARGS, and compat syscalls:
 ;	{ pseudo-proto } [alias]
 ; For other syscalls:
 ;	[comment]
+;
 ; #ifdef's, etc. may be included, and are copied to the output files.
 ; #include's are copied to the syscall names and switch definition files only.
 #if defined(_KERNEL_OPT)
 #include "opt_compat_netbsd.h"
 #include "opt_ntp.h"
 #include "opt_compat_43.h"
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/signal.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_syscall.h>
 #include <compat/netbsd32/netbsd32_syscallargs.h>
 %%
 ; Reserved/unimplemented system calls in the range 0-150 inclusive
 ; are reserved for use in future Berkeley releases.
 ; Additional system calls implemented in vendor and other
 ; redistributions should be placed in the reserved range at the end
 ; of the current calls.
 	INDIR		{ int|netbsd32||syscall(int code, \
 			    ... register32_t args[NETBSD32_SYS_MAXSYSARGS]); }
 	STD		{ void|netbsd32||exit(int rval); }
 	NOARGS		{ int|sys||fork(void); }
 	STD		{ netbsd32_ssize_t|netbsd32||read(int fd, \
 			    netbsd32_voidp buf, netbsd32_size_t nbyte); }
 	STD		{ netbsd32_ssize_t|netbsd32||write(int fd, \
 			    netbsd32_voidp buf, netbsd32_size_t nbyte); }
 	STD		{ int|netbsd32||open(netbsd32_charp path, int flags, \
 			    ... mode_t mode); }
 	STD		{ int|netbsd32||close(int fd); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||wait4(int pid, netbsd32_intp status, \
 			    int options, netbsd32_rusage50p_t rusage); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ocreat(netbsd32_charp path, \
 			    mode_t mode); }
 	STD		{ int|netbsd32||link(netbsd32_charp path, \
 			    netbsd32_charp link); }
 	STD		{ int|netbsd32||unlink(netbsd32_charp path); }
 	OBSOL		execv
 	STD		{ int|netbsd32||chdir(netbsd32_charp path); }
 	STD		{ int|netbsd32||fchdir(int fd); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||mknod(netbsd32_charp path, mode_t mode, \
 			    uint32_t dev); }
 	STD		{ int|netbsd32||chmod(netbsd32_charp path, mode_t mode); }
 	STD		{ int|netbsd32||chown(netbsd32_charp path, uid_t uid, \
 			    gid_t gid); }
 	STD		{ int|netbsd32||break(netbsd32_charp nsize); }
 	COMPAT_20 MODULAR compat_netbsd32_20	\
 			{ int|netbsd32||getfsstat(netbsd32_statfsp_t buf, \
 			    netbsd32_long bufsize, int flags); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ netbsd32_long|netbsd32||olseek(int fd, \
 			    netbsd32_long offset, int whence); }
 	NOARGS 		{ pid_t|sys||getpid_with_ppid(void); } getpid
 	COMPAT_40 MODULAR compat_netbsd32_40	\
 			{ int|netbsd32||mount(netbsd32_charp type, \
 			    netbsd32_charp path, int flags, \
 			    netbsd32_voidp data); }
 	STD		{ int|netbsd32||unmount(netbsd32_charp path, \
 			    int flags); }
 	STD		{ int|netbsd32||setuid(uid_t uid); }
 	NOARGS 		{ uid_t|sys||getuid_with_euid(void); } getuid
 	NOARGS		{ uid_t|sys||geteuid(void); }
 	STD MODULAR compat_netbsd32_ptrace \
 			{ int|netbsd32||ptrace(int req, pid_t pid, \
 			    netbsd32_voidp addr, int data); }
 	STD		{ netbsd32_ssize_t|netbsd32||recvmsg(int s, \
 			    netbsd32_msghdrp_t msg, int flags); }
 	STD		{ netbsd32_ssize_t|netbsd32||sendmsg(int s, \
 			    netbsd32_msghdrp_t msg, int flags); }
 	STD		{ netbsd32_ssize_t|netbsd32||recvfrom(int s, \
 			    netbsd32_voidp buf, netbsd32_size_t len, \
 			    int flags, netbsd32_sockaddrp_t from, \
 			    netbsd32_intp fromlenaddr); }
 	STD		{ int|netbsd32||accept(int s, \
 			    netbsd32_sockaddrp_t name, \
 			    netbsd32_intp anamelen); }
 	STD		{ int|netbsd32||getpeername(int fdes, \
 			    netbsd32_sockaddrp_t asa, netbsd32_intp alen); }
 	STD		{ int|netbsd32||getsockname(int fdes, \
 			    netbsd32_sockaddrp_t asa, netbsd32_intp alen); }
 	STD		{ int|netbsd32||access(netbsd32_charp path, int flags); }
 	STD		{ int|netbsd32||chflags(netbsd32_charp path, \
 			    netbsd32_u_long flags); }
 	STD		{ int|netbsd32||fchflags(int fd, \
 			    netbsd32_u_long flags); }
 	NOARGS		{ void|sys||sync(void); }
 	STD		{ int|netbsd32||kill(int pid, int signum); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||stat43(netbsd32_charp path, \
 			    netbsd32_stat43p_t ub); }
 	NOARGS 		{ pid_t|sys||getppid(void); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||lstat43(netbsd32_charp path, \
 			    netbsd32_stat43p_t ub); }
 	STD		{ int|netbsd32||dup(int fd); }
 	NOARGS		{ int|sys||pipe(void); }
 	NOARGS 		{ gid_t|sys||getegid(void); }
 	STD		{ int|netbsd32||profil(netbsd32_voidp samples, \
 			    netbsd32_size_t size, netbsd32_u_long offset, \
 			    u_int scale); }
 	STD		{ int|netbsd32||ktrace(netbsd32_charp fname, int ops, \
 			    int facs, int pid); }
 	STD		{ int|netbsd32||sigaction(int signum, \
 			    netbsd32_sigactionp_t nsa, \
 			    netbsd32_sigactionp_t osa); }
 	NOARGS 		{ gid_t|sys||getgid_with_egid(void); } getgid
 	COMPAT_13 MODULAR compat_netbsd32_13	\
 			{ int|netbsd32||sigprocmask(int how, \
 			    int mask); } sigprocmask13
 	STD		{ int|netbsd32||__getlogin(netbsd32_charp namebuf, \
 			    u_int namelen); }
 	STD		{ int|netbsd32||setlogin(netbsd32_charp namebuf); }
 	STD		{ int|netbsd32||acct(netbsd32_charp path); }
 	COMPAT_13 MODULAR compat_netbsd32_13	\
 		 	{ int|sys||sigpending(void); } sigpending13
 	COMPAT_13 MODULAR compat_netbsd32_13	\
 			{ int|netbsd32||sigaltstack13( \
 			    netbsd32_sigaltstack13p_t nss, \
 			    netbsd32_sigaltstack13p_t oss); }
 	STD		{ int|netbsd32||ioctl(int fd, netbsd32_u_long com, \
 			    ... netbsd32_voidp data); }
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||reboot(int opt); }
 	STD		{ int|netbsd32||revoke(netbsd32_charp path); }
 	STD		{ int|netbsd32||symlink(netbsd32_charp path, \
 			    netbsd32_charp link); }
 	STD		{ int|netbsd32||readlink(netbsd32_charp path, \
 			    netbsd32_charp buf, netbsd32_size_t count); }
 	STD		{ int|netbsd32||execve(netbsd32_charp path, \
 			    netbsd32_charpp argp, netbsd32_charpp envp); }
 	STD		{ mode_t|netbsd32||umask(mode_t newmask); }
 	STD		{ int|netbsd32||chroot(netbsd32_charp path); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||fstat43(int fd, netbsd32_stat43p_t sb); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ogetkerninfo(int op, \
 			    netbsd32_charp where, netbsd32_intp size, \
 			    int arg); }
 	COMPAT_43 MODULAR compat_43	\
 			{ int|sys||getpagesize(void); } ogetpagesize
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||msync(netbsd32_voidp addr, \
 			    netbsd32_size_t len); }
 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
 	NOARGS		{ int|sys||vfork(void); }
 	OBSOL		vread
 	OBSOL		vwrite
 	OBSOL		sbrk
 	OBSOL		sstk
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ommap(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int prot, int flags, int fd, \
 			    netbsd32_long pos); }
 	STD		{ int|netbsd32||ovadvise(int anom); } vadvise
 	STD		{ int|netbsd32||munmap(netbsd32_voidp addr, \
 			    netbsd32_size_t len); }
 	STD		{ int|netbsd32||mprotect(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int prot); }
 	STD		{ int|netbsd32||madvise(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int behav); }
 	OBSOL		vhangup
 	OBSOL		vlimit
 	STD		{ int|netbsd32||mincore(netbsd32_voidp addr, \
 			    netbsd32_size_t len, netbsd32_charp vec); }
 	STD		{ int|netbsd32||getgroups(int gidsetsize, \
 			    netbsd32_gid_tp gidset); }
 	STD		{ int|netbsd32||setgroups(int gidsetsize, \
 			    netbsd32_gid_tp gidset); }
 	NOARGS 		{ int|sys||getpgrp(void); }
 	STD		{ int|netbsd32||setpgid(int pid, int pgid); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||setitimer(int which, \
 			    netbsd32_itimerval50p_t itv, \
 			    netbsd32_itimerval50p_t oitv); }
 	COMPAT_43 MODULAR compat_43	\
 			{ int|sys||wait(void); } owait
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||oswapon(netbsd32_charp name); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||getitimer(int which, \
 			    netbsd32_itimerval50p_t itv); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ogethostname(netbsd32_charp hostname, \
 			    u_int len); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||osethostname(netbsd32_charp hostname, \
 			    u_int len); }
 	COMPAT_43 MODULAR compat_43	\
 			{ int|sys||getdtablesize(void); } ogetdtablesize
 	STD		{ int|netbsd32||dup2(int from, int to); }
 	STD		{ netbsd32_ssize_t|netbsd32||getrandom( \
 			    netbsd32_voidp buf, netbsd32_size_t buflen, \
 			    unsigned int flags); }
 	STD		{ int|netbsd32||fcntl(int fd, int cmd, \
 			    ... netbsd32_voidp arg); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||select(int nd, netbsd32_fd_setp_t in, \
 			    netbsd32_fd_setp_t ou, netbsd32_fd_setp_t ex, \
 			    netbsd32_timeval50p_t tv); }
 	UNIMPL		setdopt
 	STD		{ int|netbsd32||fsync(int fd); }
 	STD		{ int|netbsd32||setpriority(int which, int who, \
 			    int prio); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||socket(int domain, int type, \
 			    int protocol); }
 	STD		{ int|netbsd32||connect(int s, \
 			    netbsd32_sockaddrp_t name, int namelen); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||oaccept(int s, netbsd32_voidp name, \
 			    netbsd32_intp anamelen); }
 	STD		{ int|netbsd32||getpriority(int which, int who); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||osend(int s, netbsd32_voidp buf, \
 			    int len, int flags); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||orecv(int s, netbsd32_voidp buf, \
 			    int len, int flags); }
 	COMPAT_13 MODULAR compat_netbsd32_13	\
 			{ int|netbsd32||sigreturn( \
 			    netbsd32_sigcontextp_t sigcntxp); } sigreturn13
 	STD		{ int|netbsd32||bind(int s, netbsd32_sockaddrp_t name, \
 			    int namelen); }
 	STD		{ int|netbsd32||setsockopt(int s, int level, int name, \
 			    netbsd32_voidp val, int valsize); }
 	STD		{ int|netbsd32||listen(int s, int backlog); }
 	OBSOL		vtimes
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||osigvec(int signum, \
 			    netbsd32_sigvecp_t nsv, netbsd32_sigvecp_t osv); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||sigblock(int mask); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||sigsetmask(int mask); }
 	COMPAT_13 MODULAR compat_netbsd32_13	\
 			{ int|netbsd32||sigsuspend(int mask); } sigsuspend13
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||osigstack(netbsd32_sigstackp_t nss, \
 			    netbsd32_sigstackp_t oss); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||orecvmsg(int s, \
 			    netbsd32_omsghdrp_t msg, int flags); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||osendmsg(int s, netbsd32_voidp msg, \
 			    int flags); }
 	OBSOL		vtrace
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||gettimeofday(netbsd32_timeval50p_t tp, \
 			    netbsd32_timezonep_t tzp); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||getrusage(int who, \
 			    netbsd32_rusage50p_t rusage); }
 	STD		{ int|netbsd32||getsockopt(int s, int level, int name, \
 			    netbsd32_voidp val, netbsd32_intp avalsize); }
 	OBSOL		resuba
 	STD		{ netbsd32_ssize_t|netbsd32||readv(int fd, \
 			    netbsd32_iovecp_t iovp, int iovcnt); }
 	STD		{ netbsd32_ssize_t|netbsd32||writev(int fd, \
 			    netbsd32_iovecp_t iovp, int iovcnt); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||settimeofday(netbsd32_timeval50p_t tv, \
 			    netbsd32_timezonep_t tzp); }
 	STD		{ int|netbsd32||fchown(int fd, uid_t uid, gid_t gid); }
 	STD		{ int|netbsd32||fchmod(int fd, mode_t mode); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||orecvfrom(int s, netbsd32_voidp buf, \
 			    netbsd32_size_t len, int flags, \
 			    netbsd32_voidp from, netbsd32_intp fromlenaddr); }
 	STD		{ int|netbsd32||setreuid(uid_t ruid, uid_t euid); }
 	STD		{ int|netbsd32||setregid(gid_t rgid, gid_t egid); }
 	STD		{ int|netbsd32||rename(netbsd32_charp from, \
 			    netbsd32_charp to); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||otruncate(netbsd32_charp path, \
 			    netbsd32_long length); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||oftruncate(int fd, \
 			    netbsd32_long length); }
 	STD		{ int|netbsd32||flock(int fd, int how); }
 	STD		{ int|netbsd32||mkfifo(netbsd32_charp path, \
 			    mode_t mode); }
 	STD		{ netbsd32_ssize_t|netbsd32||sendto(int s, \
 			    netbsd32_voidp buf, netbsd32_size_t len, \
 			    int flags, netbsd32_sockaddrp_t to, int tolen); }
 	STD		{ int|netbsd32||shutdown(int s, int how); }
 	STD		{ int|netbsd32||socketpair(int domain, int type, \
 			    int protocol, netbsd32_intp rsv); }
 	STD		{ int|netbsd32||mkdir(netbsd32_charp path, \
 			    mode_t mode); }
 	STD		{ int|netbsd32||rmdir(netbsd32_charp path); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||utimes(netbsd32_charp path, \
 			    netbsd32_timeval50p_t tptr); }
 	OBSOL		4.2 sigreturn
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||adjtime(netbsd32_timeval50p_t delta, \
 			    netbsd32_timeval50p_t olddelta); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ogetpeername(int fdes, \
 			    netbsd32_voidp asa, netbsd32_intp alen); }
 	COMPAT_43 MODULAR compat_43	\
 			{ int32_t|sys||gethostid(void); } ogethostid
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||sethostid(int32_t hostid); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ogetrlimit(int which, \
 			    netbsd32_orlimitp_t rlp); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||osetrlimit(int which, \
 			    netbsd32_orlimitp_t rlp); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||killpg(int pgid, int signum); }
 	NOARGS		{ int|sys||setsid(void); }
 	COMPAT_50 MODULAR compat_netbsd32_quota_50	\
 			{ int|netbsd32||quotactl(netbsd32_charp path, int cmd, \
 			    int uid, netbsd32_voidp arg); }
 	EXCL 		compat_netbsd32_quota
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ogetsockname(int fdec, \
 			    netbsd32_voidp asa, netbsd32_intp alen); }
 ; Syscalls 151-180 inclusive are reserved for vendor-specific
 ; system calls.  (This includes various calls added for compatibity
 ; with other Unix variants.)
 ; Some of these calls are now supported by BSD...
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	STD MODULAR compat_netbsd32_nfssrv	\
 			{ int|netbsd32||nfssvc(int flag, netbsd32_voidp argp); }
 	COMPAT_43 MODULAR compat_netbsd32_43	\
 			{ int|netbsd32||ogetdirentries(int fd, \
 			    netbsd32_charp buf, u_int count, \
 			    netbsd32_longp basep); }
 	COMPAT_20 MODULAR compat_netbsd32_20	\
 			{ int|netbsd32||statfs(netbsd32_charp path, \
 			    netbsd32_statfsp_t buf); }
 	COMPAT_20 MODULAR compat_netbsd32_20	\
 			{ int|netbsd32||fstatfs(int fd, \
 			    netbsd32_statfsp_t buf); }
 	UNIMPL
 	UNIMPL
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||getfh(netbsd32_charp fname, \
 			    netbsd32_compat_30_fhandlep_t fhp); }
 	COMPAT_09 MODULAR compat_netbsd32_09	\
 			{ int|netbsd32||ogetdomainname( \
 			    netbsd32_charp domainname, int len); }
 	COMPAT_09 MODULAR compat_netbsd32_09	\
 			{ int|netbsd32||osetdomainname( \
 			    netbsd32_charp domainname, int len); }
 	COMPAT_09 MODULAR compat_netbsd32_09	\
 			{ int|netbsd32||uname(netbsd32_outsnamep_t name); }
 	STD		{ int|netbsd32||sysarch(int op, netbsd32_voidp parms); }
 	STD		{ int|netbsd32||__futex(netbsd32_intp uaddr, int op, \
 			    int val, const netbsd32_timespecp_t timeout, \
 			    netbsd32_intp uaddr2, int val2, int val3); }
 	STD		{ int|netbsd32||__futex_set_robust_list( \
 			    netbsd32_voidp head, netbsd32_size_t len); }
 	STD		{ int|netbsd32||__futex_get_robust_list(lwpid_t lwpid, \
 			    netbsd32_voidp headp, netbsd32_size_tp lenp); }
 	COMPAT_10 MODULAR compat_netbsd32_sysvipc_10	\
 			{ int|netbsd32||semsys(int which, int a2, int a3, \
 			    int a4, int a5); } osemsys
 	COMPAT_10 MODULAR compat_netbsd32_sysvipc_10	\
 			{ int|netbsd32||msgsys(int which, int a2, int a3, \
 			    int a4, int a5, int a6); } omsgsys
 	COMPAT_10 MODULAR compat_netbsd32_sysvipc_10	\
 			{ int|netbsd32||shmsys(int which, int a2, int a3, \
 			    int a4); } oshmsys
 	UNIMPL
 	STD		{ netbsd32_ssize_t|netbsd32||pread(int fd, \
 			    netbsd32_voidp buf, netbsd32_size_t nbyte, \
 			    int PAD, netbsd32_off_t offset); }
 	STD		{ netbsd32_ssize_t|netbsd32||pwrite(int fd, \
 			    netbsd32_voidp buf, netbsd32_size_t nbyte, \
 			    int PAD, netbsd32_off_t offset); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||ntp_gettime( \
 			    netbsd32_ntptimeval50p_t ntvp); }
 #if defined(NTP) || !defined(_KERNEL_OPT)
 	STD		{ int|netbsd32||ntp_adjtime(netbsd32_timexp_t tp); }
 #else
 	EXCL		ntp_adjtime
 #endif
 	STD		{ int|netbsd32||timerfd_create( \
 			    netbsd32_clockid_t clock_id, \
 			    int flags); }
 	STD		{ int|netbsd32||timerfd_settime(int fd, int flags, \
 			    const netbsd32_itimerspecp_t new_value, \
 			    netbsd32_itimerspecp_t old_value); }
 	STD		{ int|netbsd32||timerfd_gettime(int fd, \
 			    netbsd32_itimerspecp_t curr_value); }
 	UNIMPL
 ; Syscalls 180-199 are used by/reserved for BSD
 	STD		{ int|netbsd32||setgid(gid_t gid); }
 	STD		{ int|netbsd32||setegid(gid_t egid); }
 	STD		{ int|netbsd32||seteuid(uid_t euid); }
 	EXCL		netbsd32_lfs_bmapv
 	EXCL		netbsd32_lfs_markv
 	EXCL		netbsd32_lfs_segclean
 	EXCL		netbsd32_lfs_segwait
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||stat12(netbsd32_charp path, \
 			    netbsd32_stat12p_t ub); }
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||fstat12(int fd, netbsd32_stat12p_t sb); }
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||lstat12(netbsd32_charp path, \
 			    netbsd32_stat12p_t ub); }
 	STD		{ netbsd32_long|netbsd32||pathconf(netbsd32_charp path, \
 			    int name); }
 	STD		{ netbsd32_long|netbsd32||fpathconf(int fd, int name); }
 	STD		{ int|netbsd32||getsockopt2(int s, int level, int name, \
 			    netbsd32_voidp val, netbsd32_intp avalsize); }
 	STD		{ int|netbsd32||getrlimit(int which, \
 			    netbsd32_rlimitp_t rlp); }
 	STD		{ int|netbsd32||setrlimit(int which, \
 			    netbsd32_rlimitp_t rlp); }
 	COMPAT_12 MODULAR compat_netbsd32_12	\
 			{ int|netbsd32||getdirentries(int fd, \
 			    netbsd32_charp buf, u_int count, \
 			    netbsd32_longp basep); }
 	STD		{ netbsd32_voidp|netbsd32||mmap(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int prot, int flags, int fd, \
 			    netbsd32_long PAD, netbsd32_off_t pos); }
 	INDIR		{ quad_t|netbsd32||___syscall(quad_t code, \
 			    ... register32_t args[NETBSD32_SYS_MAXSYSARGS]); }
 	STD		{ netbsd32_off_t|netbsd32||lseek(int fd, int PAD, \
 			    netbsd32_off_t offset, int whence); }
 	STD		{ int|netbsd32||truncate(netbsd32_charp path, int PAD, \
 			    netbsd32_off_t length); }
 	STD		{ int|netbsd32||ftruncate(int fd, int PAD, \
 			    netbsd32_off_t length); }
 	STD		{ int|netbsd32||__sysctl(netbsd32_intp name, \
 			    u_int namelen, netbsd32_voidp oldv, \
 			    netbsd32_size_tp oldlenp, netbsd32_voidp newv, \
 			    netbsd32_size_t newlen); }
 	STD		{ int|netbsd32||mlock(netbsd32_voidp addr, \
 			    netbsd32_size_t len); }
 	STD		{ int|netbsd32||munlock(netbsd32_voidp addr, \
 			    netbsd32_size_t len); }
 	STD		{ int|netbsd32||undelete(netbsd32_charp path); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||futimes(int fd, \
 			    netbsd32_timeval50p_t tptr); }
 	STD		{ int|netbsd32||getpgid(pid_t pid); }
 	STD		{ int|netbsd32||reboot(int opt, \
 			    netbsd32_charp bootstr); }
 	STD		{ int|netbsd32||poll(netbsd32_pollfdp_t fds, \
 			    u_int nfds, int timeout); }
 	UNIMPL		{ int|netbsd32||afssys(long id, long a1, long a2, \
 			    long a3, long a4, long a5, long a6); }
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 ; System calls 220-300 are reserved for use by NetBSD
 	COMPAT_14 MODULAR compat_netbsd32_sysvipc_14	\
 			{ int|netbsd32||__semctl(int semid, int semnum, \
 			    int cmd, netbsd32_semunu_t arg); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||semget(netbsd32_key_t key, int nsems, \
 			    int semflg); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||semop(int semid, \
 			    netbsd32_sembufp_t sops, netbsd32_size_t nsops); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||semconfig(int flag); }
 	COMPAT_14 MODULAR compat_netbsd32_sysvipc_14	\
 			{ int|netbsd32||msgctl(int msqid, int cmd, \
 			    netbsd32_msqid_ds14p_t buf); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||msgget(netbsd32_key_t key, int msgflg); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||msgsnd(int msqid, netbsd32_voidp msgp, \
 			    netbsd32_size_t msgsz, int msgflg); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ netbsd32_ssize_t|netbsd32||msgrcv(int msqid, \
 			    netbsd32_voidp msgp, netbsd32_size_t msgsz, \
 			    netbsd32_long msgtyp, int msgflg); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ netbsd32_voidp|netbsd32||shmat(int shmid, \
 			    netbsd32_voidp shmaddr, int shmflg); }
 	COMPAT_14 MODULAR compat_netbsd32_sysvipc_14	\
 			{ int|netbsd32||shmctl(int shmid, int cmd, \
 			    netbsd32_shmid_dsp_t buf); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||shmdt(netbsd32_voidp shmaddr); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 			{ int|netbsd32||shmget(netbsd32_key_t key, \
 			    netbsd32_size_t size, int shmflg); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||clock_gettime( \
 			    netbsd32_clockid_t clock_id, \
 			    netbsd32_timespec50p_t tp); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||clock_settime( \
 			    netbsd32_clockid_t clock_id, \
 			    netbsd32_timespec50p_t tp); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||clock_getres( \
 			    netbsd32_clockid_t clock_id, \
 			    netbsd32_timespec50p_t tp); }
 	STD		{ int|netbsd32||timer_create( \
 			    netbsd32_clockid_t clock_id, \
 			    netbsd32_sigeventp_t evp, \
 			    netbsd32_timerp_t timerid); }
 	STD		{ int|netbsd32||timer_delete(netbsd32_timer_t timerid); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||timer_settime(netbsd32_timer_t timerid, \
 			    int flags, \
 			    netbsd32_itimerspec50p_t value, \
 			    netbsd32_itimerspec50p_t ovalue); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||timer_gettime(netbsd32_timer_t timerid, \
 			    netbsd32_itimerspec50p_t value); }
 	STD		{ int|netbsd32||timer_getoverrun( \
 			    netbsd32_timer_t timerid); }
+;
 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
+;
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||nanosleep(netbsd32_timespec50p_t rqtp, \
 			    netbsd32_timespec50p_t rmtp); }
 	STD		{ int|netbsd32||fdatasync(int fd); }
 	STD		{ int|netbsd32||mlockall(int flags); }
 	NOARGS		{ int|sys||munlockall(void); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||__sigtimedwait(netbsd32_sigsetp_t set, \
 			    netbsd32_siginfop_t info, \
 			    netbsd32_timespec50p_t timeout); }
 	STD		{ int|netbsd32||sigqueueinfo(pid_t pid, \
 			    const netbsd32_siginfop_t info); }
 	STD		{ int|netbsd32||modctl(int cmd, netbsd32_voidp arg); }
 	STD		{ int|netbsd32||_ksem_init(unsigned int value, \
 			    netbsd32_semidp_t idp); }
 	STD		{ int|netbsd32||_ksem_open(netbsd32_charp name, \
 			    int oflag, mode_t mode, unsigned int value, \
 			    netbsd32_semidp_t idp); }
 	STD		{ int|netbsd32||_ksem_unlink(netbsd32_charp name); }
 	STD		{ int|netbsd32||_ksem_close(netbsd32_intptr_t id); }
 	STD		{ int|netbsd32||_ksem_post(netbsd32_intptr_t id); }
 	STD		{ int|netbsd32||_ksem_wait(netbsd32_intptr_t id); }
 	STD		{ int|netbsd32||_ksem_trywait(netbsd32_intptr_t id); }
 	STD		{ int|netbsd32||_ksem_getvalue(netbsd32_intptr_t id, \
 			    netbsd32_intp value); }
 	STD		{ int|netbsd32||_ksem_destroy(netbsd32_intptr_t id); }
 	STD		{ int|netbsd32||_ksem_timedwait(intptr_t id, \
 				const netbsd32_timespecp_t abstime); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ mqd_t|netbsd32||mq_open(const netbsd32_charp name, \
 			    int oflag, mode_t mode, \
 			    netbsd32_mq_attrp_t attr); }
 	STD MODULAR compat_netbsd32_mqueue	\
 	 		{ int|netbsd32||mq_close(mqd_t mqdes); }
 	STD MODULAR compat_netbsd32_mqueue	\
 	 		{ int|netbsd32||mq_unlink(const netbsd32_charp name); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ int|netbsd32||mq_getattr(mqd_t mqdes, \
 			    netbsd32_mq_attrp_t mqstat); }
 	STD MODULAR compat_netbsd32_mqueue	\
 	 		{ int|netbsd32||mq_setattr(mqd_t mqdes, \
 			    const netbsd32_mq_attrp_t mqstat, \
 			    netbsd32_mq_attrp_t omqstat); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ int|netbsd32||mq_notify(mqd_t mqdes, \
 			    const netbsd32_sigeventp_t notification); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ int|netbsd32||mq_send(mqd_t mqdes, \
 			    const netbsd32_charp msg_ptr, \
 			    netbsd32_size_t msg_len, unsigned msg_prio); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ netbsd32_ssize_t|netbsd32||mq_receive(mqd_t mqdes, \
 			    netbsd32_charp msg_ptr, \
 			    netbsd32_size_t msg_len, netbsd32_uintp msg_prio); }
 	COMPAT_50 MODULAR compat_netbsd32_mqueue	\
 			{ int|netbsd32||mq_timedsend(mqd_t mqdes, \
 			    const netbsd32_charp msg_ptr, \
 			    netbsd32_size_t msg_len, \
 			    unsigned msg_prio, \
 			    const netbsd32_timespec50p_t abs_timeout); }
 	COMPAT_50 MODULAR compat_netbsd32_mqueue	\
 			{ netbsd32_ssize_t|netbsd32||mq_timedreceive( \
 			    mqd_t mqdes, \
 			    netbsd32_charp msg_ptr, netbsd32_size_t msg_len, \
 			    netbsd32_uintp msg_prio, \
 			    const netbsd32_timespec50p_t abs_timeout); }
 	STD		{ int|netbsd32||eventfd(unsigned int val, int flags); }
 	UNIMPL
 	UNIMPL
 	STD		{ int|netbsd32||__posix_rename(netbsd32_charp from, \
 			    netbsd32_charp to); }
 	STD		{ int|netbsd32||swapctl(int cmd, netbsd32_voidp arg, \
 			    int misc); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||getdents(int fd, netbsd32_charp buf, \
 			    netbsd32_size_t count); }
 	STD		{ int|netbsd32||minherit(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int inherit); }
 	STD		{ int|netbsd32||lchmod(netbsd32_charp path, \
 			    mode_t mode); }
 	STD		{ int|netbsd32||lchown(netbsd32_charp path, uid_t uid, \
 			    gid_t gid); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||lutimes(netbsd32_charp path, \
 			    netbsd32_timeval50p_t tptr); }
 	STD		{ int|netbsd32|13|msync(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int flags); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32|13|stat(netbsd32_charp path, \
 			    netbsd32_stat13p_t ub); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32|13|fstat(int fd, \
 			    netbsd32_stat13p_t sb); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32|13|lstat(netbsd32_charp path, \
 			    netbsd32_stat13p_t ub); }
 	STD		{ int|netbsd32|14|sigaltstack(\
 			    netbsd32_sigaltstackp_t nss, \
 			    netbsd32_sigaltstackp_t oss); }
 	NOARGS		{ int|sys|14|vfork(void); }
 	STD		{ int|netbsd32||__posix_chown(netbsd32_charp path, \
 			    uid_t uid, gid_t gid); }
 	STD		{ int|netbsd32||__posix_fchown(int fd, uid_t uid, \
 			    gid_t gid); }
 	STD		{ int|netbsd32||__posix_lchown(netbsd32_charp path, \
 			    uid_t uid, gid_t gid); }
 	STD		{ pid_t|netbsd32||getsid(pid_t pid); }
 	STD		{ int|netbsd32||__clone(int flags, \
 			    netbsd32_voidp stack); }
 	STD		{ int|netbsd32||fktrace(int fd, int ops, int facs, \
 			    int pid); }
 	STD		{ netbsd32_ssize_t|netbsd32||preadv(int fd, \
 			    netbsd32_iovecp_t iovp, int iovcnt, int PAD, \
 			    netbsd32_off_t offset); }
 	STD		{ netbsd32_ssize_t|netbsd32||pwritev(int fd, \
 			    netbsd32_iovecp_t iovp, int iovcnt, int PAD, \
 			    netbsd32_off_t offset); }
 	STD		{ int|netbsd32|14|sigaction(int signum, \
 			    netbsd32_sigactionp_t nsa, \
 			    netbsd32_sigactionp_t osa); }
 	STD		{ int|netbsd32|14|sigpending(netbsd32_sigsetp_t set); }
 	STD		{ int|netbsd32|14|sigprocmask(int how, \
 			    netbsd32_sigsetp_t set, \
 			    netbsd32_sigsetp_t oset); }
 	STD		{ int|netbsd32|14|sigsuspend(netbsd32_sigsetp_t set); }
 	COMPAT_16 MODULAR compat_netbsd32_16	\
 			{ int|netbsd32|14|sigreturn( \
 			    netbsd32_sigcontextp_t sigcntxp); }
 	STD		{ int|netbsd32||__getcwd(netbsd32_charp bufp, \
 			    netbsd32_size_t length); }
 	STD		{ int|netbsd32||fchroot(int fd); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||fhopen(netbsd32_fhandlep_t fhp, \
 			   int flags); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||fhstat(netbsd32_fhandlep_t fhp, \
 			    netbsd32_stat13p_t sb); }
 	COMPAT_20 MODULAR compat_netbsd32_20	\
 			{ int|netbsd32||fhstatfs(netbsd32_fhandlep_t fhp, \
 			    netbsd32_stat50p_t buf); }
 	COMPAT_50 MODULAR compat_netbsd32_sysvipc_50	\
 			{ int|netbsd32|14|semctl(int semid, int semnum, \
 			    int cmd, ... netbsd32_semun50p_t arg); }
 	COMPAT_50 MODULAR compat_netbsd32_sysvipc_50	\
 			{ int|netbsd32|13|msgctl(int msqid, int cmd, \
 			    netbsd32_msqid_ds50p_t buf); }
 	COMPAT_50 MODULAR compat_netbsd32_sysvipc_50	\
 			{ int|netbsd32|13|shmctl(int shmid, int cmd, \
 			    netbsd32_shmid_ds50p_t buf); }
 	STD		{ int|netbsd32||lchflags(netbsd32_charp path, \
 			    netbsd32_u_long flags); }
 	NOARGS 		{ int|sys||issetugid(void); }
 	STD		{ int|netbsd32||utrace(netbsd32_charp label, \
 			    netbsd32_voidp addr, netbsd32_size_t len); }
 	STD		{ int|netbsd32||getcontext(netbsd32_ucontextp ucp); }
 	STD		{ int|netbsd32||setcontext(netbsd32_ucontextp ucp); }
 	STD		{ int|netbsd32||_lwp_create(netbsd32_ucontextp ucp, \
 			    netbsd32_u_long flags, netbsd32_lwpidp new_lwp); }
 	NOARGS		{ int|sys||_lwp_exit(void); }
 	NOARGS 		{ lwpid_t|sys||_lwp_self(void); }
 	STD 		{ int|netbsd32||_lwp_wait(lwpid_t wait_for, \
 			    netbsd32_lwpidp departed); }
 	STD 		{ int|netbsd32||_lwp_suspend(lwpid_t target); }
 	STD 		{ int|netbsd32||_lwp_continue(lwpid_t target); }
 	STD 		{ int|netbsd32||_lwp_wakeup(lwpid_t target); }
 	NOARGS 		{ netbsd32_voidp|sys||_lwp_getprivate(void); }
 	STD 		{ void|netbsd32||_lwp_setprivate(netbsd32_voidp ptr); }
 	STD		{ int|netbsd32||_lwp_kill(lwpid_t target, int signo); }
 	STD 		{ int|netbsd32||_lwp_detach(lwpid_t target); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||_lwp_park(netbsd32_timespec50p_t ts, \
 			    lwpid_t unpark, netbsd32_voidp hint, \
 			    netbsd32_voidp unparkhint); }
 	STD 		{ int|netbsd32||_lwp_unpark(lwpid_t target, \
 			    netbsd32_voidp hint); }
 	STD 		{ netbsd32_size_t|netbsd32||_lwp_unpark_all( \
 			    netbsd32_lwpidp targets, netbsd32_size_t ntargets, \
 			    netbsd32_voidp hint); }
 	STD		{ int|netbsd32||_lwp_setname(lwpid_t target, \
 				netbsd32_charp name); }
 	STD		{ int|netbsd32||_lwp_getname(lwpid_t target, \
 				netbsd32_charp name, netbsd32_size_t len); }
 	STD 		{ int|netbsd32||_lwp_ctl(int features, \
 				netbsd32_pointer_t address); }
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	OBSOL		netbsd32_sa_register
 	OBSOL		netbsd32_sa_stacks
 	OBSOL		sa_enable
 	OBSOL		netbsd32_sa_setconcurrency
 	OBSOL		sa_yield
 	OBSOL		netbsd32_sa_preempt
 	OBSOL		sys_sa_unblockyield
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	STD		{ int|netbsd32||__sigaction_sigtramp(int signum, \
 			    netbsd32_sigactionp_t nsa, \
 			    netbsd32_sigactionp_t osa, \
 			    netbsd32_voidp tramp, int vers); }
 	OBSOL		netbsd32_pmc_get_info
 	OBSOL		netbsd32_pmc_control
 	STD		{ int|netbsd32||rasctl(netbsd32_voidp addr, \
 			    netbsd32_size_t len, int op); }
 	NOARGS		{ int|sys||kqueue(void); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||kevent(int fd, \
 			    netbsd32_kevent100p_t changelist, \
 			    netbsd32_size_t nchanges, \
 			    netbsd32_kevent100p_t eventlist, \
 			    netbsd32_size_t nevents, \
 			    netbsd32_timespec50p_t timeout); }
 ; Scheduling system calls.
 	STD 		{ int|netbsd32||_sched_setparam(pid_t pid, lwpid_t lid, \
 			    int policy, const netbsd32_sched_paramp_t params); }
 	STD 		{ int|netbsd32||_sched_getparam(pid_t pid, lwpid_t lid, \
 			    netbsd32_intp policy, \
 			    netbsd32_sched_paramp_t params); }
 	STD 		{ int|netbsd32||_sched_setaffinity(pid_t pid, \
 			    lwpid_t lid, netbsd32_size_t size, \
 			    const netbsd32_cpusetp_t cpuset); }
 	STD 		{ int|netbsd32||_sched_getaffinity(pid_t pid, \
 			    lwpid_t lid, netbsd32_size_t size, \
 			    netbsd32_cpusetp_t cpuset); }
 	NOARGS 		{ int|sys||sched_yield(void); }
 	STD		{ int|netbsd32||_sched_protect(int priority); }
 	UNIMPL
 	UNIMPL
 	STD		{ int|netbsd32||fsync_range(int fd, int flags, \
 			    netbsd32_off_t start, netbsd32_off_t length); }
 	STD		{ int|netbsd32||uuidgen(netbsd32_uuidp_t store, \
 			    int count); }
 	COMPAT_90 MODULAR compat_netbsd32_90 \
 			{ int|netbsd32||getvfsstat(netbsd32_statvfs90p_t buf, \
 			    netbsd32_size_t bufsize, int flags); }
 	COMPAT_90 MODULAR compat_netbsd32_90 \
 			{ int|netbsd32||statvfs1(netbsd32_charp path, \
 			    netbsd32_statvfs90p_t buf, int flags); }
 	COMPAT_90 MODULAR compat_netbsd32_90 \
 			{ int|netbsd32||fstatvfs1(int fd, \
 			    netbsd32_statvfs90p_t buf, int flags); }
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32||fhstatvfs1(netbsd32_fhandlep_t fhp, \
 			    netbsd32_statvfs90p_t buf, int flags); }
 	STD		{ int|netbsd32||extattrctl(netbsd32_charp path, \
 			    int cmd, netbsd32_charp filename, \
 			    int attrnamespace, netbsd32_charp attrname); }
 	STD		{ int|netbsd32||extattr_set_file(netbsd32_charp path, \
 			    int attrnamespace, netbsd32_charp attrname, \
 			    netbsd32_voidp data, netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_get_file(netbsd32_charp path, \
 			    int attrnamespace, netbsd32_charp attrname, \
 			    netbsd32_voidp data, netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_delete_file( \
 			    netbsd32_charp path, int attrnamespace, \
 			    netbsd32_charp attrname); }
 	STD		{ int|netbsd32||extattr_set_fd(int fd, \
 			    int attrnamespace, netbsd32_charp attrname, \
 			    netbsd32_voidp data, netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_get_fd(int fd, \
 			    int attrnamespace, netbsd32_charp attrname, \
 			    netbsd32_voidp data, netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_delete_fd(int fd, \
 			    int attrnamespace, netbsd32_charp attrname); }
 	STD		{ int|netbsd32||extattr_set_link(netbsd32_charp path, \
 			    int attrnamespace, netbsd32_charp attrname, \
 			    netbsd32_voidp data, netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_get_link(netbsd32_charp path, \
 			    int attrnamespace, netbsd32_charp attrname, \
 			    netbsd32_voidp data, netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_delete_link( \
 			    netbsd32_charp path, int attrnamespace, \
 			    netbsd32_charp attrname); }
 	STD		{ int|netbsd32||extattr_list_fd(int fd, \
 			    int attrnamespace, netbsd32_voidp data, \
 			    netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_list_file(netbsd32_charp path, \
 			    int attrnamespace, netbsd32_voidp data, \
 			    netbsd32_size_t nbytes); }
 	STD		{ int|netbsd32||extattr_list_link(netbsd32_charp path, \
 			    int attrnamespace, netbsd32_voidp data, \
 			    netbsd32_size_t nbytes); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||pselect(int nd, netbsd32_fd_setp_t in, \
 			    netbsd32_fd_setp_t ou, netbsd32_fd_setp_t ex, \
 			    netbsd32_timespec50p_t ts, \
 			    netbsd32_sigsetp_t mask); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||pollts(netbsd32_pollfdp_t fds, \
 			    u_int nfds, netbsd32_timespec50p_t ts, \
 			    netbsd32_sigsetp_t mask); }
 	STD		{ int|netbsd32||setxattr(netbsd32_charp path, \
 			    netbsd32_charp name, netbsd32_voidp value, \
 			    netbsd32_size_t size, int flags); }
 	STD		{ int|netbsd32||lsetxattr(netbsd32_charp path, \
 			    netbsd32_charp name, netbsd32_voidp value, \
 			    netbsd32_size_t size, int flags); }
 	STD		{ int|netbsd32||fsetxattr(int fd, \
 			    netbsd32_charp name, netbsd32_voidp value, \
 			    netbsd32_size_t size, int flags); }
 	STD		{ int|netbsd32||getxattr(netbsd32_charp path, \
 			    netbsd32_charp name, netbsd32_voidp value, \
 			    netbsd32_size_t size); }
 	STD		{ int|netbsd32||lgetxattr(netbsd32_charp path, \
 			    netbsd32_charp name, netbsd32_voidp value, \
 			    netbsd32_size_t size); }
 	STD		{ int|netbsd32||fgetxattr(int fd, \
 			    netbsd32_charp name, netbsd32_voidp value, \
 			    netbsd32_size_t size); }
 	STD		{ int|netbsd32||listxattr(netbsd32_charp path, \
 			    netbsd32_charp list, netbsd32_size_t size); }
 	STD		{ int|netbsd32||llistxattr(netbsd32_charp path, \
 			    netbsd32_charp list, netbsd32_size_t size); }
 	STD		{ int|netbsd32||flistxattr(int fd, \
 			    netbsd32_charp list, netbsd32_size_t size); }
 	STD		{ int|netbsd32||removexattr(netbsd32_charp path, \
 			    netbsd32_charp name); }
 	STD		{ int|netbsd32||lremovexattr(netbsd32_charp path, \
 			    netbsd32_charp name); }
 	STD		{ int|netbsd32||fremovexattr(int fd, \
 			    netbsd32_charp name); }
 COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32|30|stat(netbsd32_charp path, \
 			    netbsd32_stat50p_t ub); }
 COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32|30|fstat(int fd, \
 			    netbsd32_stat50p_t sb); }
 COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32|30|lstat( \
 			    netbsd32_charp path, netbsd32_stat50p_t ub); }
 STD             { int|netbsd32|30|getdents(int fd, \
 			    netbsd32_charp buf, netbsd32_size_t count); }
 	IGNORED		old posix fadvise
 	COMPAT_30 MODULAR compat_netbsd32_30	\
 			{ int|netbsd32|30|fhstat( \
 			    netbsd32_fhandlep_t fhp, \
 			    netbsd32_stat50p_t sb); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32||ntp_gettime( \
 			    netbsd32_ntptimeval50p_t ntvp); }
 	STD		{ int|netbsd32|30|socket(int domain, int type, \
 			    int protocol); }
 	STD		{ int|netbsd32|30|getfh(netbsd32_charp fname, \
 			    netbsd32_pointer_t fhp, netbsd32_size_tp fh_size); }
 	STD		{ int|netbsd32|40|fhopen(netbsd32_pointer_t fhp, \
 			    netbsd32_size_t fh_size, int flags); }
 	COMPAT_90 MODULAR compat_netbsd90 \
 			{ int|netbsd32||fhstatvfs1(	\
 			    netbsd32_pointer_t fhp, netbsd32_size_t fh_size,\
 			    netbsd32_statvfs90p_t buf, int flags); }
 	COMPAT_50 MODULAR compat_netbsd32_50	\
 			{ int|netbsd32|40|fhstat(	\
 			    netbsd32_pointer_t fhp, netbsd32_size_t fh_size,\
 			    netbsd32_stat50p_t sb); }
 ; Asynchronous I/O system calls
 	UNIMPL		sys_aio_cancel
 	UNIMPL		sys_aio_error
 	UNIMPL		sys_aio_fsync
 	UNIMPL		sys_aio_read
 	UNIMPL		sys_aio_return
 	UNIMPL		sys_aio_suspend
 UNIMPL		sys_aio_write
 	UNIMPL		sys_lio_listio
 	UNIMPL
 	UNIMPL
 	UNIMPL
 	STD		{ int|netbsd32||__mount50(netbsd32_charp type, \
 			    netbsd32_charp path, int flags, \
 			    netbsd32_voidp data, netbsd32_size_t data_len); }
 	STD 		{ netbsd32_voidp|netbsd32||mremap( \
 			    netbsd32_voidp old_address, \
 			    netbsd32_size_t old_size, \
 			    netbsd32_voidp new_address, \
 			    netbsd32_size_t new_size, int flags); }
 	STD		{ int|netbsd32||pset_create(netbsd32_psetidp_t psid); }
 	STD		{ int|netbsd32||pset_destroy(psetid_t psid); }
 	STD		{ int|netbsd32||pset_assign(psetid_t psid, \
 			  cpuid_t cpuid, netbsd32_psetidp_t opsid); }
 	STD		{ int|netbsd32||_pset_bind(idtype_t idtype, \
 			  id_t first_id, id_t second_id, psetid_t psid, \
 			  netbsd32_psetidp_t opsid); }
 	STD 		{ int|netbsd32|50|posix_fadvise(int fd, int PAD, \
 			    netbsd32_off_t offset, netbsd32_off_t len, int advice); }
 	STD 		{ int|netbsd32|50|select(int nd, \
 			    netbsd32_fd_setp_t in,  netbsd32_fd_setp_t ou, \
 			    netbsd32_fd_setp_t ex, netbsd32_timevalp_t tv); }
 	STD 		{ int|netbsd32|50|gettimeofday( \
 			    netbsd32_timevalp_t tp, netbsd32_voidp tzp); }
 	STD 		{ int|netbsd32|50|settimeofday( \
 			    const netbsd32_timevalp_t tv, \
 			    const netbsd32_voidp tzp); }
 	STD  		{ int|netbsd32|50|utimes(const netbsd32_charp path, \
 			    const netbsd32_timevalp_t tptr); }
 	STD		{ int|netbsd32|50|adjtime( \
 			    const netbsd32_timevalp_t delta, \
 			    netbsd32_timevalp_t olddelta); }
 	EXCL		__lfs_segwait50
 	STD 		{ int|netbsd32|50|futimes(int fd, \
 			    const netbsd32_timevalp_t tptr); }
 	STD  		{ int|netbsd32|50|lutimes(const netbsd32_charp path, \
 			    const netbsd32_timevalp_t tptr); }
 	STD		{ int|netbsd32|50|setitimer(int which, \
 			    const netbsd32_itimervalp_t itv, \
 			    netbsd32_itimervalp_t oitv); }
 	STD		{ int|netbsd32|50|getitimer(int which, \
 			    netbsd32_itimervalp_t itv); }
 	STD 		{ int|netbsd32|50|clock_gettime(clockid_t clock_id, \
 			    netbsd32_timespecp_t tp); }
 	STD 		{ int|netbsd32|50|clock_settime(clockid_t clock_id, \
 			    const netbsd32_timespecp_t tp); }
 	STD 		{ int|netbsd32|50|clock_getres(clockid_t clock_id, \
 			    netbsd32_timespecp_t tp); }
 	STD 		{ int|netbsd32|50|nanosleep( \
 			    const netbsd32_timespecp_t rqtp, \
 			    netbsd32_timespecp_t rmtp); }
 	STD 		{ int|netbsd32|50|__sigtimedwait( \
 			    const netbsd32_sigsetp_t set, \
 			    netbsd32_siginfop_t info, \
 			    netbsd32_timespecp_t timeout); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ int|netbsd32|50|mq_timedsend(mqd_t mqdes, \
 			    const netbsd32_charp msg_ptr, \
 			    netbsd32_size_t msg_len, \
 			    unsigned msg_prio, \
 			    const netbsd32_timespecp_t abs_timeout); }
 	STD MODULAR compat_netbsd32_mqueue	\
 			{ netbsd32_ssize_t|netbsd32|50|mq_timedreceive( \
 			    mqd_t mqdes, netbsd32_charp msg_ptr, \
 			    netbsd32_size_t msg_len, netbsd32_uintp msg_prio, \
 			    const netbsd32_timespecp_t abs_timeout); }
 	COMPAT_60 MODULAR compat_netbsd32_60	\
 		 	{ int|netbsd32||_lwp_park( \
 			    const netbsd32_timespecp_t ts, \
 			    lwpid_t unpark, const netbsd32_voidp hint, \
 			    const netbsd32_voidp unparkhint); }
 	COMPAT_100 MODULAR compat_netbsd32_100	\
 			{ int|netbsd32|50|kevent(int fd, \
 			    const netbsd32_kevent100p_t changelist, \
 			    netbsd32_size_t nchanges, \
 			    netbsd32_kevent100p_t eventlist, \
 			    netbsd32_size_t nevents, \
 			    const netbsd32_timespecp_t timeout); }
 	STD 		{ int|netbsd32|50|pselect(int nd, \
 			    netbsd32_fd_setp_t in, \
 			    netbsd32_fd_setp_t ou, \
 			    netbsd32_fd_setp_t ex, \
 			    const netbsd32_timespecp_t ts, \
 			    const netbsd32_sigsetp_t mask); }
 	STD 		{ int|netbsd32|50|pollts(netbsd32_pollfdp_t fds, \
 			    u_int nfds, const netbsd32_timespecp_t ts, \
 			    const netbsd32_sigsetp_t mask); }
 	UNIMPL 		netbsd32___aio_suspend50
 	STD 		{ int|netbsd32|50|stat(const netbsd32_charp path, \
 			    netbsd32_statp_t ub); }
 	STD 		{ int|netbsd32|50|fstat(int fd, netbsd32_statp_t sb); }
 	STD 		{ int|netbsd32|50|lstat(const netbsd32_charp path, \
 			    netbsd32_statp_t ub); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 	 		{ int|netbsd32|50|__semctl(int semid, int semnum, \
 			    int cmd, ... netbsd32_semunp_t arg); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 	 		{ int|netbsd32|50|shmctl(int shmid, int cmd, \
 			    netbsd32_shmid_dsp_t buf); }
 	STD MODULAR compat_netbsd32_sysvipc	\
 	 		{ int|netbsd32|50|msgctl(int msqid, int cmd, \
 			    netbsd32_msqid_dsp_t buf); }
 	STD 		{ int|netbsd32|50|getrusage(int who, \
 			    netbsd32_rusagep_t rusage); }
 	STD		{ int|netbsd32|50|timer_settime(timer_t timerid, \
 			    int flags, const netbsd32_itimerspecp_t value, \
 			    netbsd32_itimerspecp_t ovalue); }
 	STD		{ int|netbsd32|50|timer_gettime(timer_t timerid, \
 			    netbsd32_itimerspecp_t value); }
 #if defined(NTP) || !defined(_KERNEL_OPT)
 	STD		{ int|netbsd32|50|ntp_gettime( \
 			    netbsd32_ntptimevalp_t ntvp); }
 #else
 	EXCL		___ntp_gettime50
 #endif
 	STD 		{ int|netbsd32|50|wait4(int pid, \
 			    netbsd32_intp status, \
 			    int options, netbsd32_rusagep_t rusage); }
 	STD 		{ int|netbsd32|50|mknod(const netbsd32_charp path, \
 			    mode_t mode, netbsd32_dev_t dev); }
 	STD	 	{ int|netbsd32|50|fhstat(const netbsd32_voidp fhp, \
 			    netbsd32_size_t fh_size, netbsd32_statp_t sb); }
 	OBSOL		5.99 quotactl
 	STD		{ int|netbsd32||pipe2(netbsd32_intp fildes, int flags); }
 	STD		{ int|netbsd32||dup3(int from, int to, int flags); }
 	STD		{ int|netbsd32||kqueue1(int flags); }
 	STD  		{ int|netbsd32||paccept(int s, \
 			    netbsd32_sockaddrp_t name, \
 			    netbsd32_socklenp_t anamelen, \
 			    const netbsd32_sigsetp_t mask, \
 			    int flags); }
 	STD  		{ int|netbsd32||linkat(int fd1, \
 			    const netbsd32_charp name1, \
 			    int fd2, \
 			    const netbsd32_charp name2, \
 			    int flags); }
 	STD  		{ int|netbsd32||renameat(int fromfd, \
 			    const netbsd32_charp from, \
 			    int tofd, \
 			    const netbsd32_charp to); }
 	STD  		{ int|netbsd32||mkfifoat(int fd, \
 			    const netbsd32_charp path, \
 			    mode_t mode); }
 	STD  		{ int|netbsd32||mknodat(int fd, \
 			    const netbsd32_charp path, \
 			    mode_t mode, int PAD, \
 			    netbsd32_dev_t dev); }
 	STD  		{ int|netbsd32||mkdirat(int fd, \
 			    const netbsd32_charp path, \
 			    mode_t mode); }
 	STD  		{ int|netbsd32||faccessat(int fd, \
 			    const netbsd32_charp path, \
 			    int amode, \
 			    int flag); }
 	STD  		{ int|netbsd32||fchmodat(int fd, \
 			    const netbsd32_charp path, \
 			    mode_t mode, \
 			    int flag); }
 	STD  		{ int|netbsd32||fchownat(int fd, \
 			    const netbsd32_charp path, \
 			    uid_t owner, \
 			    gid_t group, \
 			    int flag); }
 	STD  		{ int|netbsd32||fexecve(int fd, \
 			    netbsd32_charpp argp, \
 			    netbsd32_charpp envp); }
 	STD  		{ int|netbsd32||fstatat(int fd, \
 			    const netbsd32_charp path, \
 			    netbsd32_statp_t buf, \
 			    int flag); }
 	STD  		{ int|netbsd32||utimensat(int fd, \
 			    const netbsd32_charp path, \
 			    const netbsd32_timespecp_t tptr, \
 			    int flag); }
 	STD  		{ int|netbsd32||openat(int fd, \
 			    const netbsd32_charp path, \
 			    int oflags, ... \
 			    mode_t mode); }
 	STD  		{ netbsd32_ssize_t|netbsd32||readlinkat(int fd, \
 			    const netbsd32_charp path, \
 			    netbsd32_charp buf, \
 			    netbsd32_size_t bufsize); }
 	STD  		{ int|netbsd32||symlinkat(const netbsd32_charp path1, \
 			    int fd, \
 			    const netbsd32_charp path2); }
 	STD  		{ int|netbsd32||unlinkat(int fd, \
 			    const netbsd32_charp path, \
 			    int flag); }
 	STD  		{ int|netbsd32||futimens(int fd, \
 			    const netbsd32_timespecp_t tptr); }
 	STD MODULAR compat_netbsd32_quota	\
 			{ int|netbsd32||__quotactl(const netbsd32_charp path, \
 			    netbsd32_voidp args); }
 	NOERR		{ int|netbsd32||posix_spawn(netbsd32_pid_tp pid, \
 			    const netbsd32_charp path, \
 			    const netbsd32_posix_spawn_file_actionsp \
 				file_actions, \
 			    const netbsd32_posix_spawnattrp attrp, \
 			    netbsd32_charpp argv, netbsd32_charpp envp); }
 	STD		{ int|netbsd32||recvmmsg(int s, \
 			    netbsd32_mmsghdrp_t mmsg, \
 			    unsigned int vlen, unsigned int flags, \
 			    netbsd32_timespecp_t timeout); }
 	STD		{ int|netbsd32||sendmmsg(int s, \
 			    netbsd32_mmsghdrp_t mmsg, \
 			    unsigned int vlen, unsigned int flags); }
 	STD 		{ int|netbsd32||clock_nanosleep(\
 			    netbsd32_clockid_t clock_id, \
 			    int flags, const netbsd32_timespecp_t rqtp, \
 			    netbsd32_timespecp_t rmtp); }
 	STD 		{ int|netbsd32|60|_lwp_park(\
 			    netbsd32_clockid_t clock_id, \
 			    int flags, netbsd32_timespecp_t ts, \
 			    lwpid_t unpark, netbsd32_voidp hint, \
 			    netbsd32_voidp unparkhint); }
 	NOERR		{ int|netbsd32||posix_fallocate(int fd, int PAD, \
 			    netbsd32_off_t pos, netbsd32_off_t len); }
 	STD		{ int|netbsd32||fdiscard(int fd, int PAD, \
 			    netbsd32_off_t pos, netbsd32_off_t len); }
 	STD 		{ int|netbsd32||wait6(idtype_t idtype, id_t id, \
 			    netbsd32_intp status, int options, \
 			    netbsd32_wrusagep_t wru, netbsd32_siginfop_t info); }
 	STD		{ int|netbsd32||clock_getcpuclockid2(idtype_t idtype, \
 			    id_t id, netbsd32_clockidp_t clock_id); }
 	STD 		{ int|netbsd32|90|getvfsstat( \
 			    netbsd32_statvfsp_t buf, \
 			    netbsd32_size_t bufsize, int flags); }
 	STD 		{ int|netbsd32|90|statvfs1(netbsd32_charp path, \
 			    netbsd32_statvfsp_t buf, int flags); }
 	STD 		{ int|netbsd32|90|fstatvfs1(int fd, \
 			    netbsd32_statvfsp_t buf, int flags); }
 	STD 		{ int|netbsd32|90|fhstatvfs1(netbsd32_voidp fhp, \
 			    netbsd32_size_t fh_size, netbsd32_statvfsp_t buf, \
 			    int flags); }
 	STD		{ int|netbsd32||__acl_get_link( \
 			    const netbsd32_charp path, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_set_link( \
 			    const netbsd32_charp path, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_delete_link( \
 			    const netbsd32_charp path, \
 			    acl_type_t type); }
 	STD		{ int|netbsd32||__acl_aclcheck_link( \
 			    const netbsd32_charp path, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_get_file( \
 			    const netbsd32_charp path, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_set_file( \
 			    const netbsd32_charp path, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_get_fd(int filedes, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_set_fd(int filedes, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_delete_file( \
 			    const netbsd32_charp path, \
 			    acl_type_t type); }
 	STD		{ int|netbsd32||__acl_delete_fd(int filedes, \
 			    acl_type_t type); }
 	STD		{ int|netbsd32||__acl_aclcheck_file( \
 			    const netbsd32_charp path, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ int|netbsd32||__acl_aclcheck_fd(int filedes, \
 			    acl_type_t type, netbsd32_aclp_t aclp); }
 	STD		{ long|netbsd32||lpathconf(const netbsd32_charp path, \
 			    int name); }
-	UNIMPL		memfd_create
+	STD		{ int|netbsd32||memfd_create( \
 			    const netbsd32_charp name, unsigned int flags); }
 	STD		{ int|netbsd32|100|kevent(int fd, \
 			    const netbsd32_keventp_t changelist, \
 			    netbsd32_size_t nchanges, \
 			    netbsd32_keventp_t eventlist, \
 			    netbsd32_size_t nevents, \
 			    const netbsd32_timespecp_t timeout); }
 	UNIMPL		epoll_create1
 	UNIMPL		epoll_ctl
 	UNIMPL		epoll_pwait2