 @@ -1,587 +1,591 @@
-	$NetBSD: syscalls.master,v 1.71.2.2 2020/12/17 03:05:32 thorpej Exp $
+	$NetBSD: syscalls.master,v 1.71.2.3 2021/01/03 16:12:43 thorpej Exp $
 ; NetBSD i386 COMPAT_LINUX32 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, NODEF, NOARGS, or one of
 ;		the compatibility options defined in syscalls.conf.
+;
 ; types:
 ;	STD	always included
 ;	OBSOL	obsolete, not included in system
 ;	UNIMPL	unimplemented, not included in system
 ;	NODEF	included, but don't define the syscall number
+;
 ;	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.
 #include <sys/param.h>
 #include <sys/poll.h>
 #include <sys/systm.h>
 #include <sys/signal.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 #include <machine/netbsd32_machdep.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_syscallargs.h>
 #include <compat/linux/common/linux_types.h>
 #include <compat/linux32/common/linux32_types.h>
 #include <compat/linux32/common/linux32_signal.h>
 #include <compat/linux32/arch/amd64/linux32_missing.h>
 #include <compat/linux32/linux32_syscallargs.h>
 #include <compat/linux/common/linux_mmap.h>
 #include <compat/linux/common/linux_signal.h>
 #include <compat/linux/common/linux_siginfo.h>
 #include <compat/linux/common/linux_machdep.h>
 #include <compat/linux/common/linux_ipc.h>
 #include <compat/linux/common/linux_sem.h>
 #include <compat/linux/linux_syscallargs.h>
 %%
 	NOARGS	{ int|linux_sys||nosys(void); } syscall
 	STD	{ int|linux32_sys||exit(int rval); }
 	NOARGS	{ int|sys||fork(void); }
 	NOARGS	{ netbsd32_ssize_t|netbsd32||read(int fd, \
 		    netbsd32_voidp buf, netbsd32_size_t nbyte); }
 	NOARGS	{ netbsd32_ssize_t|netbsd32||write(int fd, \
 		    netbsd32_voidp buf, netbsd32_size_t nbyte); }
 	STD	{ int|linux32_sys||open(netbsd32_charp path, int flags, \
 		    linux_umode_t mode); }
 	NOARGS	{ int|netbsd32||close(int fd); }
 	STD	{ int|linux32_sys||waitpid(int pid, netbsd32_intp status, \
 		    int options);}
 	STD	{ int|linux32_sys||creat(netbsd32_charp path, linux_umode_t mode); }
 	NOARGS	{ int|netbsd32||link(netbsd32_charp path, \
 		    netbsd32_charp link); }
 	STD	{ int|linux32_sys||unlink(netbsd32_charp path); }
 	NOARGS	{ int|netbsd32||execve(netbsd32_charp path, \
 		    netbsd32_charpp argp, netbsd32_charpp envp); }
 	NOARGS	{ int|netbsd32||chdir(netbsd32_charp path); }
 	STD	{ int|linux32_sys||time(linux32_timep_t t); }
 	STD	{ int|linux32_sys||mknod(netbsd32_charp path, \
 		    linux_umode_t mode, unsigned dev); }
 	NOARGS	{ int|netbsd32||chmod(netbsd32_charp path, linux_umode_t mode); }
 	STD	{ int|linux32_sys||lchown16(netbsd32_charp path, \
 		    linux32_uid16_t uid, linux32_gid16_t gid); }
 	STD	{ int|linux32_sys||break(netbsd32_charp nsize); }
 	OBSOL	ostat
 	NOARGS	{ netbsd32_long|compat_43_netbsd32||olseek(int fd, \
 		    netbsd32_long offset, int whence); }
 	NOARGS 	{ pid_t|sys||getpid(void); }
 	UNIMPL	mount
 	UNIMPL	umount
 	NOARGS	linux_setuid16 { int|netbsd32||setuid(uid_t uid); }
 	NOARGS	linux_getuid16 { uid_t|sys||getuid(void); }
 	STD	{ int|linux32_sys||stime(linux32_timep_t t); }
 	STD	{ int|linux32_sys||ptrace(int request, int pid, \
 		  int addr, int data); }
 	STD	{ int|linux32_sys||alarm(unsigned int secs); }
 	OBSOL	ofstat
 	NOARGS	{ int|linux_sys||pause(void); }
 	STD	{ int|linux32_sys||utime(netbsd32_charp path, \
 		    linux32_utimbufp_t times); }
 	OBSOL	stty
 	OBSOL	gtty
 	NOARGS	{ int|netbsd32||access(netbsd32_charp path, \
 		    int flags); }
 	STD	{ int|linux32_sys||nice(int incr); }
 	OBSOL	ftime
 	NOARGS	{ int|sys||sync(void); }
 	STD	{ int|linux32_sys||kill(int pid, int signum); }
 	NOARGS	{ int|netbsd32||__posix_rename(netbsd32_charp from, \
 		    netbsd32_charp to); }
 	NOARGS	{ int|netbsd32||mkdir(netbsd32_charp path, linux_umode_t mode); }
 	NOARGS	{ int|netbsd32||rmdir(netbsd32_charp path); }
 	NOARGS	{ int|netbsd32||dup(int fd); }
 	STD	{ int|linux32_sys||pipe(netbsd32_intp fd); }
 	STD	{ int|linux32_sys||times(linux32_tmsp_t tms); }
 	OBSOL	prof
 	STD	{ int|linux32_sys||brk(netbsd32_charp nsize); }
 	NOARGS	linux_setgid16 { int|netbsd32||setgid(gid_t gid); }
 	NOARGS	linux_getgid16 { gid_t|sys||getgid(void); }
 	STD	{ int|linux32_sys||signal(int signum, \
 		    linux32_handlerp_t handler); }
 	NOARGS	linux_geteuid16 { uid_t|sys||geteuid(void); }
 	NOARGS	linux_getegid16 { gid_t|sys||getegid(void); }
 	NOARGS	{ int|netbsd32||acct(netbsd32_charp path); }
 	OBSOL	phys
 	OBSOL	lock
 	STD	{ int|linux32_sys||ioctl(int fd, netbsd32_u_long com, \
 		    netbsd32_charp data); }
 	STD	{ int|linux32_sys||fcntl(int fd, \
 		    int cmd, netbsd32_voidp arg); }
 	OBSOL	mpx
 	NOARGS	{ int|netbsd32||setpgid(int pid, int pgid); }
 	OBSOL	ulimit
 	STD	{ int|linux32_sys||oldolduname( \
 		    linux32_oldold_utsnamep_t up); }
 	NOARGS	{ int|netbsd32||umask(int newmask); }
 	NOARGS	{ int|netbsd32||chroot(netbsd32_charp path); }
 	UNIMPL	ustat
 	NOARGS	{ int|netbsd32||dup2(int from, int to); }
 	NOARGS	{ pid_t|sys||getppid(void); }
 	NOARGS	{ int|sys||getpgrp(void); }
 	NOARGS	{ int|sys||setsid(void); }
 	UNIMPL	sigaction
 	STD	{ int|linux32_sys||siggetmask(void); }
 	STD	{ int|linux32_sys||sigsetmask(linux32_old_sigset_t mask); }
 	STD	{ int|linux32_sys||setreuid16(linux32_uid16_t ruid, \
 		    linux32_uid16_t euid); }
 	STD	{ int|linux32_sys||setregid16(linux32_gid16_t rgid, \
 		    linux32_gid16_t egid); }
 	UNIMPL	sigsuspend
 	UNIMPL	sigpending
 	NOARGS	{ int|compat_43_netbsd32||osethostname(netbsd32_charp hostname, \
 		    u_int len); }
 	STD	{ int|linux32_sys||setrlimit(u_int which, \
 		    netbsd32_orlimitp_t rlp); }
 	STD	{ int|linux32_sys||getrlimit(u_int which, \
 		    netbsd32_orlimitp_t rlp); }
 	NOARGS	{ int|compat_50_netbsd32||getrusage(int who, \
 		    netbsd32_rusage50p_t rusage); }
 	STD	{ int|linux32_sys||gettimeofday(netbsd32_timeval50p_t tp, \
 		    netbsd32_timezonep_t tzp); }
 	STD	{ int|linux32_sys||settimeofday(netbsd32_timeval50p_t tp, \
 		    netbsd32_timezonep_t tzp); }
 	STD	{ int|linux32_sys||getgroups16(int gidsetsize, \
 		    linux32_gid16p_t gidset); }
 	STD	{ int|linux32_sys||setgroups16(int gidsetsize, \
 		    linux32_gid16p_t gidset); }
 	STD	{ int|linux32_sys||oldselect(linux32_oldselectp_t lsp); }
 	NOARGS	{ int|netbsd32||symlink(netbsd32_charp path, \
 		    netbsd32_charp link); }
 	NOARGS	{ int|compat_43_netbsd32||lstat43(netbsd32_charp \
 		    path, netbsd32_stat43p_t ub); }
 	NOARGS	{ int|netbsd32||readlink(netbsd32_charp path, \
 		    netbsd32_charp buf, netbsd32_size_t count); }
 	UNIMPL	uselib
 	STD	{ int|linux32_sys||swapon(netbsd32_charp name); }
 	STD	{ int|linux32_sys||reboot(int magic1, int magic2, int cmd, \
 		    netbsd32_voidp arg); }
 	STD	{ int|linux32_sys||readdir(int fd, netbsd32_voidp dent, \
 		    unsigned int count); }
 	STD	{ int|linux32_sys||old_mmap(linux32_oldmmapp lmp); }
 	NOARGS	{ int|netbsd32||munmap(netbsd32_voidp addr, \
 		    netbsd32_size_t len); }
 	NOARGS	{ int|compat_43_netbsd32||otruncate(netbsd32_charp path, \
 		    netbsd32_long length); }
 	NOARGS	{ int|compat_43_netbsd32||oftruncate(int fd, \
 		    netbsd32_long length); }
 	NOARGS	{ int|netbsd32||fchmod(int fd, linux_umode_t mode); }
 	STD	{ int|linux32_sys||fchown16(int fd, linux32_uid16_t uid, \
 		    linux32_gid16_t gid); }
 	STD	{ int|linux32_sys||getpriority(int which, int who); }
 	NOARGS	{ int|netbsd32||setpriority(int which, int who, int prio); }
 	NOARGS	{ int|netbsd32||profil(netbsd32_voidp samples, \
 		    netbsd32_size_t size, netbsd32_u_long offset, \
 		    u_int scale); }
 	STD	{ int|linux32_sys||statfs(netbsd32_charp path, \
 		    linux32_statfsp sp); }
 	STD	{ int|linux32_sys||fstatfs(int fd, linux32_statfsp sp); }
 	NOARGS	{ int|linux_sys||ioperm(unsigned int lo, \
 		    unsigned int hi, int val); }
 	STD	{ int|linux32_sys||socketcall(int what, netbsd32_voidp args); }
 	UNIMPL	syslog
 	NOARGS	{ int|compat_50_netbsd32||setitimer(int which, \
 		    netbsd32_itimerval50p_t itv, netbsd32_itimerval50p_t oitv); }
 	NOARGS	{ int|compat_50_netbsd32||getitimer(int which, \
 		    netbsd32_itimerval50p_t itv); }
 	STD	{ int|linux32_sys||stat(netbsd32_charp path, \
 		    linux32_statp sp); }
 	STD	{ int|linux32_sys||lstat(netbsd32_charp path, \
 		    linux32_statp sp); }
 	STD	{ int|linux32_sys||fstat(int fd, \
 		    linux32_statp sp); }
 	STD	{ int|linux32_sys||olduname(linux32_oldutsnamep_t up); }
 	NOARGS	{ int|linux_sys||iopl(int level); }
 	UNIMPL	vhangup
 	UNIMPL	idle
 	UNIMPL	vm86old
 	STD	{ int|linux32_sys||wait4(int pid, netbsd32_intp status, \
 		    int options, netbsd32_rusage50p_t rusage); }
 	STD	{ int|linux32_sys||swapoff(netbsd32_charp path); }
 	STD	{ int|linux32_sys||sysinfo(linux32_sysinfop_t arg); }
 	STD	{ int|linux32_sys||ipc(int what, int a1, int a2, int a3, \
 		    netbsd32_voidp ptr); }
 	NOARGS	{ int|netbsd32||fsync(int fd); }
 	STD	{ int|linux32_sys||sigreturn(linux32_sigcontextp_t scp); }
 	STD	{ int|linux32_sys||clone(int flags, netbsd32_voidp stack, \
 		    netbsd32_voidp parent_tidptr, netbsd32_voidp tls, \
 		    netbsd32_voidp child_tidptr); }
 	STD	{ int|linux32_sys||setdomainname(netbsd32_charp domainname, \
 		    int len); }
 	STD	{ int|linux32_sys||uname(linux32_utsnamep up); }
 	STD	{ int|linux32_sys||modify_ldt(int func, netbsd32_charp ptr, \
 		    netbsd32_size_t bytecount); }
 	UNIMPL	adjtimex
 	STD	{ int|linux32_sys||mprotect(netbsd32_voidp start, \
 		    netbsd32_size_t len, int prot); }
 	UNIMPL	sigprocmask
 	UNIMPL	create_module
 	UNIMPL	init_module
 	UNIMPL	delete_module
 	UNIMPL	get_kernel_syms
 	UNIMPL	quotactl
 	NOARGS	{ int|netbsd32||getpgid(pid_t pid); }
 	NOARGS	{ int|netbsd32||fchdir(int fd); }
 	UNIMPL	bdflush
 	UNIMPL	sysfs
 	STD	{ int|linux32_sys||personality(netbsd32_u_long per); }
 	UNIMPL	afs_syscall
 	NOARGS	setfsuid16 { int|linux32_sys||setfsuid(uid_t uid); }
 	NOARGS	setfsgid16 { int|linux32_sys||setfsgid(gid_t gid); }
 	STD	{ int|linux32_sys||llseek(int fd, u_int32_t ohigh, \
 		    u_int32_t olow, netbsd32_voidp res, int whence); }
 	STD	{ int|linux32_sys||getdents(int fd, \
 		    linux32_direntp_t dent, unsigned int count); }
 	STD	{ int|linux32_sys||select(int nfds, \
 		    netbsd32_fd_setp_t readfds, \
 		    netbsd32_fd_setp_t writefds, \
 		    netbsd32_fd_setp_t exceptfds, \
 		    netbsd32_timeval50p_t timeout); }
 	NOARGS	{ int|netbsd32||flock(int fd, int how); }
 	NOARGS	{ int|netbsd32|13|msync(netbsd32_voidp addr, \
 		    netbsd32_size_t len, int flags); }
 	NOARGS	{ int|netbsd32||readv(int fd, \
 		    netbsd32_iovecp_t iovp, int iovcnt); }
 	NOARGS	{ netbsd32_ssize_t|netbsd32||writev(int fd, \
 		    netbsd32_iovecp_t iovp, int iovcnt); }
 	NOARGS	{ pid_t|netbsd32||getsid(pid_t pid); }
 	STD	{ int|linux32_sys||fdatasync(int fd); }
 	STD	{ int|linux32_sys||__sysctl(linux32___sysctlp_t lsp); }
 	NOARGS	{ int|netbsd32||mlock(netbsd32_voidp addr, \
 		    netbsd32_size_t len); }
 	NOARGS	{ int|netbsd32||munlock(netbsd32_voidp addr, \
 		    netbsd32_size_t len); }
 	NOARGS	{ int|netbsd32||mlockall(int flags); }
 	NOARGS	{ int|sys||munlockall(void); }
 	STD	{ int|linux32_sys||sched_setparam(pid_t pid, \
 		    const linux32_sched_paramp_t sp); }
 	STD	{ int|linux32_sys||sched_getparam(pid_t pid, \
 		    linux32_sched_paramp_t sp); }
 	STD	{ int|linux32_sys||sched_setscheduler(pid_t pid, \
 		    int policy, linux32_sched_paramp_t sp); }
 	STD	{ int|linux32_sys||sched_getscheduler(pid_t pid); }
 	NOARGS	{ int|linux_sys||sched_yield(void); }
 	STD	{ int|linux32_sys||sched_get_priority_max(int policy); }
 	STD	{ int|linux32_sys||sched_get_priority_min(int policy); }
 	UNIMPL	sched_rr_get_interval
 	STD	{ int|linux32_sys||nanosleep(linux32_timespecp_t rqtp, \
 		    linux32_timespecp_t rmtp); }
 	STD	{ int|linux32_sys||mremap(netbsd32_voidp old_address, \
 		    netbsd32_size_t old_size, netbsd32_size_t new_size, \
 		    netbsd32_u_long flags); }
 	STD	{ int|linux32_sys||setresuid16(linux32_uid16_t ruid, \
 		    linux32_uid16_t euid, linux32_uid16_t suid); }
 	STD	{ int|linux32_sys||getresuid16(linux32_uid16p_t ruid, \
 		    linux32_uid16p_t euid, linux32_uid16p_t suid); }
 	UNIMPL	vm86
 	UNIMPL	query_module
 	NOARGS	{ int|netbsd32||poll(netbsd32_pollfdp_t fds, u_int nfds, \
 		    int timeout); }
 	UNIMPL	nfsservctl
 	STD	{ int|linux32_sys||setresgid16(linux32_gid16_t rgid, \
 		    linux32_gid16_t egid, linux32_gid16_t sgid); }
 	STD	{ int|linux32_sys||getresgid16(linux32_gid16p_t rgid, \
 		    linux32_gid16p_t egid, linux32_gid16p_t sgid); }
 	UNIMPL	prctl
 	STD	{ int|linux32_sys||rt_sigreturn(linux32_ucontextp_t ucp); }
 	STD	{ int|linux32_sys||rt_sigaction(int signum, \
 		    linux32_sigactionp_t nsa, \
 		    linux32_sigactionp_t osa, \
 		    netbsd32_size_t sigsetsize); }
 	STD	{ int|linux32_sys||rt_sigprocmask(int how, \
 		     linux32_sigsetp_t set, \
 		     linux32_sigsetp_t oset, \
 		     netbsd32_size_t sigsetsize); }
 	STD	{ int|linux32_sys||rt_sigpending(linux32_sigsetp_t set, \
 		    netbsd32_size_t sigsetsize); }
 	STD	{ int|linux32_sys||rt_sigtimedwait( \
 		    const linux32_sigsetp_t set, \
 		    linux32_siginfop_t info, \
 		    const linux32_timespecp_t timeout); }
 	STD	{ int|linux32_sys||rt_queueinfo(int pid, int sig, \
 		    linux32_siginfop_t uinfo); }
 	STD	{ int|linux32_sys||rt_sigsuspend(linux32_sigsetp_t unewset, \
 		    netbsd32_size_t sigsetsize); }
 	STD	{ netbsd32_ssize_t|linux32_sys||pread(int fd, \
 		    netbsd32_voidp buf, netbsd32_size_t nbyte, \
 		    netbsd32_off_t offset); }
 	STD	{ netbsd32_ssize_t|linux32_sys||pwrite(int fd, \
 		    netbsd32_voidp buf, netbsd32_size_t nbyte, \
 		    netbsd32_off_t offset); }
 	STD	{ int|linux32_sys||chown16(netbsd32_charp path, \
 		    linux32_uid16_t uid, linux32_gid16_t gid); }
 	NOARGS	{ int|netbsd32||__getcwd(netbsd32_charp bufp, \
 		    netbsd32_size_t length); }
 	UNIMPL	capget
 	UNIMPL	capset
 	UNIMPL	sigaltstack
 	UNIMPL	sendfile
 	UNIMPL	getpmsg
 	UNIMPL	putpmsg
 	NOARGS	{ int|sys|14|vfork(void); }
 	STD	{ int|linux32_sys||ugetrlimit(int which, \
 		    netbsd32_orlimitp_t rlp); }
 	STD	{ linux32_off_t|linux32_sys||mmap2(netbsd32_u_long addr, \
 		    netbsd32_size_t len, int prot, int flags, int fd, \
 		    linux32_off_t offset); }
 	STD	{ int|linux32_sys||truncate64(netbsd32_charp path, \
 		    uint32_t lenlo, uint32_t lenhi); }
 	STD	{ int|linux32_sys||ftruncate64(unsigned int fd, \
 		    uint32_t lenlo, uint32_t lenhi); }
 	STD	{ int|linux32_sys||stat64(netbsd32_charp path, \
 		    linux32_stat64p sp); }
 	STD	{ int|linux32_sys||lstat64(netbsd32_charp path, \
 		    linux32_stat64p sp); }
 	STD	{ int|linux32_sys||fstat64(int fd, \
 		    linux32_stat64p sp); }
 	NOARGS	{ int|netbsd32||__posix_lchown(netbsd32_charp path, \
 		    uid_t uid, gid_t gid); }
 	NOARGS	{ uid_t|sys||getuid(void); }
 	NOARGS	{ gid_t|sys||getgid(void); }
 	NOARGS	{ uid_t|sys||geteuid(void); }
 	NOARGS	{ gid_t|sys||getegid(void); }
 	NOARGS	{ int|netbsd32||setreuid(uid_t ruid, uid_t euid); }
 	NOARGS	{ int|netbsd32||setregid(gid_t rgid, gid_t egid); }
 	NOARGS	{ int|netbsd32||getgroups(int gidsetsize, \
 		    netbsd32_gid_tp gidset); }
 	NOARGS	{ int|netbsd32||setgroups(int gidsetsize, \
 		    netbsd32_gid_tp gidset); }
 	NOARGS	{ int|netbsd32||__posix_fchown(int fd, uid_t uid, gid_t gid); }
 	STD	{ int|linux32_sys||setresuid(uid_t ruid, uid_t euid, \
 		    uid_t suid); }
 	STD	{ int|linux32_sys||getresuid(linux32_uidp_t ruid, \
 		    linux32_uidp_t euid, linux32_uidp_t suid); }
 	STD	{ int|linux32_sys||setresgid(gid_t rgid, gid_t egid, \
 		    gid_t sgid); }
 	STD	{ int|linux32_sys||getresgid(linux32_gidp_t rgid, \
 		    linux32_gidp_t egid, linux32_gidp_t sgid); }
 	NOARGS	{ int|netbsd32||__posix_chown(netbsd32_charp path, \
 		    uid_t uid, gid_t gid); }
 	NOARGS	{ int|netbsd32||setuid(uid_t uid); }
 	NOARGS	{ int|netbsd32||setgid(gid_t gid); }
 	STD	{ int|linux32_sys||setfsuid(uid_t uid); }
 	STD	{ int|linux32_sys||setfsgid(gid_t gid); }
 	UNIMPL	pivot_root
 	NOARGS	{ int|netbsd32||mincore(netbsd32_voidp addr, \
 		    netbsd32_size_t len, netbsd32_charp vec); }
 	NOARGS	{ int|netbsd32||madvise(netbsd32_voidp addr, \
 		    netbsd32_size_t len, int behav); }
 	STD	{ int|linux32_sys||getdents64(int fd, \
 		    linux32_dirent64p_t dent, unsigned int count); }
 ; fcntl64() - Exactly the same as fcntl()
 #define linux32_sys_fcntl64 linux32_sys_fcntl
 #define linux32_sys_fcntl64_args linux32_sys_fcntl_args
 	NOARGS	{ int|linux32_sys||fcntl64(int fd, \
 		    int cmd, netbsd32_voidp arg); }
 	UNIMPL	/*	unused	*/
 	UNIMPL	/*	unused	*/
 	NOARGS	{ pid_t|linux_sys||gettid(void); }
 	UNIMPL	readahead
 	NOARGS	{ int|netbsd32||setxattr(netbsd32_charp path, \
 		    netbsd32_charp name, netbsd32_voidp value, \
 		    netbsd32_size_t size, int flags); }
 	NOARGS	{ int|netbsd32||lsetxattr(netbsd32_charp path, \
 		    netbsd32_charp name,  netbsd32_voidp value, \
 		    netbsd32_size_t size, int flags); }
 	NOARGS	{ int|netbsd32||fsetxattr(int fd, netbsd32_charp name, \
 		    netbsd32_voidp value, netbsd32_size_t size, int flags); }
 	NOARGS	{ ssize_t|netbsd32||getxattr(netbsd32_charp path, \
 		    netbsd32_charp name, netbsd32_voidp value, \
 		    netbsd32_size_t size); }
 	NOARGS	{ ssize_t|netbsd32||lgetxattr(netbsd32_charp path, \
 		    netbsd32_charp name, netbsd32_voidp value, \
 		    netbsd32_size_t size); }
 	NOARGS	{ ssize_t|netbsd32||fgetxattr(int fd, netbsd32_charp name, \
 		    netbsd32_voidp value, netbsd32_size_t size); }
 	NOARGS	{ ssize_t|netbsd32||listxattr(netbsd32_charp path, \
 		    netbsd32_charp list, netbsd32_size_t size); }
 	NOARGS	{ ssize_t|netbsd32||llistxattr(netbsd32_charp path, \
 		    netbsd32_charp list, netbsd32_size_t size); }
 	NOARGS	{ ssize_t|netbsd32||flistxattr(int fd, netbsd32_charp list, \
 		    netbsd32_size_t size); }
 	NOARGS	{ int|netbsd32||removexattr(netbsd32_charp path, \
 		    netbsd32_charp name); }
 	NOARGS	{ int|netbsd32||lremovexattr(netbsd32_charp path, \
 		    netbsd32_charp name); }
 	NOARGS	{ int|netbsd32||fremovexattr(int fd, netbsd32_charp name); }
 	STD	{ int|linux32_sys||tkill(int tid, int sig); }
 	UNIMPL	sendfile64
 	STD	{ int|linux32_sys||futex(linux32_intp_t uaddr, int op, int val, \
 		    linux32_timespecp_t timeout, linux32_intp_t uaddr2, \
 		    int val3); }
 	STD	{ int|linux32_sys||sched_setaffinity(pid_t pid, \
 		    unsigned int len, linux32_ulongp_t mask); }
 	STD	{ int|linux32_sys||sched_getaffinity(pid_t pid, \
 		    unsigned int len, linux32_ulongp_t mask); }
 	STD	{ int|linux32_sys||set_thread_area(linux32_user_descp_t desc); }
 	STD	{ int|linux32_sys||get_thread_area(linux32_user_descp_t desc); }
 	UNIMPL	io_setup
 	UNIMPL	io_destroy
 	UNIMPL	io_getevents
 	UNIMPL	io_submit
 	UNIMPL	io_cancel
 	STD	{ int|linux32_sys||fadvise64(int fd, uint32_t offlo, \
 		    uint32_t offhi, linux32_size_t len, int advice); }
 	UNIMPL	/*	unused	*/
 	STD	{ int|linux32_sys||exit_group(int error_code); }
 	UNIMPL	lookup_dcookie
 	UNIMPL	epoll_create
 	UNIMPL	epoll_ctl
 	UNIMPL	epoll_wait
 	UNIMPL	remap_file_pages
 	STD	{ int|linux32_sys||set_tid_address(linux32_intp_t tid); }
 	STD	{ int|linux32_sys||timer_create(clockid_t clockid, \
 		    struct linux32_sigevent *evp, timer_t *timerid); }
 	STD	{ int|linux32_sys||timer_settime(timer_t timerid, \
 		    int flags, const struct linux32_itimerspec *tim, \
 		    struct linux32_itimerspec *otim); }
 	STD	{ int|linux32_sys||timer_gettime(timer_t timerid, \
 		    struct linux32_itimerspec *tim); }
 	NOARGS	{ int|sys||timer_getoverrun(timer_t timerid); }
 	NOARGS	{ int|sys||timer_delete(timer_t timerid); }
 	STD	{ int|linux32_sys||clock_settime(clockid_t which, \
 		    linux32_timespecp_t tp); }
 	STD	{ int|linux32_sys||clock_gettime(clockid_t which, \
 		    linux32_timespecp_t tp); }
 	STD	{ int|linux32_sys||clock_getres(clockid_t which, \
 		    linux32_timespecp_t tp); }
 	STD	{ int|linux32_sys||clock_nanosleep(clockid_t which, int flags, \
 		    linux32_timespecp_t rqtp, linux32_timespecp_t rmtp); }
 	STD	{ int|linux32_sys||statfs64(netbsd32_charp path, \
 		    netbsd32_size_t sz, linux32_statfs64p sp); }
 	STD	{ int|linux32_sys||fstatfs64(int fd, \
 		    netbsd32_size_t sz, linux32_statfs64p sp); }
 	STD	{ int|linux32_sys||tgkill(int tgid, int tid, int sig); }
 	NOARGS	{ int|compat_50_netbsd32||utimes(netbsd32_charp path, \
 		    netbsd32_timeval50p_t tptr); }
 	STD	{ int|linux32_sys||fadvise64_64(int fd, uint32_t offlo, \
 		    uint32_t offhi, uint32_t lenlo, uint32_t lenhi, int advice); }
 	UNIMPL	vserver
 	UNIMPL	mbind
 	UNIMPL	get_mempolicy
 	UNIMPL	set_mempolicy
 	UNIMPL	mq_open
 	UNIMPL	mq_unlink
 	UNIMPL	mq_timedsend
 	UNIMPL	mq_timedreceive
 	UNIMPL	mq_notify
 	UNIMPL	mq_getsetattr
 	UNIMPL	kexec_load
 	UNIMPL	waitid
 	UNIMPL	/* unused */
 	UNIMPL	add_key
 	UNIMPL	request_key
 	UNIMPL	keyctl
 	UNIMPL	ioprio_set
 	UNIMPL	ioprio_get
 	UNIMPL	inotify_init
 	UNIMPL	inotify_add_watch
 	UNIMPL	inotify_rm_watch
 	UNIMPL	migrate_pages
 	STD	{ int|linux32_sys||openat(int fd, netbsd32_charp path, \
 		    int flags, ... linux_umode_t mode); }
 	NOARGS	{ int|netbsd32||mkdirat(int fd, netbsd32_charp path, \
 		    linux_umode_t mode); }
 	STD	{ int|linux32_sys||mknodat(int fd, netbsd32_charp path, \
 		    linux_umode_t mode, unsigned dev); }
 	STD	{ int|linux32_sys||fchownat(int fd, netbsd32_charp path, \
 		    uid_t owner, gid_t group, int flag); }
 	UNIMPL	futimesat
 	STD	{ int|linux32_sys||fstatat64(int fd, netbsd32_charp path, \
 		    linux32_stat64p sp, int flag); }
 	STD	{ int|linux32_sys||unlinkat(int fd, netbsd32_charp path, \
 		    int flag); }
 	NOARGS	{ int|netbsd32||renameat(int fromfd, netbsd32_charp from, \
 		    int tofd, netbsd32_charp to); }
 	STD	{ int|linux32_sys||linkat(int fd1, netbsd32_charp name1, \
 		    int fd2, netbsd32_charp name2, int flags); }
 	NOARGS	{ int|netbsd32||symlinkat(netbsd32_charp path1, int fd, \
 		    netbsd32_charp path2); }
 	NOARGS	{ int|netbsd32||readlinkat(int fd, netbsd32_charp path, \
 		    netbsd32_charp buf, linux32_size_t bufsize); }
 	STD	{ int|linux32_sys||fchmodat(int fd, netbsd32_charp path, \
 		    linux_umode_t mode); }
 	STD	{ int|linux32_sys||faccessat(int fd, netbsd32_charp path, \
 		    int amode); }
 	UNIMPL	pselect6
 	STD	{ int|linux32_sys||ppoll(netbsd32_pollfdp_t fds, u_int nfds, \
 		    linux32_timespecp_t timeout, linux32_sigsetp_t sigset); }
 	UNIMPL	unshare
+		;
 		; The netbsd32 native robust list calls have different
 		; argument names / types, but they are ABI-compatible
 		; with linux32.
+		;
 	NOARGS	{ int|netbsd32||__futex_set_robust_list( \
 		    netbsd32_voidp head, netbsd32_size_t len); }
 	NOARGS	{ int|netbsd32||__futex_get_robust_list(lwpid_t lwpid, \
 		    netbsd32_voidp headp, netbsd32_size_tp lenp); }
 	UNIMPL	splice
 	UNIMPL	sync_file_range
 	UNIMPL	tee
 	UNIMPL	vmsplice
 	UNIMPL	move_pages
 	UNIMPL	getcpu
 	UNIMPL	epoll_wait
 	STD	{ int|linux32_sys||utimensat(int fd, netbsd32_charp path, \
 			    linux32_timespecp_t times, int flag); }
 	UNIMPL	signalfd
 	NOARGS	{ int|linux_sys||timerfd_create(clockid_t clock_id, \
 		    int flags); }
 	STD	{ int|linux32_sys||eventfd(unsigned int initval); }
 	STD	{ int|linux32_sys||fallocate(int fd, int mode, \
 			    off_t offset, off_t len); }
 	STD	{ int|linux32_sys||timerfd_settime(int fd, int flags, \
 		    const struct linux32_itimerspec *new_value, \
 		    struct linux32_itimerspec *old_value); }
 	STD	{ int|linux32_sys||timerfd_gettime(int fd, \
 		    struct linux32_itimerspec *curr_value); }
 	UNIMPL	signalfd4
 	STD	{ int|linux32_sys||eventfd2(unsigned int initval, \
 		    int flags); }
 	UNIMPL	epoll_create1
 	STD	{ int|linux32_sys||dup3(int from, int to, int flags); }
 STD	{ int|linux32_sys||pipe2(netbsd32_intp fd, int flags); }
 	UNIMPL	inotify_init1
-	UNIMPL	preadv
+	STD	{ int|linux32_sys||preadv(int fd, \
-	UNIMPL	pwritev
+		    const netbsd32_iovecp_t iovp, int iovcnt, \
 		    netbsd32_u_long off_lo, netbsd32_u_long off_hi); }
 	STD	{ int|linux32_sys||pwritev(int fd, \
 		    const netbsd32_iovecp_t iovp, int iovcnt, \
 		    netbsd32_u_long off_lo, netbsd32_u_long off_hi); }
 	UNIMPL	rt_tgsigqueueinfo
 	UNIMPL	perf_counter_open
 	UNIMPL	recvmmsg
 	UNIMPL	fanotify_init
 	UNIMPL	fanotify_mark
 	UNIMPL	prlimit64
 	UNIMPL	name_to_handle_at
 	UNIMPL	open_by_handle_at
 	UNIMPL	clock_adjtime
 	UNIMPL	syncfs
 	UNIMPL	sendmmsg
 	UNIMPL	setns
 	UNIMPL	process_vm_readv
 	UNIMPL	process_vm_writev
 	UNIMPL	kcmp
 	UNIMPL	finit_module

 @@ -1,382 +1,432 @@
-/*	$NetBSD: linux32_misc.c,v 1.30.2.2 2020/12/17 03:02:06 thorpej Exp $	*/
+/*	$NetBSD: linux32_misc.c,v 1.30.2.3 2021/01/03 16:12:44 thorpej Exp $	*/
 /*-
  * Copyright (c) 1995, 1998, 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
  * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center;
  * by Edgar Fu\ss, Mathematisches Institut der Uni Bonn.
+ *
  * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: linux32_misc.c,v 1.30.2.2 2020/12/17 03:02:06 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux32_misc.c,v 1.30.2.3 2021/01/03 16:12:44 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/fstypes.h>
 #include <sys/vfs_syscalls.h>
 #include <sys/ptrace.h>
 #include <sys/syscall.h>
 #include <sys/poll.h>
 #include <sys/futex.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_syscallargs.h>
 #include <compat/linux/common/linux_types.h>
 #include <compat/linux32/common/linux32_types.h>
 #include <compat/linux32/common/linux32_signal.h>
 #include <compat/linux32/common/linux32_sched.h>
 #include <compat/linux32/linux32_syscallargs.h>
 #include <compat/linux/common/linux_ptrace.h>
 #include <compat/linux/common/linux_emuldata.h>
 #include <compat/linux/common/linux_signal.h>
 #include <compat/linux/common/linux_misc.h>
 #include <compat/linux/common/linux_statfs.h>
 #include <compat/linux/common/linux_ipc.h>
 #include <compat/linux/common/linux_sem.h>
 #include <compat/linux/linux_syscallargs.h>
 extern const struct linux_mnttypes linux_fstypes[];
 extern const int linux_fstypes_cnt;
 /*
  * Implement the fs stat functions. Straightforward.
  */
 int
 linux32_sys_statfs(struct lwp *l, const struct linux32_sys_statfs_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp char) path;
 		syscallarg(linux32_statfsp) sp;
 	} */
 	struct statvfs *sb;
 	struct linux_statfs ltmp;
 	int error;
 	sb = STATVFSBUF_GET();
 	error = do_sys_pstatvfs(l, SCARG_P32(uap, path), ST_WAIT, sb);
 	if (error == 0) {
 		bsd_to_linux_statfs(sb, &ltmp);
 		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
+	}
 	STATVFSBUF_PUT(sb);
 	return error;
+}
 int
 linux32_sys_fstatfs(struct lwp *l, const struct linux32_sys_fstatfs_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(linux32_statfsp) sp;
 	} */
 	struct statvfs *sb;
 	struct linux_statfs ltmp;
 	int error;
 	sb = STATVFSBUF_GET();
 	error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
 	if (error == 0) {
 		bsd_to_linux_statfs(sb, &ltmp);
 		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
+	}
 	STATVFSBUF_PUT(sb);
 	return error;
+}
 int
 linux32_sys_statfs64(struct lwp *l, const struct linux32_sys_statfs64_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp char) path;
 		syscallarg(linux32_statfs64p) sp;
 	} */
 	struct statvfs *sb;
 	struct linux_statfs64 ltmp;
 	int error;
 	sb = STATVFSBUF_GET();
 	error = do_sys_pstatvfs(l, SCARG_P32(uap, path), ST_WAIT, sb);
 	if (error == 0) {
 		bsd_to_linux_statfs64(sb, &ltmp);
 		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
+	}
 	STATVFSBUF_PUT(sb);
 	return error;
+}
 int
 linux32_sys_fstatfs64(struct lwp *l, const struct linux32_sys_fstatfs64_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(linux32_statfs64p) sp;
 	} */
 	struct statvfs *sb;
 	struct linux_statfs64 ltmp;
 	int error;
 	sb = STATVFSBUF_GET();
 	error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
 	if (error == 0) {
 		bsd_to_linux_statfs64(sb, &ltmp);
 		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
+	}
 	STATVFSBUF_PUT(sb);
 	return error;
+}
 extern const int linux_ptrace_request_map[];
 int
 linux32_sys_ptrace(struct lwp *l, const struct linux32_sys_ptrace_args *uap, register_t *retval)
+{
 	/* {
 		i386, m68k, powerpc: T=int
 		alpha, amd64: T=long
 		syscallarg(T) request;
 		syscallarg(T) pid;
 		syscallarg(T) addr;
 		syscallarg(T) data;
 	} */
 	const int *ptr;
 	int request;
 	int error;
 	ptr = linux_ptrace_request_map;
 	request = SCARG(uap, request);
 	while (*ptr != -1)
 		if (*ptr++ == request) {
 			struct sys_ptrace_args pta;
 			SCARG(&pta, req) = *ptr;
 			SCARG(&pta, pid) = SCARG(uap, pid);
 			SCARG(&pta, addr) = NETBSD32IPTR64(SCARG(uap, addr));
 			SCARG(&pta, data) = SCARG(uap, data);
 			/*
 			 * Linux ptrace(PTRACE_CONT, pid, 0, 0) means actually
 			 * to continue where the process left off previously.
 			 * The same thing is achieved by addr == (void *) 1
 			 * on NetBSD, so rewrite 'addr' appropriately.
 			 */
 			if (request == LINUX_PTRACE_CONT && SCARG(uap, addr)==0)
 				SCARG(&pta, addr) = (void *) 1;
 			error = sysent[SYS_ptrace].sy_call(l, &pta, retval);
 			if (error)
 				return error;
 			switch (request) {
 			case LINUX_PTRACE_PEEKTEXT:
 			case LINUX_PTRACE_PEEKDATA:
 				error = copyout (retval,
 				    NETBSD32IPTR64(SCARG(uap, data)),
 				    sizeof *retval);
 				*retval = SCARG(uap, data);
 				break;
 			default:
 				break;
+			}
 			return error;
+		}
 		else
 			ptr++;
 	return EIO;
+}
 int
 linux32_sys_personality(struct lwp *l, const struct linux32_sys_personality_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_u_long) per;
 	} */
 	struct linux_sys_personality_args ua;
 	NETBSD32TOX_UAP(per, long);
 	return linux_sys_personality(l, &ua, retval);
+}
 int
 linux32_sys_futex(struct lwp *l,
     const struct linux32_sys_futex_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux32_intp_t) uaddr;
 		syscallarg(int) op;
 		syscallarg(int) val;
 		syscallarg(linux32_timespecp_t) timeout;
 		syscallarg(linux32_intp_t) uaddr2;
 		syscallarg(int) val3;
 	} */
 	struct linux32_timespec lts;
 	struct timespec ts, *tsp = NULL;
 	int val2 = 0;
 	int error;
 	/*
 	 * Linux overlays the "timeout" field and the "val2" field.
 	 * "timeout" is only valid for FUTEX_WAIT and FUTEX_WAIT_BITSET
 	 * on Linux.
 	 */
 	const int op = (SCARG(uap, op) & FUTEX_CMD_MASK);
 	if ((op == FUTEX_WAIT || op == FUTEX_WAIT_BITSET) &&
 	    SCARG_P32(uap, timeout) != NULL) {
 		if ((error = copyin(SCARG_P32(uap, timeout),
 		    &lts, sizeof(lts))) != 0) {
 			return error;
+		}
 		linux32_to_native_timespec(&ts, &lts);
 		tsp = &ts;
 	} else {
 		val2 = (int)(uintptr_t)SCARG_P32(uap, timeout);
+	}
 	return linux_do_futex(SCARG_P32(uap, uaddr), SCARG(uap, op),
 	    SCARG(uap, val), tsp, SCARG_P32(uap, uaddr2), val2,
 	    SCARG(uap, val3), retval);
+}
 int
 linux32_sys_truncate64(struct lwp *l, const struct linux32_sys_truncate64_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_charp) path;
 		syscallarg(off_t) length;
 	} */
 	struct sys_truncate_args ua;
 	/* Linux doesn't have the 'pad' pseudo-parameter */
 	NETBSD32TOP_UAP(path, const char *);
 	SCARG(&ua, PAD) = 0;
 	SCARG(&ua, length) = ((off_t)SCARG(uap, lenhi) << 32) + SCARG(uap, lenlo);
 	return sys_truncate(l, &ua, retval);
+}
 int
 linux32_sys_ftruncate64(struct lwp *l, const struct linux32_sys_ftruncate64_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(unsigned int) fd;
 		syscallarg(off_t) length;
 	} */
 	struct sys_ftruncate_args ua;
 	/* Linux doesn't have the 'pad' pseudo-parameter */
 	NETBSD32TO64_UAP(fd);
 	SCARG(&ua, PAD) = 0;
 	SCARG(&ua, length) = ((off_t)SCARG(uap, lenhi) << 32) + SCARG(uap, lenlo);
 	return sys_ftruncate(l, &ua, retval);
+}
 int
 linux32_sys_setdomainname(struct lwp *l, const struct linux32_sys_setdomainname_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_charp) domainname;
 		syscallarg(int) len;
 	} */
 	struct linux_sys_setdomainname_args ua;
 	NETBSD32TOP_UAP(domainname, char);
 	NETBSD32TO64_UAP(len);
 	return linux_sys_setdomainname(l, &ua, retval);
+}
 int
 linux32_sys_ppoll(struct lwp *l, const struct linux32_sys_ppoll_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_pollfdp_t) fds;
 		syscallarg(u_int) nfds;
 		syscallarg(linux32_timespecp_t) timeout;
 		syscallarg(linux32_sigsetp_t) sigset;
 	} */
 	struct linux32_timespec lts0, *lts;
 	struct timespec ts0, *ts = NULL;
 	linux32_sigset_t lsigmask0, *lsigmask;
 	sigset_t sigmask0, *sigmask = NULL;
 	int error;
 	lts = SCARG_P32(uap, timeout);
 	if (lts) {
 		if ((error = copyin(lts, &lts0, sizeof(lts0))) != 0)
 			return error;
 		linux32_to_native_timespec(&ts0, &lts0);
 		ts = &ts0;
+	}
 	lsigmask = SCARG_P32(uap, sigset);
 	if (lsigmask) {
 		if ((error = copyin(lsigmask, &lsigmask0, sizeof(lsigmask0))))
 			return error;
 		linux32_to_native_sigset(&sigmask0, &lsigmask0);
 		sigmask = &sigmask0;
+	}
 	return pollcommon(retval, SCARG_P32(uap, fds), SCARG(uap, nfds),
 	    ts, sigmask);
+}
 int
 linux32_sys_eventfd(struct lwp *l, const struct linux32_sys_eventfd_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(unsigned int) initval;
 	} */
 	struct linux_sys_eventfd_args ua;
 	NETBSD32TO64_UAP(initval);
 	return linux_sys_eventfd(l, &ua, retval);
+}
 int
 linux32_sys_eventfd2(struct lwp *l, const struct linux32_sys_eventfd2_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(unsigned int) initval;
 		syscallarg(int) flags;
 	} */
 	struct linux_sys_eventfd2_args ua;
 	NETBSD32TO64_UAP(initval);
 	NETBSD32TO64_UAP(flags);
 	return linux_sys_eventfd2(l, &ua, retval);
+}
 static inline off_t
 linux32_hilo_to_off_t(unsigned long hi, unsigned long lo)
+{
 	return (((off_t)hi) << 32) | lo;
+}
 int
 linux32_sys_preadv(struct lwp *l, const struct linux32_sys_preadv_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_iovecp_t) iovp;
 		syscallarg(int) iovcnt;
 		syscallarg(netbsd32_u_long) off_lo;
 		syscallarg(netbsd32_u_long) off_hi;
 	} */
 	struct netbsd32_preadv_args ua;
 	SCARG(&ua, fd) = SCARG(uap, fd);
 	SCARG(&ua, iovp) = SCARG(uap, iovp);
 	SCARG(&ua, iovcnt) = SCARG(uap, iovcnt);
 	SCARG(&ua, PAD) = 0;
 	SCARG(&ua, offset) = linux32_hilo_to_off_t(SCARG(uap, off_hi),
 						   SCARG(uap, off_lo));
 	return netbsd32_preadv(l, &ua, retval);
+}
 int
 linux32_sys_pwritev(struct lwp *l, const struct linux32_sys_pwritev_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_iovecp_t) iovp;
 		syscallarg(int) iovcnt;
 		syscallarg(netbsd32_u_long) off_lo;
 		syscallarg(netbsd32_u_long) off_hi;
 	} */
 	struct netbsd32_pwritev_args ua;
 	SCARG(&ua, fd) = SCARG(uap, fd);
 	SCARG(&ua, iovp) = SCARG(uap, iovp);
 	SCARG(&ua, iovcnt) = SCARG(uap, iovcnt);
 	SCARG(&ua, PAD) = 0;
 	SCARG(&ua, offset) = linux32_hilo_to_off_t(SCARG(uap, off_hi),
 						   SCARG(uap, off_lo));
 	return netbsd32_pwritev(l, &ua, retval);
+}