Attachment 158849 Details for Bug 201299 – patch rerolled with svn

[patch] patch rerolled with svn

lemul-10-stable.diff (text/plain), 819.98 KB, created by Nikolai Lifanov on 2015-07-16 14:40:34 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Nikolai Lifanov

Created: 2015-07-16 14:40:34 UTC

Size: 819.98 KB

patch

obsolete

>Index: sys/amd64/amd64/elf_machdep.c
>===================================================================
>--- sys/amd64/amd64/elf_machdep.c	(revision 285633)
>+++ sys/amd64/amd64/elf_machdep.c	(working copy)
>@@ -82,6 +82,7 @@
> 	.sv_shared_page_base = SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(elf64_sysvec, &elf64_freebsd_sysvec);
> 
>Index: sys/amd64/amd64/machdep.c
>===================================================================
>--- sys/amd64/amd64/machdep.c	(revision 285633)
>+++ sys/amd64/amd64/machdep.c	(working copy)
>@@ -384,10 +384,6 @@
> 	/* Align to 16 bytes. */
> 	sfp = (struct sigframe *)((unsigned long)sp & ~0xFul);
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	regs->tf_rdi = sig;			/* arg 1 in %rdi */
> 	regs->tf_rdx = (register_t)&sfp->sf_uc;	/* arg 3 in %rdx */
>Index: sys/amd64/amd64/trap.c
>===================================================================
>--- sys/amd64/amd64/trap.c	(revision 285633)
>+++ sys/amd64/amd64/trap.c	(working copy)
>@@ -274,6 +274,10 @@
> 		if (td->td_ucred != p->p_ucred) 
> 			cred_update_thread(td);
> 
>+		if (*p->p_sysent->sv_trap)
>+			if ((*p->p_sysent->sv_trap)(td, frame) == 0)
>+				goto userout;
>+
> 		switch (type) {
> 		case T_PRIVINFLT:	/* privileged instruction fault */
> 			i = SIGILL;
>@@ -591,11 +595,31 @@
> 	ksi.ksi_trapno = type;
> 	ksi.ksi_addr = (void *)addr;
> 	if (uprintf_signal) {
>-		uprintf("pid %d comm %s: signal %d err %lx code %d type %d "
>-		    "addr 0x%lx rsp 0x%lx rip 0x%lx "
>+		uprintf("pid %05d thread %p comm %s: signal %d err %lx code %d type %d\n"
>+		    "addr 0x%lx rip 0x%lx rax 0x%lx\n"
>+		    "rdi 0x%lx rsi 0x%lx rdx 0x%lx rcx 0x%lx\n"
>+		    "r8 0x%lx r9 0x%lx rbx 0x%lx rbp 0x%lx\n"
>+		    "r10 0x%lx r11 0x%lx r12 0x%lx r13 0x%lx\n"
>+		    "r14 0x%lx r15 0x%lx\n"
>+		    "<%02x %02x %02x %02x %02x %02x %02x %02x>\n"
> 		    "<%02x %02x %02x %02x %02x %02x %02x %02x>\n",
>-		    p->p_pid, p->p_comm, i, frame->tf_err, ucode, type, addr,
>-		    frame->tf_rsp, frame->tf_rip,
>+		    p->p_pid, td, p->p_comm, i, frame->tf_err, ucode, type,
>+		    addr, frame->tf_rip, frame->tf_rax,
>+		    frame->tf_rdi, frame->tf_rsi,
>+		    frame->tf_rdx, frame->tf_rcx,
>+		    frame->tf_r8, frame->tf_r9,
>+		    frame->tf_rbx, frame->tf_rbp,
>+		    frame->tf_r10, frame->tf_r11,
>+		    frame->tf_r12, frame->tf_r13,
>+		    frame->tf_r14, frame->tf_r15,
>+		    fubyte((void *)(frame->tf_rip - 8)),
>+		    fubyte((void *)(frame->tf_rip - 7)),
>+		    fubyte((void *)(frame->tf_rip - 6)),
>+		    fubyte((void *)(frame->tf_rip - 5)),
>+		    fubyte((void *)(frame->tf_rip - 4)),
>+		    fubyte((void *)(frame->tf_rip - 3)),
>+		    fubyte((void *)(frame->tf_rip - 2)),
>+		    fubyte((void *)(frame->tf_rip - 1)),
> 		    fubyte((void *)(frame->tf_rip + 0)),
> 		    fubyte((void *)(frame->tf_rip + 1)),
> 		    fubyte((void *)(frame->tf_rip + 2)),
>Index: sys/amd64/ia32/ia32_signal.c
>===================================================================
>--- sys/amd64/ia32/ia32_signal.c	(revision 285633)
>+++ sys/amd64/ia32/ia32_signal.c	(working copy)
>@@ -360,10 +360,6 @@
> 	} else
> 		fp = (struct ia32_sigframe3 *)regs->tf_rsp - 1;
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	sf.sf_signum = sig;
> 	sf.sf_scp = (register_t)&fp->sf_siginfo.si_sc;
>@@ -498,10 +494,6 @@
> 		sfp = (struct ia32_sigframe4 *)regs->tf_rsp - 1;
> 	PROC_UNLOCK(p);
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	sf.sf_signum = sig;
> 	sf.sf_ucontext = (register_t)&sfp->sf_uc;
>@@ -643,10 +635,6 @@
> 	sfp = (struct ia32_sigframe *)((uintptr_t)sp & ~0xF);
> 	PROC_UNLOCK(p);
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	sf.sf_signum = sig;
> 	sf.sf_ucontext = (register_t)&sfp->sf_uc;
>Index: sys/amd64/linux/Makefile
>===================================================================
>--- sys/amd64/linux/Makefile	(revision 0)
>+++ sys/amd64/linux/Makefile	(working copy)
>@@ -0,0 +1,17 @@
>+# Makefile for syscall tables
>+#
>+# $FreeBSD$
>+
>+all:
>+	@echo "make sysent only"
>+
>+sysent:  linux_sysent.c linux_syscall.h linux_proto.h linux_syscalls.c linux_systrace_args.c
>+
>+linux_sysent.c linux_syscall.h linux_proto.h linux_syscalls.c linux_systrace_args.c: \
>+		../../kern/makesyscalls.sh syscalls.master syscalls.conf
>+	-mv -f linux_sysent.c linux_sysent.c.bak
>+	-mv -f linux_syscall.h linux_syscall.h.bak
>+	-mv -f linux_proto.h linux_proto.h.bak
>+	-mv -f linux_syscalls.c linux_syscalls.c.bak
>+	-mv -f linux_systrace_args.c linux_systrace_args.c.bak
>+	sh ../../kern/makesyscalls.sh syscalls.master syscalls.conf
>Index: sys/amd64/linux/linux.h
>===================================================================
>--- sys/amd64/linux/linux.h	(revision 0)
>+++ sys/amd64/linux/linux.h	(working copy)
>@@ -0,0 +1,547 @@
>+/*-
>+ * Copyright (c) 2013 Dmitry Chagin
>+ * Copyright (c) 1994-1996 SÃ¸ren Schmidt
>+ * 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
>+ *    in this position and unchanged.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ * 3. The name of the author may not be used to endorse or promote products
>+ *    derived from this software without specific prior written permission
>+ *
>+ * 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.
>+ *
>+ * $FreeBSD$
>+ */
>+
>+#ifndef _AMD64_LINUX_H_
>+#define	_AMD64_LINUX_H_
>+
>+#include <compat/linux/linux.h>
>+#include <amd64/linux/linux_syscall.h>
>+
>+/*
>+ * debugging support
>+ */
>+extern u_char linux_debug_map[];
>+#define	ldebug(name)	isclr(linux_debug_map, LINUX_SYS_linux_ ## name)
>+#define	ARGS(nm, fmt)	"linux(%ld/%ld): "#nm"("fmt")\n",			\
>+			(long)td->td_proc->p_pid, (long)td->td_tid
>+#define	LMSG(fmt)	"linux(%ld/%ld): "fmt"\n",				\
>+			(long)td->td_proc->p_pid, (long)td->td_tid
>+#define	LINUX_DTRACE	linuxulator
>+
>+#define	PTRIN(v)	(void *)(v)
>+#define	PTROUT(v)	(uintptr_t)(v)
>+
>+#define	CP(src,dst,fld) do { (dst).fld = (src).fld; } while (0)
>+#define	CP2(src,dst,sfld,dfld) do { (dst).dfld = (src).sfld; } while (0)
>+#define	PTRIN_CP(src,dst,fld) \
>+	do { (dst).fld = PTRIN((src).fld); } while (0)
>+
>+/*
>+ * Provide a separate set of types for the Linux types.
>+ */
>+typedef int32_t		l_int;
>+typedef int64_t		l_long;
>+typedef int16_t		l_short;
>+typedef uint32_t	l_uint;
>+typedef uint64_t	l_ulong;
>+typedef uint16_t	l_ushort;
>+
>+typedef l_ulong		l_uintptr_t;
>+typedef l_long		l_clock_t;
>+typedef l_int		l_daddr_t;
>+typedef l_ulong		l_dev_t;
>+typedef l_uint		l_gid_t;
>+typedef l_uint		l_uid_t;
>+typedef l_ulong		l_ino_t;
>+typedef l_int		l_key_t;
>+typedef l_long		l_loff_t;
>+typedef l_uint		l_mode_t;
>+typedef l_long		l_off_t;
>+typedef l_int		l_pid_t;
>+typedef l_ulong		l_size_t;
>+typedef l_long		l_ssize_t;
>+typedef l_long		l_suseconds_t;
>+typedef l_long		l_time_t;
>+typedef l_int		l_timer_t;
>+typedef l_int		l_mqd_t;
>+typedef l_size_t	l_socklen_t;
>+typedef	l_ulong		l_fd_mask;
>+
>+typedef struct {
>+	l_int		val[2];
>+} l_fsid_t;
>+
>+typedef struct {
>+	l_time_t	tv_sec;
>+	l_suseconds_t	tv_usec;
>+} l_timeval;
>+
>+#define	l_fd_set	fd_set
>+
>+/*
>+ * Miscellaneous
>+ */
>+#define	LINUX_NAME_MAX		255
>+#define	LINUX_CTL_MAXNAME	10
>+
>+#define LINUX_AT_COUNT		19	/* Count of used aux entry types. */
>+
>+struct l___sysctl_args
>+{
>+	l_uintptr_t	name;
>+	l_int		nlen;
>+	l_uintptr_t	oldval;
>+	l_uintptr_t	oldlenp;
>+	l_uintptr_t	newval;
>+	l_size_t	newlen;
>+	l_ulong		__spare[4];
>+};
>+
>+/* Scheduling policies */
>+#define	LINUX_SCHED_OTHER	0
>+#define	LINUX_SCHED_FIFO	1
>+#define	LINUX_SCHED_RR		2
>+
>+/* Resource limits */
>+#define	LINUX_RLIMIT_CPU	0
>+#define	LINUX_RLIMIT_FSIZE	1
>+#define	LINUX_RLIMIT_DATA	2
>+#define	LINUX_RLIMIT_STACK	3
>+#define	LINUX_RLIMIT_CORE	4
>+#define	LINUX_RLIMIT_RSS	5
>+#define	LINUX_RLIMIT_NPROC	6
>+#define	LINUX_RLIMIT_NOFILE	7
>+#define	LINUX_RLIMIT_MEMLOCK	8
>+#define	LINUX_RLIMIT_AS		9	/* Address space limit */
>+
>+#define	LINUX_RLIM_NLIMITS	10
>+
>+struct l_rlimit {
>+	l_ulong		rlim_cur;
>+	l_ulong		rlim_max;
>+};
>+
>+/* mmap options */
>+#define	LINUX_MAP_SHARED	0x0001
>+#define	LINUX_MAP_PRIVATE	0x0002
>+#define	LINUX_MAP_FIXED		0x0010
>+#define	LINUX_MAP_ANON		0x0020
>+#define	LINUX_MAP_GROWSDOWN	0x0100
>+
>+/*
>+ * stat family of syscalls
>+ */
>+struct l_timespec {
>+	l_time_t	tv_sec;
>+	l_long		tv_nsec;
>+};
>+
>+struct l_newstat {
>+	l_dev_t		st_dev;
>+	l_ino_t		st_ino;
>+	l_ulong		st_nlink;
>+	l_uint		st_mode;
>+	l_uid_t		st_uid;
>+	l_gid_t		st_gid;
>+	l_uint		__st_pad1;
>+	l_dev_t		st_rdev;
>+	l_off_t		st_size;
>+	l_long		st_blksize;
>+	l_long		st_blocks;
>+	struct l_timespec	st_atim;
>+	struct l_timespec	st_mtim;
>+	struct l_timespec	st_ctim;
>+	l_long		__unused1;
>+	l_long		__unused2;
>+	l_long		__unused3;
>+};
>+
>+/* sigaction flags */
>+#define	LINUX_SA_NOCLDSTOP	0x00000001
>+#define	LINUX_SA_NOCLDWAIT	0x00000002
>+#define	LINUX_SA_SIGINFO	0x00000004
>+#define	LINUX_SA_RESTORER	0x04000000
>+#define	LINUX_SA_ONSTACK	0x08000000
>+#define	LINUX_SA_RESTART	0x10000000
>+#define	LINUX_SA_INTERRUPT	0x20000000
>+#define	LINUX_SA_NOMASK		0x40000000
>+#define	LINUX_SA_ONESHOT	0x80000000
>+
>+/* sigprocmask actions */
>+#define	LINUX_SIG_BLOCK		0
>+#define	LINUX_SIG_UNBLOCK	1
>+#define	LINUX_SIG_SETMASK	2
>+
>+/* sigaltstack */
>+#define	LINUX_MINSIGSTKSZ	2048
>+
>+typedef void	(*l_handler_t)(l_int);
>+
>+typedef struct {
>+	l_handler_t	lsa_handler;
>+	l_ulong		lsa_flags;
>+	l_uintptr_t	lsa_restorer;
>+	l_sigset_t	lsa_mask;
>+} l_sigaction_t;
>+
>+typedef struct {
>+	l_uintptr_t	ss_sp;
>+	l_int		ss_flags;
>+	l_size_t	ss_size;
>+} l_stack_t;
>+
>+struct l_fpstate {
>+	u_int16_t cwd;
>+	u_int16_t swd;
>+	u_int16_t twd;
>+	u_int16_t fop;
>+	u_int64_t rip;
>+	u_int64_t rdp;
>+	u_int32_t mxcsr;
>+	u_int32_t mxcsr_mask;
>+	u_int32_t st_space[32];
>+	u_int32_t xmm_space[64];
>+	u_int32_t reserved2[24];
>+};
>+
>+struct l_sigcontext {
>+	l_ulong		sc_r8;
>+	l_ulong		sc_r9;
>+	l_ulong		sc_r10;
>+	l_ulong		sc_r11;
>+	l_ulong		sc_r12;
>+	l_ulong		sc_r13;
>+	l_ulong		sc_r14;
>+	l_ulong		sc_r15;
>+	l_ulong		sc_rdi;
>+	l_ulong		sc_rsi;
>+	l_ulong		sc_rbp;
>+	l_ulong		sc_rbx;
>+	l_ulong		sc_rdx;
>+	l_ulong		sc_rax;
>+	l_ulong		sc_rcx;
>+	l_ulong		sc_rsp;
>+	l_ulong		sc_rip;
>+	l_ulong		sc_rflags;
>+	l_ushort	sc_cs;
>+	l_ushort	sc_gs;
>+	l_ushort	sc_fs;
>+	l_ushort	sc___pad0;
>+	l_ulong		sc_err;
>+	l_ulong		sc_trapno;
>+	l_sigset_t	sc_mask;
>+	l_ulong		sc_cr2;
>+	struct l_fpstate *sc_fpstate;
>+	l_ulong		sc_reserved1[8];
>+};
>+
>+struct l_ucontext {
>+	l_ulong		uc_flags;
>+	l_uintptr_t	uc_link;
>+	l_stack_t	uc_stack;
>+	struct l_sigcontext	uc_mcontext;
>+	l_sigset_t	uc_sigmask;
>+};
>+
>+#define LINUX_SI_PREAMBLE_SIZE	(4 * sizeof(int))
>+#define	LINUX_SI_MAX_SIZE	128
>+#define	LINUX_SI_PAD_SIZE	((LINUX_SI_MAX_SIZE - \
>+				    LINUX_SI_PREAMBLE_SIZE) / sizeof(l_int))
>+typedef union l_sigval {
>+	l_int		sival_int;
>+	l_uintptr_t	sival_ptr;
>+} l_sigval_t;
>+
>+typedef struct l_siginfo {
>+	l_int		lsi_signo;
>+	l_int		lsi_errno;
>+	l_int		lsi_code;
>+	union {
>+		l_int	_pad[LINUX_SI_PAD_SIZE];
>+
>+		struct {
>+			l_pid_t		_pid;
>+			l_uid_t		_uid;
>+		} _kill;
>+
>+		struct {
>+			l_timer_t	_tid;
>+			l_int		_overrun;
>+			char		_pad[sizeof(l_uid_t) - sizeof(int)];
>+			union l_sigval	_sigval;
>+			l_uint		_sys_private;
>+		} _timer;
>+
>+		struct {
>+			l_pid_t		_pid;		/* sender's pid */
>+			l_uid_t		_uid;		/* sender's uid */
>+			union l_sigval	_sigval;
>+		} _rt;
>+
>+		struct {
>+			l_pid_t		_pid;		/* which child */
>+			l_uid_t		_uid;		/* sender's uid */
>+			l_int		_status;	/* exit code */
>+			l_clock_t	_utime;
>+			l_clock_t	_stime;
>+		} _sigchld;
>+
>+		struct {
>+			l_uintptr_t	_addr;	/* Faulting insn/memory ref. */
>+		} _sigfault;
>+
>+		struct {
>+			l_long		_band;	/* POLL_IN,POLL_OUT,POLL_MSG */
>+			l_int		_fd;
>+		} _sigpoll;
>+	} _sifields;
>+} l_siginfo_t;
>+
>+#define	lsi_pid		_sifields._kill._pid
>+#define	lsi_uid		_sifields._kill._uid
>+#define	lsi_tid		_sifields._timer._tid
>+#define	lsi_overrun	_sifields._timer._overrun
>+#define	lsi_sys_private	_sifields._timer._sys_private
>+#define	lsi_status	_sifields._sigchld._status
>+#define	lsi_utime	_sifields._sigchld._utime
>+#define	lsi_stime	_sifields._sigchld._stime
>+#define	lsi_value	_sifields._rt._sigval
>+#define	lsi_int		_sifields._rt._sigval.sival_int
>+#define	lsi_ptr		_sifields._rt._sigval.sival_ptr
>+#define	lsi_addr	_sifields._sigfault._addr
>+#define	lsi_band	_sifields._sigpoll._band
>+#define	lsi_fd		_sifields._sigpoll._fd
>+
>+/*
>+ * We make the stack look like Linux expects it when calling a signal
>+ * handler, but use the BSD way of calling the handler and sigreturn().
>+ * This means that we need to pass the pointer to the handler too.
>+ * It is appended to the frame to not interfere with the rest of it.
>+ */
>+
>+struct l_rt_sigframe {
>+	struct l_ucontext	sf_sc;
>+	struct l_siginfo	sf_si;
>+	l_handler_t		sf_handler;
>+};
>+
>+/*
>+ * mount flags
>+ */
>+#define	LINUX_MS_RDONLY		0x0001
>+#define	LINUX_MS_NOSUID		0x0002
>+#define	LINUX_MS_NODEV		0x0004
>+#define	LINUX_MS_NOEXEC		0x0008
>+#define	LINUX_MS_REMOUNT	0x0020
>+
>+/*
>+ * SystemV IPC defines
>+ */
>+#define	LINUX_IPC_RMID		0
>+#define	LINUX_IPC_SET		1
>+#define	LINUX_IPC_STAT		2
>+#define	LINUX_IPC_INFO		3
>+
>+#define	LINUX_SHM_LOCK		11
>+#define	LINUX_SHM_UNLOCK	12
>+#define	LINUX_SHM_STAT		13
>+#define	LINUX_SHM_INFO		14
>+
>+#define	LINUX_SHM_RDONLY	0x1000
>+#define	LINUX_SHM_RND		0x2000
>+#define	LINUX_SHM_REMAP		0x4000
>+
>+/* semctl commands */
>+#define	LINUX_GETPID		11
>+#define	LINUX_GETVAL		12
>+#define	LINUX_GETALL		13
>+#define	LINUX_GETNCNT		14
>+#define	LINUX_GETZCNT		15
>+#define	LINUX_SETVAL		16
>+#define	LINUX_SETALL		17
>+#define	LINUX_SEM_STAT		18
>+#define	LINUX_SEM_INFO		19
>+
>+union l_semun {
>+	l_int		val;
>+	l_uintptr_t	buf;
>+	l_uintptr_t	array;
>+	l_uintptr_t	__buf;
>+	l_uintptr_t	__pad;
>+};
>+
>+struct l_ipc_perm {
>+	l_key_t		key;
>+	l_uid_t		uid;
>+	l_gid_t		gid;
>+	l_uid_t		cuid;
>+	l_gid_t		cgid;
>+	l_ushort	mode;
>+	l_ushort	seq;
>+};
>+
>+/*
>+ * Socket defines
>+ */
>+
>+#define	LINUX_SOL_SOCKET	1
>+#define	LINUX_SOL_IP		0
>+#define	LINUX_SOL_IPX		256
>+#define	LINUX_SOL_AX25		257
>+#define	LINUX_SOL_TCP		6
>+#define	LINUX_SOL_UDP		17
>+
>+#define	LINUX_SO_DEBUG		1
>+#define	LINUX_SO_REUSEADDR	2
>+#define	LINUX_SO_TYPE		3
>+#define	LINUX_SO_ERROR		4
>+#define	LINUX_SO_DONTROUTE	5
>+#define	LINUX_SO_BROADCAST	6
>+#define	LINUX_SO_SNDBUF		7
>+#define	LINUX_SO_RCVBUF		8
>+#define	LINUX_SO_KEEPALIVE	9
>+#define	LINUX_SO_OOBINLINE	10
>+#define	LINUX_SO_NO_CHECK	11
>+#define	LINUX_SO_PRIORITY	12
>+#define	LINUX_SO_LINGER		13
>+#define	LINUX_SO_PASSCRED	16
>+#define	LINUX_SO_PEERCRED	17
>+#define	LINUX_SO_RCVLOWAT	18
>+#define	LINUX_SO_SNDLOWAT	19
>+#define	LINUX_SO_RCVTIMEO	20
>+#define	LINUX_SO_SNDTIMEO	21
>+#define	LINUX_SO_TIMESTAMP	29
>+#define	LINUX_SO_ACCEPTCONN	30
>+
>+#define	LINUX_IP_TOS		1
>+#define	LINUX_IP_TTL		2
>+#define	LINUX_IP_HDRINCL	3
>+#define	LINUX_IP_OPTIONS	4
>+
>+#define	LINUX_IP_MULTICAST_IF		32
>+#define	LINUX_IP_MULTICAST_TTL		33
>+#define	LINUX_IP_MULTICAST_LOOP		34
>+#define	LINUX_IP_ADD_MEMBERSHIP		35
>+#define	LINUX_IP_DROP_MEMBERSHIP	36
>+
>+struct l_sockaddr {
>+	l_ushort	sa_family;
>+	char		sa_data[14];
>+};
>+
>+struct l_ifmap {
>+	l_ulong		mem_start;
>+	l_ulong		mem_end;
>+	l_ushort	base_addr;
>+	u_char		irq;
>+	u_char		dma;
>+	u_char		port;
>+} __packed;
>+
>+#define	LINUX_IFHWADDRLEN	6
>+#define	LINUX_IFNAMSIZ		16
>+
>+struct l_ifreq {
>+	union {
>+		char	ifrn_name[LINUX_IFNAMSIZ];
>+	} ifr_ifrn;
>+
>+	union {
>+		struct l_sockaddr	ifru_addr;
>+		struct l_sockaddr	ifru_dstaddr;
>+		struct l_sockaddr	ifru_broadaddr;
>+		struct l_sockaddr	ifru_netmask;
>+		struct l_sockaddr	ifru_hwaddr;
>+		l_short		ifru_flags[1];
>+		l_int		ifru_metric;
>+		l_int		ifru_mtu;
>+		struct l_ifmap	ifru_map;
>+		char		ifru_slave[LINUX_IFNAMSIZ];
>+		l_uintptr_t	ifru_data;
>+	} ifr_ifru;
>+} __packed;
>+
>+#define	ifr_name	ifr_ifrn.ifrn_name	/* Interface name */
>+#define	ifr_hwaddr	ifr_ifru.ifru_hwaddr	/* MAC address */
>+
>+struct l_ifconf {
>+	int	ifc_len;
>+	union {
>+		l_uintptr_t	ifcu_buf;
>+		l_uintptr_t	ifcu_req;
>+	} ifc_ifcu;
>+};
>+
>+#define	ifc_buf		ifc_ifcu.ifcu_buf
>+#define	ifc_req		ifc_ifcu.ifcu_req
>+
>+/*
>+ * poll()
>+ */
>+#define	LINUX_POLLIN		0x0001
>+#define	LINUX_POLLPRI		0x0002
>+#define	LINUX_POLLOUT		0x0004
>+#define	LINUX_POLLERR		0x0008
>+#define	LINUX_POLLHUP		0x0010
>+#define	LINUX_POLLNVAL		0x0020
>+#define	LINUX_POLLRDNORM	0x0040
>+#define	LINUX_POLLRDBAND	0x0080
>+#define	LINUX_POLLWRNORM	0x0100
>+#define	LINUX_POLLWRBAND	0x0200
>+#define	LINUX_POLLMSG		0x0400
>+
>+struct l_pollfd {
>+	l_int		fd;
>+	l_short		events;
>+	l_short		revents;
>+};
>+
>+
>+#define	LINUX_CLONE_VM			0x00000100
>+#define	LINUX_CLONE_FS			0x00000200
>+#define	LINUX_CLONE_FILES		0x00000400
>+#define	LINUX_CLONE_SIGHAND		0x00000800
>+#define	LINUX_CLONE_PID			0x00001000	/* No longer exist in Linux */
>+#define	LINUX_CLONE_VFORK		0x00004000
>+#define	LINUX_CLONE_PARENT		0x00008000
>+#define	LINUX_CLONE_THREAD		0x00010000
>+#define	LINUX_CLONE_SETTLS		0x00080000
>+#define	LINUX_CLONE_PARENT_SETTID	0x00100000
>+#define	LINUX_CLONE_CHILD_CLEARTID	0x00200000
>+#define	LINUX_CLONE_CHILD_SETTID	0x01000000
>+
>+#define LINUX_ARCH_SET_GS		0x1001
>+#define LINUX_ARCH_SET_FS		0x1002
>+#define LINUX_ARCH_GET_GS		0x1003
>+#define LINUX_ARCH_GET_FS		0x1004
>+
>+/* robust futexes */
>+struct linux_robust_list {
>+	l_uintptr_t			next;
>+};
>+ 
>+struct linux_robust_list_head {
>+	struct linux_robust_list	list;
>+	l_long				futex_offset;
>+	l_uintptr_t			pending_list;
>+};
>+
>+#endif /* !_AMD64_LINUX_H_ */
>Index: sys/amd64/linux/linux_dummy.c
>===================================================================
>--- sys/amd64/linux/linux_dummy.c	(revision 0)
>+++ sys/amd64/linux/linux_dummy.c	(working copy)
>@@ -0,0 +1,141 @@
>+/*-
>+ * Copyright (c) 2013 Dmitry Chagin
>+ * 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
>+ *    in this position and unchanged.
>+ * 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include "opt_compat.h"
>+#include "opt_kdtrace.h"
>+
>+#include <sys/param.h>
>+#include <sys/kernel.h>
>+#include <sys/sdt.h>
>+#include <sys/systm.h>
>+#include <sys/proc.h>
>+
>+#include <amd64/linux/linux.h>
>+#include <amd64/linux/linux_proto.h>
>+#include <compat/linux/linux_dtrace.h>
>+#include <compat/linux/linux_util.h>
>+
>+/* DTrace init */
>+LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
>+
>+DUMMY(mincore);
>+DUMMY(sendfile);
>+DUMMY(ptrace);
>+DUMMY(syslog);
>+DUMMY(setfsuid);
>+DUMMY(setfsgid);
>+DUMMY(sysfs);
>+DUMMY(vhangup);
>+DUMMY(pivot_root);
>+DUMMY(adjtimex);
>+DUMMY(swapoff);
>+DUMMY(create_module);
>+DUMMY(init_module);
>+DUMMY(delete_module);
>+DUMMY(get_kernel_syms);
>+DUMMY(query_module);
>+DUMMY(quotactl);
>+DUMMY(nfsservctl);
>+DUMMY(getpmsg);
>+DUMMY(putpmsg);
>+DUMMY(afs_syscall);
>+DUMMY(tuxcall);
>+DUMMY(security);
>+DUMMY(set_thread_area);
>+DUMMY(lookup_dcookie);
>+DUMMY(epoll_ctl_old);
>+DUMMY(epoll_wait_old);
>+DUMMY(remap_file_pages);
>+DUMMY(semtimedop);
>+DUMMY(mbind);
>+DUMMY(get_mempolicy);
>+DUMMY(set_mempolicy);
>+DUMMY(mq_open);
>+DUMMY(mq_unlink);
>+DUMMY(mq_timedsend);
>+DUMMY(mq_timedreceive);
>+DUMMY(mq_notify);
>+DUMMY(mq_getsetattr);
>+DUMMY(kexec_load);
>+DUMMY(add_key);
>+DUMMY(request_key);
>+DUMMY(keyctl);
>+DUMMY(ioprio_set);
>+DUMMY(ioprio_get);
>+DUMMY(inotify_init);
>+DUMMY(inotify_add_watch);
>+DUMMY(inotify_rm_watch);
>+DUMMY(migrate_pages);
>+DUMMY(unshare);
>+DUMMY(splice);
>+DUMMY(tee);
>+DUMMY(sync_file_range);
>+DUMMY(vmsplice);
>+DUMMY(move_pages);
>+DUMMY(signalfd);
>+DUMMY(timerfd);
>+DUMMY(timerfd_settime);
>+DUMMY(timerfd_gettime);
>+DUMMY(signalfd4);
>+DUMMY(inotify_init1);
>+DUMMY(preadv);
>+DUMMY(pwritev);
>+DUMMY(rt_tsigqueueinfo);
>+DUMMY(perf_event_open);
>+DUMMY(fanotify_init);
>+DUMMY(fanotify_mark);
>+DUMMY(name_to_handle_at);
>+DUMMY(open_by_handle_at);
>+DUMMY(clock_adjtime);
>+DUMMY(setns);
>+DUMMY(process_vm_readv);
>+DUMMY(process_vm_writev);
>+DUMMY(kcmp);
>+DUMMY(finit_module);
>+
>+#define DUMMY_XATTR(s)						\
>+int								\
>+linux_ ## s ## xattr(						\
>+    struct thread *td, struct linux_ ## s ## xattr_args *arg)	\
>+{								\
>+								\
>+	return (ENOATTR);					\
>+}
>+DUMMY_XATTR(set);
>+DUMMY_XATTR(lset);
>+DUMMY_XATTR(fset);
>+DUMMY_XATTR(get);
>+DUMMY_XATTR(lget);
>+DUMMY_XATTR(fget);
>+DUMMY_XATTR(list);
>+DUMMY_XATTR(llist);
>+DUMMY_XATTR(flist);
>+DUMMY_XATTR(remove);
>+DUMMY_XATTR(lremove);
>+DUMMY_XATTR(fremove);
>Index: sys/amd64/linux/linux_genassym.c
>===================================================================
>--- sys/amd64/linux/linux_genassym.c	(revision 0)
>+++ sys/amd64/linux/linux_genassym.c	(working copy)
>@@ -0,0 +1,15 @@
>+#include <sys/cdefs.h>
>+__FBSDID("$FreeBSD$");
>+
>+#include <sys/param.h>
>+#include <sys/assym.h>
>+#include <sys/systm.h>
>+
>+#include <amd64/linux/linux.h>
>+#include <compat/linux/linux_mib.h>
>+
>+ASSYM(LINUX_RT_SIGF_HANDLER, offsetof(struct l_rt_sigframe, sf_handler));
>+ASSYM(LINUX_RT_SIGF_UC, offsetof(struct l_rt_sigframe, sf_sc));
>+ASSYM(LINUX_RT_SIGF_SC, offsetof(struct l_ucontext, uc_mcontext));
>+ASSYM(LINUX_VERSION_CODE, LINUX_VERSION_CODE);
>+ASSYM(LINUX_SC_RSP, offsetof(struct l_sigcontext, sc_rsp));
>Index: sys/amd64/linux/linux_ipc64.h
>===================================================================
>--- sys/amd64/linux/linux_ipc64.h	(revision 0)
>+++ sys/amd64/linux/linux_ipc64.h	(working copy)
>@@ -0,0 +1,142 @@
>+/*-
>+ * Copyright (c) 2002 Maxim Sobolev <sobomax@FreeBSD.org>
>+ * 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
>+ *    in this position and unchanged.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ * 3. The name of the author may not be used to endorse or promote products
>+ *    derived from this software without specific prior written permission
>+ *
>+ * 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.
>+ *
>+ * $FreeBSD$
>+ */
>+
>+#ifndef _AMD64_LINUX_LINUX_IPC64_H_
>+#define	_AMD64_LINUX_LINUX_IPC64_H_
>+
>+/*
>+ * The ipc64_perm structure for i386 architecture.
>+ * Note extra padding because this structure is passed back and forth
>+ * between kernel and user space.
>+ *
>+ * Pad space is left for:
>+ * - 32-bit mode_t and seq
>+ * - 2 miscellaneous 32-bit values
>+ */
>+
>+struct l_ipc64_perm
>+{
>+	l_key_t		key;
>+	l_uid_t		uid;
>+	l_gid_t		gid;
>+	l_uid_t		cuid;
>+	l_gid_t		cgid;
>+	l_mode_t	mode;
>+	l_ushort	__pad1;
>+	l_ushort	seq;
>+	l_ushort	__pad2;
>+	l_ulong		__unused1;
>+	l_ulong		__unused2;
>+};
>+
>+/*
>+ * The msqid64_ds structure for i386 architecture.
>+ * Note extra padding because this structure is passed back and forth
>+ * between kernel and user space.
>+ *
>+ * Pad space is left for:
>+ * - 64-bit time_t to solve y2038 problem
>+ * - 2 miscellaneous 32-bit values
>+ */
>+
>+struct l_msqid64_ds {
>+	struct l_ipc64_perm msg_perm;
>+	l_time_t	msg_stime;	/* last msgsnd time */
>+	l_ulong		__unused1;
>+	l_time_t	msg_rtime;	/* last msgrcv time */
>+	l_ulong		__unused2;
>+	l_time_t	msg_ctime;	/* last change time */
>+	l_ulong		__unused3;
>+	l_ulong		msg_cbytes;	/* current number of bytes on queue */
>+	l_ulong		msg_qnum;	/* number of messages in queue */
>+	l_ulong		msg_qbytes;	/* max number of bytes on queue */
>+	l_pid_t		msg_lspid;	/* pid of last msgsnd */
>+	l_pid_t		msg_lrpid;	/* last receive pid */
>+	l_ulong		__unused4;
>+	l_ulong		__unused5;
>+};
>+
>+/*
>+ * The semid64_ds structure for i386 architecture.
>+ * Note extra padding because this structure is passed back and forth
>+ * between kernel and user space.
>+ *
>+ * Pad space is left for:
>+ * - 64-bit time_t to solve y2038 problem
>+ * - 2 miscellaneous 32-bit values
>+ */
>+
>+struct l_semid64_ds {
>+	struct l_ipc64_perm sem_perm;	/* permissions */
>+	l_time_t	sem_otime;	/* last semop time */
>+	l_ulong		__unused1;
>+	l_time_t	sem_ctime;	/* last change time */
>+	l_ulong		__unused2;
>+	l_ulong		sem_nsems;	/* no. of semaphores in array */
>+	l_ulong		__unused3;
>+	l_ulong		__unused4;
>+};
>+
>+/*
>+ * The shmid64_ds structure for i386 architecture.
>+ * Note extra padding because this structure is passed back and forth
>+ * between kernel and user space.
>+ *
>+ * Pad space is left for:
>+ * - 64-bit time_t to solve y2038 problem
>+ * - 2 miscellaneous 32-bit values
>+ */
>+
>+struct l_shmid64_ds {
>+	struct l_ipc64_perm shm_perm;	/* operation perms */
>+	l_size_t	shm_segsz;	/* size of segment (bytes) */
>+	l_time_t	shm_atime;	/* last attach time */
>+	l_time_t	shm_dtime;	/* last detach time */
>+	l_time_t	shm_ctime;	/* last change time */
>+	l_pid_t		shm_cpid;	/* pid of creator */
>+	l_pid_t		shm_lpid;	/* pid of last operator */
>+	l_ulong		shm_nattch;	/* no. of current attaches */
>+	l_ulong		__unused4;
>+	l_ulong		__unused5;
>+};
>+
>+struct l_shminfo64 {
>+	l_ulong		shmmax;
>+	l_ulong		shmmin;
>+	l_ulong		shmmni;
>+	l_ulong		shmseg;
>+	l_ulong		shmall;
>+	l_ulong   	__unused1;
>+	l_ulong		__unused2;
>+	l_ulong		__unused3;
>+	l_ulong		__unused4;
>+};
>+
>+#endif /* !_AMD64_LINUX_LINUX_IPC64_H_ */
>Index: sys/amd64/linux/linux_locore.s
>===================================================================
>--- sys/amd64/linux/linux_locore.s	(revision 0)
>+++ sys/amd64/linux/linux_locore.s	(working copy)
>@@ -0,0 +1,123 @@
>+/* $FreeBSD$ */
>+
>+#include "linux_assym.h"			/* system definitions */
>+#include <machine/asmacros.h>			/* miscellaneous asm macros */
>+
>+#include <amd64/linux/linux_syscall.h>		/* system call numbers */
>+
>+	.data
>+
>+	.globl linux_platform
>+linux_platform:
>+	.asciz "x86_64"
>+
>+
>+	.text
>+/*
>+ * To avoid excess stack frame the signal trampoline code emulates
>+ * the 'call' instruction.
>+ */
>+NON_GPROF_ENTRY(linux_rt_sigcode)
>+	movq	%rsp, %rbx			/* preserve sigframe */
>+	call	.getip
>+.getip:
>+	popq	%rax
>+	add	$.startrtsigcode-.getip, %rax	/* ret address */
>+	pushq	%rax
>+	jmp	*LINUX_RT_SIGF_HANDLER(%rbx)
>+.startrtsigcode:
>+	movq	$LINUX_SYS_linux_rt_sigreturn,%rax   /* linux_rt_sigreturn() */
>+	syscall					/* enter kernel with args */
>+	hlt
>+0:	jmp	0b
>+
>+NON_GPROF_ENTRY(__vdso_clock_gettime)
>+.startclockgettime:
>+	movq	$LINUX_SYS_linux_clock_gettime,%rax
>+	syscall
>+	ret
>+.endclockgettime:
>+.weak clock_gettime
>+.set clock_gettime, __vdso_clock_gettime
>+
>+NON_GPROF_ENTRY(__vdso_time)
>+.starttime:
>+	movq	$LINUX_SYS_linux_time,%rax
>+	syscall
>+	ret
>+.endtime:
>+.weak time
>+.set time, __vdso_time
>+
>+NON_GPROF_ENTRY(__vdso_gettimeofday)
>+.startgettimeofday:
>+	movq	$LINUX_SYS_gettimeofday,%rax
>+	syscall
>+	ret
>+.endgettimeofday:
>+.weak gettimeofday
>+.set gettimeofday, __vdso_gettimeofday
>+
>+NON_GPROF_ENTRY(__vdso_getcpu)
>+.startgetcpu:
>+	movq	$-38,%rax	/* not implemented */
>+	ret
>+.endgetcpu:
>+.weak getcpu
>+.set getcpu, __vdso_getcpu
>+
>+#if 0
>+	.section .note.Linux, "a",@note
>+	.long 2f - 1f		/* namesz */
>+	.balign 4
>+	.long 4f - 3f		/* descsz */
>+	.long 0
>+1:
>+	.asciz "Linux"
>+2:
>+	.balign 4
>+3:
>+	.long LINUX_VERSION_CODE
>+4:
>+	.balign 4
>+	.previous
>+#endif
>+
>+#define do_cfa_expr(offset)                                             \
>+	.byte 0x0f;			/* DW_CFA_def_cfa_expression */ \
>+	.uleb128 11f-10f;		/*   length */                  \
>+10:	.byte 0x74;			/*     DW_OP_breg4 */           \
>+	.sleb128 offset;		/*      offset */               \
>+	.byte 0x06;			/*     DW_OP_deref */           \
>+11:
>+
>+	.section .eh_frame,"a",@progbits
>+.LSTARTFRAMEDLSI0:
>+	.long .LENDCIEDLSI0-.LSTARTCIEDLSI0
>+.LSTARTCIEDLSI0:
>+	.long 0					/* CIE ID */
>+	.byte 1					/* Version number */
>+	.string "zR"				/* NULL-terminated
>+						 * augmentation string
>+						 */
>+	.uleb128 1				/* Code alignment factor */
>+	.sleb128 -4				/* Data alignment factor */
>+	.byte 8					/* Return address register column */
>+	.uleb128 1				/* Augmentation value length */
>+	.byte 0x1b				/* DW_EH_PE_pcrel|DW_EH_PE_sdata4. */
>+	.byte 0x0c				/* DW_CFA_def_cfa */
>+	.uleb128 4
>+	.uleb128 4
>+	.byte 0x88				/* DW_CFA_offset, column 0x8 */
>+	.uleb128 1
>+	.align 4
>+.LENDCIEDLSI0:
>+	.long .LENDFDEDLSI0-.LSTARTFDEDLSI0	/* Length FDE */
>+.LSTARTFDEDLSI0:
>+	.long .LSTARTFDEDLSI0-.LSTARTFRAMEDLSI0	/* CIE pointer */
>+	.long .startclockgettime-.		/* PC-relative start address */
>+	.long .endclockgettime-.startclockgettime
>+	.uleb128 0
>+	.align 4
>+.LENDFDEDLSI0:
>+	.previous
>Index: sys/amd64/linux/linux_machdep.c
>===================================================================
>--- sys/amd64/linux/linux_machdep.c	(revision 0)
>+++ sys/amd64/linux/linux_machdep.c	(working copy)
>@@ -0,0 +1,527 @@
>+/*-
>+ * Copyright (c) 2013 Dmitry Chagin
>+ * Copyright (c) 2004 Tim J. Robbins
>+ * Copyright (c) 2002 Doug Rabson
>+ * Copyright (c) 2000 Marcel Moolenaar
>+ * 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
>+ *    in this position and unchanged.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ * 3. The name of the author may not be used to endorse or promote products
>+ *    derived from this software without specific prior written permission.
>+ *
>+ * 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include <sys/param.h>
>+#include <sys/kernel.h>
>+#include <sys/systm.h>
>+#include <sys/capability.h>
>+#include <sys/dirent.h>
>+#include <sys/file.h>
>+#include <sys/fcntl.h>
>+#include <sys/filedesc.h>
>+#include <sys/clock.h>
>+#include <sys/imgact.h>
>+#include <sys/ktr.h>
>+#include <sys/limits.h>
>+#include <sys/lock.h>
>+#include <sys/malloc.h>
>+#include <sys/mman.h>
>+#include <sys/mutex.h>
>+#include <sys/priv.h>
>+#include <sys/proc.h>
>+#include <sys/resource.h>
>+#include <sys/resourcevar.h>
>+#include <sys/sched.h>
>+#include <sys/syscallsubr.h>
>+#include <sys/sysproto.h>
>+#include <sys/vnode.h>
>+#include <sys/unistd.h>
>+#include <sys/wait.h>
>+
>+#include <security/mac/mac_framework.h>
>+
>+#include <ufs/ufs/extattr.h>
>+#include <ufs/ufs/quota.h>
>+#include <ufs/ufs/ufsmount.h>
>+
>+#include <machine/frame.h>
>+#include <machine/md_var.h>
>+#include <machine/pcb.h>
>+#include <machine/psl.h>
>+#include <machine/segments.h>
>+#include <machine/specialreg.h>
>+
>+#include <vm/vm.h>
>+#include <vm/pmap.h>
>+#include <vm/vm_extern.h>
>+#include <vm/vm_kern.h>
>+#include <vm/vm_map.h>
>+
>+#include <amd64/linux/linux.h>
>+#include <amd64/linux/linux_proto.h>
>+#include <compat/linux/linux_ipc.h>
>+#include <compat/linux/linux_file.h>
>+#include <compat/linux/linux_misc.h>
>+#include <compat/linux/linux_signal.h>
>+#include <compat/linux/linux_util.h>
>+#include <compat/linux/linux_emul.h>
>+
>+
>+int
>+linux_execve(struct thread *td, struct linux_execve_args *args)
>+{
>+	struct image_args eargs;
>+	char *path;
>+	int error;
>+
>+	LCONVPATHEXIST(td, args->path, &path);
>+
>+	LINUX_CTR(execve);
>+
>+	error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, args->argp,
>+	    args->envp);
>+	free(path, M_TEMP);
>+	if (error == 0)
>+		error = linux_common_execve(td, &eargs);
>+	return (error);
>+}
>+
>+int
>+linux_set_upcall_kse(struct thread *td, register_t stack)
>+{
>+
>+	if (stack)
>+		td->td_frame->tf_rsp = stack;
>+
>+	/*
>+	 * The newly created Linux thread returns
>+	 * to the user space by the same path that a parent do.
>+	 */
>+	td->td_frame->tf_rax = 0;
>+	return (0);
>+}
>+
>+#define STACK_SIZE  (2 * 1024 * 1024)
>+#define GUARD_SIZE  (4 * PAGE_SIZE)
>+
>+int
>+linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
>+{
>+	struct proc *p = td->td_proc;
>+	struct mmap_args /* {
>+		caddr_t addr;
>+		size_t len;
>+		int prot;
>+		int flags;
>+		int fd;
>+		long pad;
>+		off_t pos;
>+	} */ bsd_args;
>+	int error;
>+	struct file *fp;
>+	cap_rights_t rights;
>+
>+	LINUX_CTR6(mmap2, "0x%lx, %ld, %ld, 0x%08lx, %ld, 0x%lx",
>+	    args->addr, args->len, args->prot,
>+	    args->flags, args->fd, args->pgoff);
>+
>+	error = 0;
>+	bsd_args.flags = 0;
>+	fp = NULL;
>+
>+	/*
>+	 * Linux mmap(2):
>+	 * You must specify exactly one of MAP_SHARED and MAP_PRIVATE
>+	 */
>+	if (! ((args->flags & LINUX_MAP_SHARED) ^
>+	    (args->flags & LINUX_MAP_PRIVATE)))
>+		return (EINVAL);
>+
>+	if (args->flags & LINUX_MAP_SHARED)
>+		bsd_args.flags |= MAP_SHARED;
>+	if (args->flags & LINUX_MAP_PRIVATE)
>+		bsd_args.flags |= MAP_PRIVATE;
>+	if (args->flags & LINUX_MAP_FIXED)
>+		bsd_args.flags |= MAP_FIXED;
>+	if (args->flags & LINUX_MAP_ANON)
>+		bsd_args.flags |= MAP_ANON;
>+	else
>+		bsd_args.flags |= MAP_NOSYNC;
>+	if (args->flags & LINUX_MAP_GROWSDOWN)
>+		bsd_args.flags |= MAP_STACK;
>+
>+	/*
>+	 * PROT_READ, PROT_WRITE, or PROT_EXEC implies PROT_READ and PROT_EXEC
>+	 * on Linux/i386. We do this to ensure maximum compatibility.
>+	 * Linux/ia64 does the same in i386 emulation mode.
>+	 */
>+	bsd_args.prot = args->prot;
>+	if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC))
>+		bsd_args.prot |= PROT_READ | PROT_EXEC;
>+
>+	/* Linux does not check file descriptor when MAP_ANONYMOUS is set. */
>+	bsd_args.fd = (bsd_args.flags & MAP_ANON) ? -1 : args->fd;
>+	if (bsd_args.fd != -1) {
>+		/*
>+		 * Linux follows Solaris mmap(2) description:
>+		 * The file descriptor fildes is opened with
>+		 * read permission, regardless of the
>+		 * protection options specified.
>+		 */
>+
>+		error = fget(td, bsd_args.fd,
>+		    cap_rights_init(&rights, CAP_MMAP), &fp);
>+		if (error != 0 )
>+			return (error);
>+		if (fp->f_type != DTYPE_VNODE) {
>+			fdrop(fp, td);
>+			return (EINVAL);
>+		}
>+
>+		/* Linux mmap() just fails for O_WRONLY files */
>+		if (!(fp->f_flag & FREAD)) {
>+			fdrop(fp, td);
>+			return (EACCES);
>+		}
>+
>+		fdrop(fp, td);
>+	}
>+
>+	if (args->flags & LINUX_MAP_GROWSDOWN) {
>+		/*
>+		 * The Linux MAP_GROWSDOWN option does not limit auto
>+		 * growth of the region.  Linux mmap with this option
>+		 * takes as addr the inital BOS, and as len, the initial
>+		 * region size.  It can then grow down from addr without
>+		 * limit.  However, Linux threads has an implicit internal
>+		 * limit to stack size of STACK_SIZE.  Its just not
>+		 * enforced explicitly in Linux.  But, here we impose
>+		 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
>+		 * region, since we can do this with our mmap.
>+		 *
>+		 * Our mmap with MAP_STACK takes addr as the maximum
>+		 * downsize limit on BOS, and as len the max size of
>+		 * the region.  It then maps the top SGROWSIZ bytes,
>+		 * and auto grows the region down, up to the limit
>+		 * in addr.
>+		 *
>+		 * If we don't use the MAP_STACK option, the effect
>+		 * of this code is to allocate a stack region of a
>+		 * fixed size of (STACK_SIZE - GUARD_SIZE).
>+		 */
>+
>+		if ((caddr_t)PTRIN(args->addr) + args->len >
>+		    p->p_vmspace->vm_maxsaddr) {
>+			/*
>+			 * Some Linux apps will attempt to mmap
>+			 * thread stacks near the top of their
>+			 * address space.  If their TOS is greater
>+			 * than vm_maxsaddr, vm_map_growstack()
>+			 * will confuse the thread stack with the
>+			 * process stack and deliver a SEGV if they
>+			 * attempt to grow the thread stack past their
>+			 * current stacksize rlimit.  To avoid this,
>+			 * adjust vm_maxsaddr upwards to reflect
>+			 * the current stacksize rlimit rather
>+			 * than the maximum possible stacksize.
>+			 * It would be better to adjust the
>+			 * mmap'ed region, but some apps do not check
>+			 * mmap's return value.
>+			 */
>+			PROC_LOCK(p);
>+			p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -
>+			    lim_cur(p, RLIMIT_STACK);
>+			PROC_UNLOCK(p);
>+		}
>+
>+		/*
>+		 * This gives us our maximum stack size and a new BOS.
>+		 * If we're using VM_STACK, then mmap will just map
>+		 * the top SGROWSIZ bytes, and let the stack grow down
>+		 * to the limit at BOS.  If we're not using VM_STACK
>+		 * we map the full stack, since we don't have a way
>+		 * to autogrow it.
>+		 */
>+		if (args->len > STACK_SIZE - GUARD_SIZE) {
>+			bsd_args.addr = (caddr_t)PTRIN(args->addr);
>+			bsd_args.len = args->len;
>+		} else {
>+			bsd_args.addr = (caddr_t)PTRIN(args->addr) -
>+			    (STACK_SIZE - GUARD_SIZE - args->len);
>+			bsd_args.len = STACK_SIZE - GUARD_SIZE;
>+		}
>+	} else {
>+		bsd_args.addr = (caddr_t)PTRIN(args->addr);
>+		bsd_args.len  = args->len;
>+	}
>+	bsd_args.pos = (off_t)args->pgoff;
>+
>+	error = sys_mmap(td, &bsd_args);
>+
>+	LINUX_CTR2(mmap2, "return: %d (%p)",
>+	    error, td->td_retval[0]);
>+	return (error);
>+}
>+
>+int
>+linux_mprotect(struct thread *td, struct linux_mprotect_args *uap)
>+{
>+	struct mprotect_args bsd_args;
>+
>+	LINUX_CTR(mprotect);
>+
>+	bsd_args.addr = uap->addr;
>+	bsd_args.len = uap->len;
>+	bsd_args.prot = uap->prot;
>+	if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC))
>+		bsd_args.prot |= PROT_READ | PROT_EXEC;
>+	return (sys_mprotect(td, &bsd_args));
>+}
>+
>+int
>+linux_iopl(struct thread *td, struct linux_iopl_args *args)
>+{
>+	int error;
>+
>+	LINUX_CTR(iopl);
>+
>+	if (args->level > 3)
>+		return (EINVAL);
>+	if ((error = priv_check(td, PRIV_IO)) != 0)
>+		return (error);
>+	if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
>+		return (error);
>+	td->td_frame->tf_rflags = (td->td_frame->tf_rflags & ~PSL_IOPL) |
>+	    (args->level * (PSL_IOPL / 3));
>+
>+	return (0);
>+}
>+
>+int
>+linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)
>+{
>+	l_sigset_t lmask;
>+	sigset_t sigmask;
>+	int error;
>+
>+	LINUX_CTR2(rt_sigsuspend, "%p, %ld",
>+	    uap->newset, uap->sigsetsize);
>+
>+	if (uap->sigsetsize != sizeof(l_sigset_t))
>+		return (EINVAL);
>+
>+	error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
>+	if (error)
>+		return (error);
>+
>+	linux_to_bsd_sigset(&lmask, &sigmask);
>+	return (kern_sigsuspend(td, sigmask));
>+}
>+
>+int
>+linux_pause(struct thread *td, struct linux_pause_args *args)
>+{
>+	struct proc *p = td->td_proc;
>+	sigset_t sigmask;
>+
>+	LINUX_CTR(pause);
>+
>+	PROC_LOCK(p);
>+	sigmask = td->td_sigmask;
>+	PROC_UNLOCK(p);
>+	return (kern_sigsuspend(td, sigmask));
>+}
>+
>+int
>+linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
>+{
>+	stack_t ss, oss;
>+	l_stack_t lss;
>+	int error;
>+
>+	LINUX_CTR2(sigaltstack, "%p, %p", uap->uss, uap->uoss);
>+
>+	if (uap->uss != NULL) {
>+		error = copyin(uap->uss, &lss, sizeof(l_stack_t));
>+		if (error)
>+			return (error);
>+
>+		ss.ss_sp = PTRIN(lss.ss_sp);
>+		ss.ss_size = lss.ss_size;
>+		ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
>+	}
>+	error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
>+	    (uap->uoss != NULL) ? &oss : NULL);
>+	if (!error && uap->uoss != NULL) {
>+		lss.ss_sp = PTROUT(oss.ss_sp);
>+		lss.ss_size = oss.ss_size;
>+		lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
>+		error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
>+	}
>+
>+	return (error);
>+}
>+
>+/* XXX do all */
>+int
>+linux_arch_prctl(struct thread *td, struct linux_arch_prctl_args *args)
>+{
>+	int error;
>+	struct pcb *pcb;
>+
>+	LINUX_CTR2(arch_prctl, "0x%x, %p", args->code, args->addr);
>+
>+	error = ENOTSUP;
>+	pcb = td->td_pcb;
>+
>+	switch (args->code) {
>+	case LINUX_ARCH_GET_GS:
>+		error = copyout(&pcb->pcb_gsbase, (unsigned long *)args->addr,
>+		    sizeof(args->addr));
>+		break;
>+	case LINUX_ARCH_SET_GS:
>+		if (args->addr >= VM_MAXUSER_ADDRESS)
>+			return(EPERM);
>+		break;
>+	case LINUX_ARCH_GET_FS:
>+		error = copyout(&pcb->pcb_fsbase, (unsigned long *)args->addr,
>+		    sizeof(args->addr));
>+		break;
>+	case LINUX_ARCH_SET_FS:
>+		error = linux_set_cloned_tls(td, (void *)args->addr);
>+		break;
>+	default:
>+		error = EINVAL;
>+	}
>+	return (error);
>+}
>+
>+int
>+linux_set_cloned_tls(struct thread *td, void *desc)
>+{
>+	struct pcb *pcb;
>+
>+	if ((uint64_t)desc >= VM_MAXUSER_ADDRESS)
>+		return (EPERM);
>+
>+	pcb = td->td_pcb;
>+	pcb->pcb_fsbase = (register_t)desc;
>+	td->td_frame->tf_fs = _ufssel;
>+
>+	return (0);
>+}
>+
>+int
>+linux_wait4(struct thread *td, struct linux_wait4_args *args)
>+{
>+	int error, options;
>+	struct rusage ru, *rup;
>+
>+#ifdef DEBUG
>+	if (ldebug(wait4))
>+		printf(ARGS(wait4, "%d, %p, %d, %p"),
>+		    args->pid, (void *)args->status, args->options,
>+		    (void *)args->rusage);
>+#endif
>+	if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |
>+	    LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))
>+		return (EINVAL);
>+
>+	options = WEXITED;
>+	linux_to_bsd_waitopts(args->options, &options);
>+
>+	if (args->rusage != NULL)
>+		rup = &ru;
>+	else
>+		rup = NULL;
>+	error = linux_common_wait(td, args->pid, args->status, options, rup);
>+	if (error)
>+		return (error);
>+	if (args->rusage != NULL)
>+		error = copyout(&ru, args->rusage, sizeof(ru));
>+
>+	return (error);
>+}
>+
>+int
>+linux_waitid(struct thread *td, struct linux_waitid_args *args)
>+{
>+	int status, options, sig;
>+	struct __wrusage wru;
>+	siginfo_t siginfo;
>+	l_siginfo_t lsi;
>+	idtype_t idtype;
>+	struct proc *p;
>+	int error;
>+
>+	options = 0;
>+	linux_to_bsd_waitopts(args->options, &options);
>+
>+	if (options & ~(WNOHANG | WNOWAIT | WEXITED | WUNTRACED | WCONTINUED))
>+		return (EINVAL);
>+	if (!(options & (WEXITED | WUNTRACED | WCONTINUED)))
>+		return (EINVAL);
>+
>+	switch (args->idtype) {
>+	case LINUX_P_ALL:
>+		idtype = P_ALL;
>+		break;
>+	case LINUX_P_PID:
>+		if (args->id <= 0)
>+			return (EINVAL);
>+		idtype = P_PID;
>+		break;
>+	case LINUX_P_PGID:
>+		if (args->id <= 0)
>+			return (EINVAL);
>+		idtype = P_PGID;
>+		break;
>+	default:
>+		return (EINVAL);
>+	}
>+
>+	error = kern_wait6(td, idtype, args->id, &status, options,
>+	    &wru, &siginfo);
>+	if (error)
>+		return (error);
>+	if (args->rusage != NULL) {
>+		error = copyout(&wru.wru_children, args->rusage,
>+		    sizeof(wru.wru_children));
>+		if (error)
>+			return (error);
>+	}
>+	if (args->info != NULL) {
>+		p = td->td_proc;
>+		if (td->td_retval[0] == 0)
>+			bzero(&lsi, sizeof(lsi));
>+		else {
>+			sig = bsd_to_linux_signal(siginfo.si_signo);
>+			siginfo_to_lsiginfo(&siginfo, &lsi, sig);
>+		}
>+		error = copyout(&lsi, args->info, sizeof(lsi));
>+	}
>+	td->td_retval[0] = 0;
>+
>+	return (error);
>+}
>Index: sys/amd64/linux/linux_proto.h
>===================================================================
>--- sys/amd64/linux/linux_proto.h	(revision 0)
>+++ sys/amd64/linux/linux_proto.h	(working copy)
>@@ -0,0 +1,1663 @@
>+/*
>+ * System call prototypes.
>+ *
>+ * DO NOT EDIT-- this file is automatically generated.
>+ * $FreeBSD$
>+ * created from FreeBSD
>+ */
>+
>+#ifndef _LINUX_SYSPROTO_H_
>+#define	_LINUX_SYSPROTO_H_
>+
>+#include <sys/signal.h>
>+#include <sys/acl.h>
>+#include <sys/cpuset.h>
>+#include <sys/_ffcounter.h>
>+#include <sys/_semaphore.h>
>+#include <sys/ucontext.h>
>+#include <sys/wait.h>
>+
>+#include <bsm/audit_kevents.h>
>+
>+struct proc;
>+
>+struct thread;
>+
>+#define	PAD_(t)	(sizeof(register_t) <= sizeof(t) ? \
>+		0 : sizeof(register_t) - sizeof(t))
>+
>+#if BYTE_ORDER == LITTLE_ENDIAN
>+#define	PADL_(t)	0
>+#define	PADR_(t)	PAD_(t)
>+#else
>+#define	PADL_(t)	PAD_(t)
>+#define	PADR_(t)	0
>+#endif
>+
>+#define	nosys	linux_nosys
>+struct linux_open_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+};
>+struct linux_newstat_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)];
>+};
>+struct linux_newfstat_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)];
>+};
>+struct linux_newlstat_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)];
>+};
>+struct linux_lseek_args {
>+	char fdes_l_[PADL_(l_uint)]; l_uint fdes; char fdes_r_[PADR_(l_uint)];
>+	char off_l_[PADL_(l_off_t)]; l_off_t off; char off_r_[PADR_(l_off_t)];
>+	char whence_l_[PADL_(l_int)]; l_int whence; char whence_r_[PADR_(l_int)];
>+};
>+struct linux_mmap2_args {
>+	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];
>+	char len_l_[PADL_(l_ulong)]; l_ulong len; char len_r_[PADR_(l_ulong)];
>+	char prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)];
>+	char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)];
>+	char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)];
>+	char pgoff_l_[PADL_(l_ulong)]; l_ulong pgoff; char pgoff_r_[PADR_(l_ulong)];
>+};
>+struct linux_mprotect_args {
>+	char addr_l_[PADL_(caddr_t)]; caddr_t addr; char addr_r_[PADR_(caddr_t)];
>+	char len_l_[PADL_(int)]; int len; char len_r_[PADR_(int)];
>+	char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)];
>+};
>+struct linux_brk_args {
>+	char dsend_l_[PADL_(l_ulong)]; l_ulong dsend; char dsend_r_[PADR_(l_ulong)];
>+};
>+struct linux_rt_sigaction_args {
>+	char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)];
>+	char act_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * act; char act_r_[PADR_(l_sigaction_t *)];
>+	char oact_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * oact; char oact_r_[PADR_(l_sigaction_t *)];
>+	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
>+};
>+struct linux_rt_sigprocmask_args {
>+	char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)];
>+	char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)];
>+	char omask_l_[PADL_(l_sigset_t *)]; l_sigset_t * omask; char omask_r_[PADR_(l_sigset_t *)];
>+	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
>+};
>+struct linux_rt_sigreturn_args {
>+	char ucp_l_[PADL_(struct l_ucontext *)]; struct l_ucontext * ucp; char ucp_r_[PADR_(struct l_ucontext *)];
>+};
>+struct linux_ioctl_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)];
>+	char arg_l_[PADL_(uintptr_t)]; uintptr_t arg; char arg_r_[PADR_(uintptr_t)];
>+};
>+struct linux_pread_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
>+	char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)];
>+	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];
>+};
>+struct linux_pwrite_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
>+	char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)];
>+	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];
>+};
>+struct linux_access_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)];
>+};
>+struct linux_pipe_args {
>+	char pipefds_l_[PADL_(l_ulong *)]; l_ulong * pipefds; char pipefds_r_[PADR_(l_ulong *)];
>+};
>+struct linux_select_args {
>+	char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)];
>+	char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)];
>+	char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)];
>+	char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)];
>+	char timeout_l_[PADL_(struct l_timeval *)]; struct l_timeval * timeout; char timeout_r_[PADR_(struct l_timeval *)];
>+};
>+struct linux_mremap_args {
>+	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];
>+	char old_len_l_[PADL_(l_ulong)]; l_ulong old_len; char old_len_r_[PADR_(l_ulong)];
>+	char new_len_l_[PADL_(l_ulong)]; l_ulong new_len; char new_len_r_[PADR_(l_ulong)];
>+	char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)];
>+	char new_addr_l_[PADL_(l_ulong)]; l_ulong new_addr; char new_addr_r_[PADR_(l_ulong)];
>+};
>+struct linux_msync_args {
>+	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];
>+	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];
>+	char fl_l_[PADL_(l_int)]; l_int fl; char fl_r_[PADR_(l_int)];
>+};
>+struct linux_mincore_args {
>+	char start_l_[PADL_(l_ulong)]; l_ulong start; char start_r_[PADR_(l_ulong)];
>+	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];
>+	char vec_l_[PADL_(u_char *)]; u_char * vec; char vec_r_[PADR_(u_char *)];
>+};
>+struct linux_shmget_args {
>+	char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)];
>+	char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)];
>+	char shmflg_l_[PADL_(l_int)]; l_int shmflg; char shmflg_r_[PADR_(l_int)];
>+};
>+struct linux_shmat_args {
>+	char shmid_l_[PADL_(l_int)]; l_int shmid; char shmid_r_[PADR_(l_int)];
>+	char shmaddr_l_[PADL_(char *)]; char * shmaddr; char shmaddr_r_[PADR_(char *)];
>+	char shmflg_l_[PADL_(l_int)]; l_int shmflg; char shmflg_r_[PADR_(l_int)];
>+};
>+struct linux_shmctl_args {
>+	char shmid_l_[PADL_(l_int)]; l_int shmid; char shmid_r_[PADR_(l_int)];
>+	char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)];
>+	char buf_l_[PADL_(struct l_shmid_ds *)]; struct l_shmid_ds * buf; char buf_r_[PADR_(struct l_shmid_ds *)];
>+};
>+struct linux_pause_args {
>+	register_t dummy;
>+};
>+struct linux_nanosleep_args {
>+	char rqtp_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * rqtp; char rqtp_r_[PADR_(const struct l_timespec *)];
>+	char rmtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rmtp; char rmtp_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_getitimer_args {
>+	char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)];
>+	char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)];
>+};
>+struct linux_alarm_args {
>+	char secs_l_[PADL_(l_uint)]; l_uint secs; char secs_r_[PADR_(l_uint)];
>+};
>+struct linux_setitimer_args {
>+	char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)];
>+	char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)];
>+	char oitv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * oitv; char oitv_r_[PADR_(struct l_itimerval *)];
>+};
>+struct linux_getpid_args {
>+	register_t dummy;
>+};
>+struct linux_sendfile_args {
>+	char out_l_[PADL_(int)]; int out; char out_r_[PADR_(int)];
>+	char in_l_[PADL_(int)]; int in; char in_r_[PADR_(int)];
>+	char offset_l_[PADL_(l_long *)]; l_long * offset; char offset_r_[PADR_(l_long *)];
>+	char count_l_[PADL_(l_size_t)]; l_size_t count; char count_r_[PADR_(l_size_t)];
>+};
>+struct linux_socket_args {
>+	char domain_l_[PADL_(l_int)]; l_int domain; char domain_r_[PADR_(l_int)];
>+	char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)];
>+	char protocol_l_[PADL_(l_int)]; l_int protocol; char protocol_r_[PADR_(l_int)];
>+};
>+struct linux_connect_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char name_l_[PADL_(l_uintptr_t)]; l_uintptr_t name; char name_r_[PADR_(l_uintptr_t)];
>+	char namelen_l_[PADL_(l_int)]; l_int namelen; char namelen_r_[PADR_(l_int)];
>+};
>+struct linux_accept_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];
>+	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_sendto_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)];
>+	char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+	char to_l_[PADL_(l_uintptr_t)]; l_uintptr_t to; char to_r_[PADR_(l_uintptr_t)];
>+	char tolen_l_[PADL_(l_int)]; l_int tolen; char tolen_r_[PADR_(l_int)];
>+};
>+struct linux_recvfrom_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char buf_l_[PADL_(l_uintptr_t)]; l_uintptr_t buf; char buf_r_[PADR_(l_uintptr_t)];
>+	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+	char from_l_[PADL_(l_uintptr_t)]; l_uintptr_t from; char from_r_[PADR_(l_uintptr_t)];
>+	char fromlen_l_[PADL_(l_uintptr_t)]; l_uintptr_t fromlen; char fromlen_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_sendmsg_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_recvmsg_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_shutdown_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)];
>+};
>+struct linux_bind_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char name_l_[PADL_(l_uintptr_t)]; l_uintptr_t name; char name_r_[PADR_(l_uintptr_t)];
>+	char namelen_l_[PADL_(l_int)]; l_int namelen; char namelen_r_[PADR_(l_int)];
>+};
>+struct linux_listen_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char backlog_l_[PADL_(l_int)]; l_int backlog; char backlog_r_[PADR_(l_int)];
>+};
>+struct linux_getsockname_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];
>+	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_getpeername_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];
>+	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_socketpair_args {
>+	char domain_l_[PADL_(l_int)]; l_int domain; char domain_r_[PADR_(l_int)];
>+	char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)];
>+	char protocol_l_[PADL_(l_int)]; l_int protocol; char protocol_r_[PADR_(l_int)];
>+	char rsv_l_[PADL_(l_uintptr_t)]; l_uintptr_t rsv; char rsv_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_setsockopt_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char level_l_[PADL_(l_int)]; l_int level; char level_r_[PADR_(l_int)];
>+	char optname_l_[PADL_(l_int)]; l_int optname; char optname_r_[PADR_(l_int)];
>+	char optval_l_[PADL_(l_uintptr_t)]; l_uintptr_t optval; char optval_r_[PADR_(l_uintptr_t)];
>+	char optlen_l_[PADL_(l_int)]; l_int optlen; char optlen_r_[PADR_(l_int)];
>+};
>+struct linux_getsockopt_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char level_l_[PADL_(l_int)]; l_int level; char level_r_[PADR_(l_int)];
>+	char optname_l_[PADL_(l_int)]; l_int optname; char optname_r_[PADR_(l_int)];
>+	char optval_l_[PADL_(l_uintptr_t)]; l_uintptr_t optval; char optval_r_[PADR_(l_uintptr_t)];
>+	char optlen_l_[PADL_(l_uintptr_t)]; l_uintptr_t optlen; char optlen_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_clone_args {
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+	char stack_l_[PADL_(void *)]; void * stack; char stack_r_[PADR_(void *)];
>+	char parent_tidptr_l_[PADL_(void *)]; void * parent_tidptr; char parent_tidptr_r_[PADR_(void *)];
>+	char child_tidptr_l_[PADL_(void *)]; void * child_tidptr; char child_tidptr_r_[PADR_(void *)];
>+	char tls_l_[PADL_(void *)]; void * tls; char tls_r_[PADR_(void *)];
>+};
>+struct linux_fork_args {
>+	register_t dummy;
>+};
>+struct linux_vfork_args {
>+	register_t dummy;
>+};
>+struct linux_execve_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char argp_l_[PADL_(char **)]; char ** argp; char argp_r_[PADR_(char **)];
>+	char envp_l_[PADL_(char **)]; char ** envp; char envp_r_[PADR_(char **)];
>+};
>+struct linux_exit_args {
>+	char rval_l_[PADL_(int)]; int rval; char rval_r_[PADR_(int)];
>+};
>+struct linux_wait4_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char status_l_[PADL_(l_int *)]; l_int * status; char status_r_[PADR_(l_int *)];
>+	char options_l_[PADL_(l_int)]; l_int options; char options_r_[PADR_(l_int)];
>+	char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)];
>+};
>+struct linux_kill_args {
>+	char pid_l_[PADL_(l_int)]; l_int pid; char pid_r_[PADR_(l_int)];
>+	char signum_l_[PADL_(l_int)]; l_int signum; char signum_r_[PADR_(l_int)];
>+};
>+struct linux_newuname_args {
>+	char buf_l_[PADL_(struct l_new_utsname *)]; struct l_new_utsname * buf; char buf_r_[PADR_(struct l_new_utsname *)];
>+};
>+struct linux_semget_args {
>+	char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)];
>+	char nsems_l_[PADL_(l_int)]; l_int nsems; char nsems_r_[PADR_(l_int)];
>+	char semflg_l_[PADL_(l_int)]; l_int semflg; char semflg_r_[PADR_(l_int)];
>+};
>+struct linux_semop_args {
>+	char semid_l_[PADL_(l_int)]; l_int semid; char semid_r_[PADR_(l_int)];
>+	char tsops_l_[PADL_(struct l_sembuf *)]; struct l_sembuf * tsops; char tsops_r_[PADR_(struct l_sembuf *)];
>+	char nsops_l_[PADL_(l_uint)]; l_uint nsops; char nsops_r_[PADR_(l_uint)];
>+};
>+struct linux_semctl_args {
>+	char semid_l_[PADL_(l_int)]; l_int semid; char semid_r_[PADR_(l_int)];
>+	char semnum_l_[PADL_(l_int)]; l_int semnum; char semnum_r_[PADR_(l_int)];
>+	char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)];
>+	char arg_l_[PADL_(union l_semun)]; union l_semun arg; char arg_r_[PADR_(union l_semun)];
>+};
>+struct linux_shmdt_args {
>+	char shmaddr_l_[PADL_(char *)]; char * shmaddr; char shmaddr_r_[PADR_(char *)];
>+};
>+struct linux_msgget_args {
>+	char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)];
>+	char msgflg_l_[PADL_(l_int)]; l_int msgflg; char msgflg_r_[PADR_(l_int)];
>+};
>+struct linux_msgsnd_args {
>+	char msqid_l_[PADL_(l_int)]; l_int msqid; char msqid_r_[PADR_(l_int)];
>+	char msgp_l_[PADL_(struct l_msgbuf *)]; struct l_msgbuf * msgp; char msgp_r_[PADR_(struct l_msgbuf *)];
>+	char msgsz_l_[PADL_(l_size_t)]; l_size_t msgsz; char msgsz_r_[PADR_(l_size_t)];
>+	char msgflg_l_[PADL_(l_int)]; l_int msgflg; char msgflg_r_[PADR_(l_int)];
>+};
>+struct linux_msgrcv_args {
>+	char msqid_l_[PADL_(l_int)]; l_int msqid; char msqid_r_[PADR_(l_int)];
>+	char msgp_l_[PADL_(struct l_msgbuf *)]; struct l_msgbuf * msgp; char msgp_r_[PADR_(struct l_msgbuf *)];
>+	char msgsz_l_[PADL_(l_size_t)]; l_size_t msgsz; char msgsz_r_[PADR_(l_size_t)];
>+	char msgtyp_l_[PADL_(l_long)]; l_long msgtyp; char msgtyp_r_[PADR_(l_long)];
>+	char msgflg_l_[PADL_(l_int)]; l_int msgflg; char msgflg_r_[PADR_(l_int)];
>+};
>+struct linux_msgctl_args {
>+	char msqid_l_[PADL_(l_int)]; l_int msqid; char msqid_r_[PADR_(l_int)];
>+	char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)];
>+	char buf_l_[PADL_(struct l_msqid_ds *)]; struct l_msqid_ds * buf; char buf_r_[PADR_(struct l_msqid_ds *)];
>+};
>+struct linux_fcntl_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)];
>+	char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)];
>+};
>+struct linux_fdatasync_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+};
>+struct linux_truncate_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char length_l_[PADL_(l_ulong)]; l_ulong length; char length_r_[PADR_(l_ulong)];
>+};
>+struct linux_ftruncate_args {
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char length_l_[PADL_(l_long)]; l_long length; char length_r_[PADR_(l_long)];
>+};
>+struct linux_getdents_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char dent_l_[PADL_(void *)]; void * dent; char dent_r_[PADR_(void *)];
>+	char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)];
>+};
>+struct linux_getcwd_args {
>+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
>+	char bufsize_l_[PADL_(l_ulong)]; l_ulong bufsize; char bufsize_r_[PADR_(l_ulong)];
>+};
>+struct linux_chdir_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+};
>+struct linux_rename_args {
>+	char from_l_[PADL_(char *)]; char * from; char from_r_[PADR_(char *)];
>+	char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)];
>+};
>+struct linux_mkdir_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+};
>+struct linux_rmdir_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+};
>+struct linux_creat_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+};
>+struct linux_link_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)];
>+};
>+struct linux_unlink_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+};
>+struct linux_symlink_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)];
>+};
>+struct linux_readlink_args {
>+	char name_l_[PADL_(char *)]; char * name; char name_r_[PADR_(char *)];
>+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
>+	char count_l_[PADL_(l_int)]; l_int count; char count_r_[PADR_(l_int)];
>+};
>+struct linux_chmod_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)];
>+};
>+struct linux_chown_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)];
>+	char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)];
>+};
>+struct linux_lchown_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)];
>+	char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)];
>+};
>+struct linux_getrlimit_args {
>+	char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)];
>+	char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)];
>+};
>+struct linux_sysinfo_args {
>+	char info_l_[PADL_(struct l_sysinfo *)]; struct l_sysinfo * info; char info_r_[PADR_(struct l_sysinfo *)];
>+};
>+struct linux_times_args {
>+	char buf_l_[PADL_(struct l_times_argv *)]; struct l_times_argv * buf; char buf_r_[PADR_(struct l_times_argv *)];
>+};
>+struct linux_ptrace_args {
>+	char req_l_[PADL_(l_long)]; l_long req; char req_r_[PADR_(l_long)];
>+	char pid_l_[PADL_(l_long)]; l_long pid; char pid_r_[PADR_(l_long)];
>+	char addr_l_[PADL_(l_long)]; l_long addr; char addr_r_[PADR_(l_long)];
>+	char data_l_[PADL_(l_long)]; l_long data; char data_r_[PADR_(l_long)];
>+};
>+struct linux_getuid_args {
>+	register_t dummy;
>+};
>+struct linux_syslog_args {
>+	char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)];
>+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
>+	char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)];
>+};
>+struct linux_getgid_args {
>+	register_t dummy;
>+};
>+struct linux_getppid_args {
>+	register_t dummy;
>+};
>+struct linux_getgroups_args {
>+	char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)];
>+	char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)];
>+};
>+struct linux_setgroups_args {
>+	char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)];
>+	char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)];
>+};
>+struct linux_setfsuid_args {
>+	char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)];
>+};
>+struct linux_setfsgid_args {
>+	char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)];
>+};
>+struct linux_getsid_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+};
>+struct linux_capget_args {
>+	char hdrp_l_[PADL_(struct l_user_cap_header *)]; struct l_user_cap_header * hdrp; char hdrp_r_[PADR_(struct l_user_cap_header *)];
>+	char datap_l_[PADL_(struct l_user_cap_data *)]; struct l_user_cap_data * datap; char datap_r_[PADR_(struct l_user_cap_data *)];
>+};
>+struct linux_capset_args {
>+	char hdrp_l_[PADL_(struct l_user_cap_header *)]; struct l_user_cap_header * hdrp; char hdrp_r_[PADR_(struct l_user_cap_header *)];
>+	char datap_l_[PADL_(struct l_user_cap_data *)]; struct l_user_cap_data * datap; char datap_r_[PADR_(struct l_user_cap_data *)];
>+};
>+struct linux_rt_sigpending_args {
>+	char set_l_[PADL_(l_sigset_t *)]; l_sigset_t * set; char set_r_[PADR_(l_sigset_t *)];
>+	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
>+};
>+struct linux_rt_sigtimedwait_args {
>+	char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)];
>+	char ptr_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * ptr; char ptr_r_[PADR_(l_siginfo_t *)];
>+	char timeout_l_[PADL_(struct l_timeval *)]; struct l_timeval * timeout; char timeout_r_[PADR_(struct l_timeval *)];
>+	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
>+};
>+struct linux_rt_sigqueueinfo_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)];
>+	char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)];
>+};
>+struct linux_rt_sigsuspend_args {
>+	char newset_l_[PADL_(l_sigset_t *)]; l_sigset_t * newset; char newset_r_[PADR_(l_sigset_t *)];
>+	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
>+};
>+struct linux_sigaltstack_args {
>+	char uss_l_[PADL_(l_stack_t *)]; l_stack_t * uss; char uss_r_[PADR_(l_stack_t *)];
>+	char uoss_l_[PADL_(l_stack_t *)]; l_stack_t * uoss; char uoss_r_[PADR_(l_stack_t *)];
>+};
>+struct linux_utime_args {
>+	char fname_l_[PADL_(char *)]; char * fname; char fname_r_[PADR_(char *)];
>+	char times_l_[PADL_(struct l_utimbuf *)]; struct l_utimbuf * times; char times_r_[PADR_(struct l_utimbuf *)];
>+};
>+struct linux_mknod_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+	char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)];
>+};
>+struct linux_personality_args {
>+	char per_l_[PADL_(l_ulong)]; l_ulong per; char per_r_[PADR_(l_ulong)];
>+};
>+struct linux_ustat_args {
>+	char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)];
>+	char ubuf_l_[PADL_(struct l_ustat *)]; struct l_ustat * ubuf; char ubuf_r_[PADR_(struct l_ustat *)];
>+};
>+struct linux_statfs_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char buf_l_[PADL_(struct l_statfs_buf *)]; struct l_statfs_buf * buf; char buf_r_[PADR_(struct l_statfs_buf *)];
>+};
>+struct linux_fstatfs_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char buf_l_[PADL_(struct l_statfs_buf *)]; struct l_statfs_buf * buf; char buf_r_[PADR_(struct l_statfs_buf *)];
>+};
>+struct linux_sysfs_args {
>+	char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)];
>+	char arg1_l_[PADL_(l_ulong)]; l_ulong arg1; char arg1_r_[PADR_(l_ulong)];
>+	char arg2_l_[PADL_(l_ulong)]; l_ulong arg2; char arg2_r_[PADR_(l_ulong)];
>+};
>+struct linux_getpriority_args {
>+	char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)];
>+	char who_l_[PADL_(int)]; int who; char who_r_[PADR_(int)];
>+};
>+struct linux_sched_setparam_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
>+struct linux_sched_getparam_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
>+struct linux_sched_setscheduler_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
>+struct linux_sched_getscheduler_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+};
>+struct linux_sched_get_priority_max_args {
>+	char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)];
>+};
>+struct linux_sched_get_priority_min_args {
>+	char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)];
>+};
>+struct linux_sched_rr_get_interval_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char interval_l_[PADL_(struct l_timespec *)]; struct l_timespec * interval; char interval_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_vhangup_args {
>+	register_t dummy;
>+};
>+struct linux_pivot_root_args {
>+	register_t dummy;
>+};
>+struct linux_sysctl_args {
>+	char args_l_[PADL_(struct l___sysctl_args *)]; struct l___sysctl_args * args; char args_r_[PADR_(struct l___sysctl_args *)];
>+};
>+struct linux_prctl_args {
>+	char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)];
>+	char arg2_l_[PADL_(l_uintptr_t)]; l_uintptr_t arg2; char arg2_r_[PADR_(l_uintptr_t)];
>+	char arg3_l_[PADL_(l_uintptr_t)]; l_uintptr_t arg3; char arg3_r_[PADR_(l_uintptr_t)];
>+	char arg4_l_[PADL_(l_uintptr_t)]; l_uintptr_t arg4; char arg4_r_[PADR_(l_uintptr_t)];
>+	char arg5_l_[PADL_(l_uintptr_t)]; l_uintptr_t arg5; char arg5_r_[PADR_(l_uintptr_t)];
>+};
>+struct linux_arch_prctl_args {
>+	char code_l_[PADL_(l_int)]; l_int code; char code_r_[PADR_(l_int)];
>+	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];
>+};
>+struct linux_adjtimex_args {
>+	register_t dummy;
>+};
>+struct linux_setrlimit_args {
>+	char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)];
>+	char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)];
>+};
>+struct linux_mount_args {
>+	char specialfile_l_[PADL_(char *)]; char * specialfile; char specialfile_r_[PADR_(char *)];
>+	char dir_l_[PADL_(char *)]; char * dir; char dir_r_[PADR_(char *)];
>+	char filesystemtype_l_[PADL_(char *)]; char * filesystemtype; char filesystemtype_r_[PADR_(char *)];
>+	char rwflag_l_[PADL_(l_ulong)]; l_ulong rwflag; char rwflag_r_[PADR_(l_ulong)];
>+	char data_l_[PADL_(void *)]; void * data; char data_r_[PADR_(void *)];
>+};
>+struct linux_umount_args {
>+	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_swapoff_args {
>+	register_t dummy;
>+};
>+struct linux_reboot_args {
>+	char magic1_l_[PADL_(l_int)]; l_int magic1; char magic1_r_[PADR_(l_int)];
>+	char magic2_l_[PADL_(l_int)]; l_int magic2; char magic2_r_[PADR_(l_int)];
>+	char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)];
>+	char arg_l_[PADL_(void *)]; void * arg; char arg_r_[PADR_(void *)];
>+};
>+struct linux_sethostname_args {
>+	char hostname_l_[PADL_(char *)]; char * hostname; char hostname_r_[PADR_(char *)];
>+	char len_l_[PADL_(l_uint)]; l_uint len; char len_r_[PADR_(l_uint)];
>+};
>+struct linux_setdomainname_args {
>+	char name_l_[PADL_(char *)]; char * name; char name_r_[PADR_(char *)];
>+	char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)];
>+};
>+struct linux_iopl_args {
>+	char level_l_[PADL_(l_uint)]; l_uint level; char level_r_[PADR_(l_uint)];
>+};
>+struct linux_create_module_args {
>+	register_t dummy;
>+};
>+struct linux_init_module_args {
>+	register_t dummy;
>+};
>+struct linux_delete_module_args {
>+	register_t dummy;
>+};
>+struct linux_get_kernel_syms_args {
>+	register_t dummy;
>+};
>+struct linux_query_module_args {
>+	register_t dummy;
>+};
>+struct linux_quotactl_args {
>+	register_t dummy;
>+};
>+struct linux_nfsservctl_args {
>+	register_t dummy;
>+};
>+struct linux_getpmsg_args {
>+	register_t dummy;
>+};
>+struct linux_putpmsg_args {
>+	register_t dummy;
>+};
>+struct linux_afs_syscall_args {
>+	register_t dummy;
>+};
>+struct linux_tuxcall_args {
>+	register_t dummy;
>+};
>+struct linux_security_args {
>+	register_t dummy;
>+};
>+struct linux_gettid_args {
>+	register_t dummy;
>+};
>+struct linux_setxattr_args {
>+	register_t dummy;
>+};
>+struct linux_lsetxattr_args {
>+	register_t dummy;
>+};
>+struct linux_fsetxattr_args {
>+	register_t dummy;
>+};
>+struct linux_getxattr_args {
>+	register_t dummy;
>+};
>+struct linux_lgetxattr_args {
>+	register_t dummy;
>+};
>+struct linux_fgetxattr_args {
>+	register_t dummy;
>+};
>+struct linux_listxattr_args {
>+	register_t dummy;
>+};
>+struct linux_llistxattr_args {
>+	register_t dummy;
>+};
>+struct linux_flistxattr_args {
>+	register_t dummy;
>+};
>+struct linux_removexattr_args {
>+	register_t dummy;
>+};
>+struct linux_lremovexattr_args {
>+	register_t dummy;
>+};
>+struct linux_fremovexattr_args {
>+	register_t dummy;
>+};
>+struct linux_tkill_args {
>+	char tid_l_[PADL_(int)]; int tid; char tid_r_[PADR_(int)];
>+	char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)];
>+};
>+struct linux_time_args {
>+	char tm_l_[PADL_(l_time_t *)]; l_time_t * tm; char tm_r_[PADR_(l_time_t *)];
>+};
>+struct linux_sys_futex_args {
>+	char uaddr_l_[PADL_(void *)]; void * uaddr; char uaddr_r_[PADR_(void *)];
>+	char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)];
>+	char val_l_[PADL_(int)]; int val; char val_r_[PADR_(int)];
>+	char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)];
>+	char uaddr2_l_[PADL_(void *)]; void * uaddr2; char uaddr2_r_[PADR_(void *)];
>+	char val3_l_[PADL_(int)]; int val3; char val3_r_[PADR_(int)];
>+};
>+struct linux_sched_setaffinity_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char len_l_[PADL_(l_uint)]; l_uint len; char len_r_[PADR_(l_uint)];
>+	char user_mask_ptr_l_[PADL_(l_ulong *)]; l_ulong * user_mask_ptr; char user_mask_ptr_r_[PADR_(l_ulong *)];
>+};
>+struct linux_sched_getaffinity_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char len_l_[PADL_(l_uint)]; l_uint len; char len_r_[PADR_(l_uint)];
>+	char user_mask_ptr_l_[PADL_(l_ulong *)]; l_ulong * user_mask_ptr; char user_mask_ptr_r_[PADR_(l_ulong *)];
>+};
>+struct linux_set_thread_area_args {
>+	register_t dummy;
>+};
>+struct linux_lookup_dcookie_args {
>+	register_t dummy;
>+};
>+struct linux_epoll_create_args {
>+	char size_l_[PADL_(l_int)]; l_int size; char size_r_[PADR_(l_int)];
>+};
>+struct linux_epoll_ctl_old_args {
>+	register_t dummy;
>+};
>+struct linux_epoll_wait_old_args {
>+	register_t dummy;
>+};
>+struct linux_remap_file_pages_args {
>+	register_t dummy;
>+};
>+struct linux_getdents64_args {
>+	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];
>+	char dirent_l_[PADL_(void *)]; void * dirent; char dirent_r_[PADR_(void *)];
>+	char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)];
>+};
>+struct linux_set_tid_address_args {
>+	char tidptr_l_[PADL_(int *)]; int * tidptr; char tidptr_r_[PADR_(int *)];
>+};
>+struct linux_semtimedop_args {
>+	register_t dummy;
>+};
>+struct linux_fadvise64_args {
>+	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
>+	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];
>+	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];
>+	char advice_l_[PADL_(int)]; int advice; char advice_r_[PADR_(int)];
>+};
>+struct linux_timer_create_args {
>+	char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)];
>+	char evp_l_[PADL_(struct sigevent *)]; struct sigevent * evp; char evp_r_[PADR_(struct sigevent *)];
>+	char timerid_l_[PADL_(l_timer_t *)]; l_timer_t * timerid; char timerid_r_[PADR_(l_timer_t *)];
>+};
>+struct linux_timer_settime_args {
>+	char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+	char new_l_[PADL_(const struct itimerspec *)]; const struct itimerspec * new; char new_r_[PADR_(const struct itimerspec *)];
>+	char old_l_[PADL_(struct itimerspec *)]; struct itimerspec * old; char old_r_[PADR_(struct itimerspec *)];
>+};
>+struct linux_timer_gettime_args {
>+	char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)];
>+	char setting_l_[PADL_(struct itimerspec *)]; struct itimerspec * setting; char setting_r_[PADR_(struct itimerspec *)];
>+};
>+struct linux_timer_getoverrun_args {
>+	char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)];
>+};
>+struct linux_timer_delete_args {
>+	char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)];
>+};
>+struct linux_clock_settime_args {
>+	char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)];
>+	char tp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tp; char tp_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_clock_gettime_args {
>+	char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)];
>+	char tp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tp; char tp_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_clock_getres_args {
>+	char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)];
>+	char tp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tp; char tp_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_clock_nanosleep_args {
>+	char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)];
>+	char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)];
>+	char rqtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rqtp; char rqtp_r_[PADR_(struct l_timespec *)];
>+	char rmtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rmtp; char rmtp_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_exit_group_args {
>+	char error_code_l_[PADL_(int)]; int error_code; char error_code_r_[PADR_(int)];
>+};
>+struct linux_epoll_wait_args {
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)];
>+	char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)];
>+	char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)];
>+};
>+struct linux_epoll_ctl_args {
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char op_l_[PADL_(l_int)]; l_int op; char op_r_[PADR_(l_int)];
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char event_l_[PADL_(struct epoll_event *)]; struct epoll_event * event; char event_r_[PADR_(struct epoll_event *)];
>+};
>+struct linux_tgkill_args {
>+	char tgid_l_[PADL_(int)]; int tgid; char tgid_r_[PADR_(int)];
>+	char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)];
>+	char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)];
>+};
>+struct linux_utimes_args {
>+	char fname_l_[PADL_(char *)]; char * fname; char fname_r_[PADR_(char *)];
>+	char tptr_l_[PADL_(struct l_timeval *)]; struct l_timeval * tptr; char tptr_r_[PADR_(struct l_timeval *)];
>+};
>+struct linux_mbind_args {
>+	register_t dummy;
>+};
>+struct linux_set_mempolicy_args {
>+	register_t dummy;
>+};
>+struct linux_get_mempolicy_args {
>+	register_t dummy;
>+};
>+struct linux_mq_open_args {
>+	register_t dummy;
>+};
>+struct linux_mq_unlink_args {
>+	register_t dummy;
>+};
>+struct linux_mq_timedsend_args {
>+	register_t dummy;
>+};
>+struct linux_mq_timedreceive_args {
>+	register_t dummy;
>+};
>+struct linux_mq_notify_args {
>+	register_t dummy;
>+};
>+struct linux_mq_getsetattr_args {
>+	register_t dummy;
>+};
>+struct linux_kexec_load_args {
>+	register_t dummy;
>+};
>+struct linux_waitid_args {
>+	char idtype_l_[PADL_(int)]; int idtype; char idtype_r_[PADR_(int)];
>+	char id_l_[PADL_(l_pid_t)]; l_pid_t id; char id_r_[PADR_(l_pid_t)];
>+	char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)];
>+	char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)];
>+	char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)];
>+};
>+struct linux_add_key_args {
>+	register_t dummy;
>+};
>+struct linux_request_key_args {
>+	register_t dummy;
>+};
>+struct linux_keyctl_args {
>+	register_t dummy;
>+};
>+struct linux_ioprio_set_args {
>+	register_t dummy;
>+};
>+struct linux_ioprio_get_args {
>+	register_t dummy;
>+};
>+struct linux_inotify_init_args {
>+	register_t dummy;
>+};
>+struct linux_inotify_add_watch_args {
>+	register_t dummy;
>+};
>+struct linux_inotify_rm_watch_args {
>+	register_t dummy;
>+};
>+struct linux_migrate_pages_args {
>+	register_t dummy;
>+};
>+struct linux_openat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+};
>+struct linux_mkdirat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+};
>+struct linux_mknodat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+	char dev_l_[PADL_(l_uint)]; l_uint dev; char dev_r_[PADR_(l_uint)];
>+};
>+struct linux_fchownat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
>+	char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)];
>+	char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)];
>+	char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)];
>+};
>+struct linux_futimesat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char filename_l_[PADL_(char *)]; char * filename; char filename_r_[PADR_(char *)];
>+	char utimes_l_[PADL_(struct l_timeval *)]; struct l_timeval * utimes; char utimes_r_[PADR_(struct l_timeval *)];
>+};
>+struct linux_newfstatat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char pathname_l_[PADL_(char *)]; char * pathname; char pathname_r_[PADR_(char *)];
>+	char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)];
>+	char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)];
>+};
>+struct linux_unlinkat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)];
>+	char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)];
>+};
>+struct linux_renameat_args {
>+	char olddfd_l_[PADL_(l_int)]; l_int olddfd; char olddfd_r_[PADR_(l_int)];
>+	char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)];
>+	char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)];
>+	char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)];
>+};
>+struct linux_linkat_args {
>+	char olddfd_l_[PADL_(l_int)]; l_int olddfd; char olddfd_r_[PADR_(l_int)];
>+	char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)];
>+	char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)];
>+	char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)];
>+	char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)];
>+};
>+struct linux_symlinkat_args {
>+	char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)];
>+	char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)];
>+	char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)];
>+};
>+struct linux_readlinkat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)];
>+	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];
>+	char bufsiz_l_[PADL_(l_int)]; l_int bufsiz; char bufsiz_r_[PADR_(l_int)];
>+};
>+struct linux_fchmodat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
>+	char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)];
>+};
>+struct linux_faccessat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
>+	char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)];
>+};
>+struct linux_pselect6_args {
>+	char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)];
>+	char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)];
>+	char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)];
>+	char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)];
>+	char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)];
>+	char sig_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * sig; char sig_r_[PADR_(l_uintptr_t *)];
>+};
>+struct linux_ppoll_args {
>+	char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)];
>+	char nfds_l_[PADL_(uint32_t)]; uint32_t nfds; char nfds_r_[PADR_(uint32_t)];
>+	char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)];
>+	char sset_l_[PADL_(l_sigset_t *)]; l_sigset_t * sset; char sset_r_[PADR_(l_sigset_t *)];
>+	char ssize_l_[PADL_(l_size_t)]; l_size_t ssize; char ssize_r_[PADR_(l_size_t)];
>+};
>+struct linux_unshare_args {
>+	register_t dummy;
>+};
>+struct linux_set_robust_list_args {
>+	char head_l_[PADL_(struct linux_robust_list_head *)]; struct linux_robust_list_head * head; char head_r_[PADR_(struct linux_robust_list_head *)];
>+	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];
>+};
>+struct linux_get_robust_list_args {
>+	char pid_l_[PADL_(l_int)]; l_int pid; char pid_r_[PADR_(l_int)];
>+	char head_l_[PADL_(struct linux_robust_list_head *)]; struct linux_robust_list_head * head; char head_r_[PADR_(struct linux_robust_list_head *)];
>+	char len_l_[PADL_(l_size_t *)]; l_size_t * len; char len_r_[PADR_(l_size_t *)];
>+};
>+struct linux_splice_args {
>+	register_t dummy;
>+};
>+struct linux_tee_args {
>+	register_t dummy;
>+};
>+struct linux_sync_file_range_args {
>+	register_t dummy;
>+};
>+struct linux_vmsplice_args {
>+	register_t dummy;
>+};
>+struct linux_move_pages_args {
>+	register_t dummy;
>+};
>+struct linux_utimensat_args {
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)];
>+	char times_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * times; char times_r_[PADR_(const struct l_timespec *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_epoll_pwait_args {
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)];
>+	char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)];
>+	char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)];
>+	char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)];
>+};
>+struct linux_signalfd_args {
>+	register_t dummy;
>+};
>+struct linux_timerfd_args {
>+	register_t dummy;
>+};
>+struct linux_eventfd_args {
>+	char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)];
>+};
>+struct linux_fallocate_args {
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];
>+	char len_l_[PADL_(l_loff_t)]; l_loff_t len; char len_r_[PADR_(l_loff_t)];
>+};
>+struct linux_timerfd_settime_args {
>+	register_t dummy;
>+};
>+struct linux_timerfd_gettime_args {
>+	register_t dummy;
>+};
>+struct linux_accept4_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];
>+	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];
>+	char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)];
>+};
>+struct linux_signalfd4_args {
>+	register_t dummy;
>+};
>+struct linux_eventfd2_args {
>+	char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_epoll_create1_args {
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_dup3_args {
>+	char oldfd_l_[PADL_(l_int)]; l_int oldfd; char oldfd_r_[PADR_(l_int)];
>+	char newfd_l_[PADL_(l_int)]; l_int newfd; char newfd_r_[PADR_(l_int)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_pipe2_args {
>+	char pipefds_l_[PADL_(l_int *)]; l_int * pipefds; char pipefds_r_[PADR_(l_int *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
>+};
>+struct linux_inotify_init1_args {
>+	register_t dummy;
>+};
>+struct linux_preadv_args {
>+	register_t dummy;
>+};
>+struct linux_pwritev_args {
>+	register_t dummy;
>+};
>+struct linux_rt_tsigqueueinfo_args {
>+	register_t dummy;
>+};
>+struct linux_perf_event_open_args {
>+	register_t dummy;
>+};
>+struct linux_recvmmsg_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)];
>+	char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)];
>+	char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)];
>+};
>+struct linux_fanotify_init_args {
>+	register_t dummy;
>+};
>+struct linux_fanotify_mark_args {
>+	register_t dummy;
>+};
>+struct linux_prlimit64_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)];
>+	char new_l_[PADL_(struct rlimit *)]; struct rlimit * new; char new_r_[PADR_(struct rlimit *)];
>+	char old_l_[PADL_(struct rlimit *)]; struct rlimit * old; char old_r_[PADR_(struct rlimit *)];
>+};
>+struct linux_name_to_handle_at_args {
>+	register_t dummy;
>+};
>+struct linux_open_by_handle_at_args {
>+	register_t dummy;
>+};
>+struct linux_clock_adjtime_args {
>+	register_t dummy;
>+};
>+struct linux_syncfs_args {
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+};
>+struct linux_sendmmsg_args {
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)];
>+	char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)];
>+};
>+struct linux_setns_args {
>+	register_t dummy;
>+};
>+struct linux_process_vm_readv_args {
>+	register_t dummy;
>+};
>+struct linux_process_vm_writev_args {
>+	register_t dummy;
>+};
>+struct linux_kcmp_args {
>+	register_t dummy;
>+};
>+struct linux_finit_module_args {
>+	register_t dummy;
>+};
>+#define	nosys	linux_nosys
>+int	linux_open(struct thread *, struct linux_open_args *);
>+int	linux_newstat(struct thread *, struct linux_newstat_args *);
>+int	linux_newfstat(struct thread *, struct linux_newfstat_args *);
>+int	linux_newlstat(struct thread *, struct linux_newlstat_args *);
>+int	linux_lseek(struct thread *, struct linux_lseek_args *);
>+int	linux_mmap2(struct thread *, struct linux_mmap2_args *);
>+int	linux_mprotect(struct thread *, struct linux_mprotect_args *);
>+int	linux_brk(struct thread *, struct linux_brk_args *);
>+int	linux_rt_sigaction(struct thread *, struct linux_rt_sigaction_args *);
>+int	linux_rt_sigprocmask(struct thread *, struct linux_rt_sigprocmask_args *);
>+int	linux_rt_sigreturn(struct thread *, struct linux_rt_sigreturn_args *);
>+int	linux_ioctl(struct thread *, struct linux_ioctl_args *);
>+int	linux_pread(struct thread *, struct linux_pread_args *);
>+int	linux_pwrite(struct thread *, struct linux_pwrite_args *);
>+int	linux_access(struct thread *, struct linux_access_args *);
>+int	linux_pipe(struct thread *, struct linux_pipe_args *);
>+int	linux_select(struct thread *, struct linux_select_args *);
>+int	linux_mremap(struct thread *, struct linux_mremap_args *);
>+int	linux_msync(struct thread *, struct linux_msync_args *);
>+int	linux_mincore(struct thread *, struct linux_mincore_args *);
>+int	linux_shmget(struct thread *, struct linux_shmget_args *);
>+int	linux_shmat(struct thread *, struct linux_shmat_args *);
>+int	linux_shmctl(struct thread *, struct linux_shmctl_args *);
>+int	linux_pause(struct thread *, struct linux_pause_args *);
>+int	linux_nanosleep(struct thread *, struct linux_nanosleep_args *);
>+int	linux_getitimer(struct thread *, struct linux_getitimer_args *);
>+int	linux_alarm(struct thread *, struct linux_alarm_args *);
>+int	linux_setitimer(struct thread *, struct linux_setitimer_args *);
>+int	linux_getpid(struct thread *, struct linux_getpid_args *);
>+int	linux_sendfile(struct thread *, struct linux_sendfile_args *);
>+int	linux_socket(struct thread *, struct linux_socket_args *);
>+int	linux_connect(struct thread *, struct linux_connect_args *);
>+int	linux_accept(struct thread *, struct linux_accept_args *);
>+int	linux_sendto(struct thread *, struct linux_sendto_args *);
>+int	linux_recvfrom(struct thread *, struct linux_recvfrom_args *);
>+int	linux_sendmsg(struct thread *, struct linux_sendmsg_args *);
>+int	linux_recvmsg(struct thread *, struct linux_recvmsg_args *);
>+int	linux_shutdown(struct thread *, struct linux_shutdown_args *);
>+int	linux_bind(struct thread *, struct linux_bind_args *);
>+int	linux_listen(struct thread *, struct linux_listen_args *);
>+int	linux_getsockname(struct thread *, struct linux_getsockname_args *);
>+int	linux_getpeername(struct thread *, struct linux_getpeername_args *);
>+int	linux_socketpair(struct thread *, struct linux_socketpair_args *);
>+int	linux_setsockopt(struct thread *, struct linux_setsockopt_args *);
>+int	linux_getsockopt(struct thread *, struct linux_getsockopt_args *);
>+int	linux_clone(struct thread *, struct linux_clone_args *);
>+int	linux_fork(struct thread *, struct linux_fork_args *);
>+int	linux_vfork(struct thread *, struct linux_vfork_args *);
>+int	linux_execve(struct thread *, struct linux_execve_args *);
>+int	linux_exit(struct thread *, struct linux_exit_args *);
>+int	linux_wait4(struct thread *, struct linux_wait4_args *);
>+int	linux_kill(struct thread *, struct linux_kill_args *);
>+int	linux_newuname(struct thread *, struct linux_newuname_args *);
>+int	linux_semget(struct thread *, struct linux_semget_args *);
>+int	linux_semop(struct thread *, struct linux_semop_args *);
>+int	linux_semctl(struct thread *, struct linux_semctl_args *);
>+int	linux_shmdt(struct thread *, struct linux_shmdt_args *);
>+int	linux_msgget(struct thread *, struct linux_msgget_args *);
>+int	linux_msgsnd(struct thread *, struct linux_msgsnd_args *);
>+int	linux_msgrcv(struct thread *, struct linux_msgrcv_args *);
>+int	linux_msgctl(struct thread *, struct linux_msgctl_args *);
>+int	linux_fcntl(struct thread *, struct linux_fcntl_args *);
>+int	linux_fdatasync(struct thread *, struct linux_fdatasync_args *);
>+int	linux_truncate(struct thread *, struct linux_truncate_args *);
>+int	linux_ftruncate(struct thread *, struct linux_ftruncate_args *);
>+int	linux_getdents(struct thread *, struct linux_getdents_args *);
>+int	linux_getcwd(struct thread *, struct linux_getcwd_args *);
>+int	linux_chdir(struct thread *, struct linux_chdir_args *);
>+int	linux_rename(struct thread *, struct linux_rename_args *);
>+int	linux_mkdir(struct thread *, struct linux_mkdir_args *);
>+int	linux_rmdir(struct thread *, struct linux_rmdir_args *);
>+int	linux_creat(struct thread *, struct linux_creat_args *);
>+int	linux_link(struct thread *, struct linux_link_args *);
>+int	linux_unlink(struct thread *, struct linux_unlink_args *);
>+int	linux_symlink(struct thread *, struct linux_symlink_args *);
>+int	linux_readlink(struct thread *, struct linux_readlink_args *);
>+int	linux_chmod(struct thread *, struct linux_chmod_args *);
>+int	linux_chown(struct thread *, struct linux_chown_args *);
>+int	linux_lchown(struct thread *, struct linux_lchown_args *);
>+int	linux_getrlimit(struct thread *, struct linux_getrlimit_args *);
>+int	linux_sysinfo(struct thread *, struct linux_sysinfo_args *);
>+int	linux_times(struct thread *, struct linux_times_args *);
>+int	linux_ptrace(struct thread *, struct linux_ptrace_args *);
>+int	linux_getuid(struct thread *, struct linux_getuid_args *);
>+int	linux_syslog(struct thread *, struct linux_syslog_args *);
>+int	linux_getgid(struct thread *, struct linux_getgid_args *);
>+int	linux_getppid(struct thread *, struct linux_getppid_args *);
>+int	linux_getgroups(struct thread *, struct linux_getgroups_args *);
>+int	linux_setgroups(struct thread *, struct linux_setgroups_args *);
>+int	linux_setfsuid(struct thread *, struct linux_setfsuid_args *);
>+int	linux_setfsgid(struct thread *, struct linux_setfsgid_args *);
>+int	linux_getsid(struct thread *, struct linux_getsid_args *);
>+int	linux_capget(struct thread *, struct linux_capget_args *);
>+int	linux_capset(struct thread *, struct linux_capset_args *);
>+int	linux_rt_sigpending(struct thread *, struct linux_rt_sigpending_args *);
>+int	linux_rt_sigtimedwait(struct thread *, struct linux_rt_sigtimedwait_args *);
>+int	linux_rt_sigqueueinfo(struct thread *, struct linux_rt_sigqueueinfo_args *);
>+int	linux_rt_sigsuspend(struct thread *, struct linux_rt_sigsuspend_args *);
>+int	linux_sigaltstack(struct thread *, struct linux_sigaltstack_args *);
>+int	linux_utime(struct thread *, struct linux_utime_args *);
>+int	linux_mknod(struct thread *, struct linux_mknod_args *);
>+int	linux_personality(struct thread *, struct linux_personality_args *);
>+int	linux_ustat(struct thread *, struct linux_ustat_args *);
>+int	linux_statfs(struct thread *, struct linux_statfs_args *);
>+int	linux_fstatfs(struct thread *, struct linux_fstatfs_args *);
>+int	linux_sysfs(struct thread *, struct linux_sysfs_args *);
>+int	linux_getpriority(struct thread *, struct linux_getpriority_args *);
>+int	linux_sched_setparam(struct thread *, struct linux_sched_setparam_args *);
>+int	linux_sched_getparam(struct thread *, struct linux_sched_getparam_args *);
>+int	linux_sched_setscheduler(struct thread *, struct linux_sched_setscheduler_args *);
>+int	linux_sched_getscheduler(struct thread *, struct linux_sched_getscheduler_args *);
>+int	linux_sched_get_priority_max(struct thread *, struct linux_sched_get_priority_max_args *);
>+int	linux_sched_get_priority_min(struct thread *, struct linux_sched_get_priority_min_args *);
>+int	linux_sched_rr_get_interval(struct thread *, struct linux_sched_rr_get_interval_args *);
>+int	linux_vhangup(struct thread *, struct linux_vhangup_args *);
>+int	linux_pivot_root(struct thread *, struct linux_pivot_root_args *);
>+int	linux_sysctl(struct thread *, struct linux_sysctl_args *);
>+int	linux_prctl(struct thread *, struct linux_prctl_args *);
>+int	linux_arch_prctl(struct thread *, struct linux_arch_prctl_args *);
>+int	linux_adjtimex(struct thread *, struct linux_adjtimex_args *);
>+int	linux_setrlimit(struct thread *, struct linux_setrlimit_args *);
>+int	linux_mount(struct thread *, struct linux_mount_args *);
>+int	linux_umount(struct thread *, struct linux_umount_args *);
>+int	linux_swapoff(struct thread *, struct linux_swapoff_args *);
>+int	linux_reboot(struct thread *, struct linux_reboot_args *);
>+int	linux_sethostname(struct thread *, struct linux_sethostname_args *);
>+int	linux_setdomainname(struct thread *, struct linux_setdomainname_args *);
>+int	linux_iopl(struct thread *, struct linux_iopl_args *);
>+int	linux_create_module(struct thread *, struct linux_create_module_args *);
>+int	linux_init_module(struct thread *, struct linux_init_module_args *);
>+int	linux_delete_module(struct thread *, struct linux_delete_module_args *);
>+int	linux_get_kernel_syms(struct thread *, struct linux_get_kernel_syms_args *);
>+int	linux_query_module(struct thread *, struct linux_query_module_args *);
>+int	linux_quotactl(struct thread *, struct linux_quotactl_args *);
>+int	linux_nfsservctl(struct thread *, struct linux_nfsservctl_args *);
>+int	linux_getpmsg(struct thread *, struct linux_getpmsg_args *);
>+int	linux_putpmsg(struct thread *, struct linux_putpmsg_args *);
>+int	linux_afs_syscall(struct thread *, struct linux_afs_syscall_args *);
>+int	linux_tuxcall(struct thread *, struct linux_tuxcall_args *);
>+int	linux_security(struct thread *, struct linux_security_args *);
>+int	linux_gettid(struct thread *, struct linux_gettid_args *);
>+int	linux_setxattr(struct thread *, struct linux_setxattr_args *);
>+int	linux_lsetxattr(struct thread *, struct linux_lsetxattr_args *);
>+int	linux_fsetxattr(struct thread *, struct linux_fsetxattr_args *);
>+int	linux_getxattr(struct thread *, struct linux_getxattr_args *);
>+int	linux_lgetxattr(struct thread *, struct linux_lgetxattr_args *);
>+int	linux_fgetxattr(struct thread *, struct linux_fgetxattr_args *);
>+int	linux_listxattr(struct thread *, struct linux_listxattr_args *);
>+int	linux_llistxattr(struct thread *, struct linux_llistxattr_args *);
>+int	linux_flistxattr(struct thread *, struct linux_flistxattr_args *);
>+int	linux_removexattr(struct thread *, struct linux_removexattr_args *);
>+int	linux_lremovexattr(struct thread *, struct linux_lremovexattr_args *);
>+int	linux_fremovexattr(struct thread *, struct linux_fremovexattr_args *);
>+int	linux_tkill(struct thread *, struct linux_tkill_args *);
>+int	linux_time(struct thread *, struct linux_time_args *);
>+int	linux_sys_futex(struct thread *, struct linux_sys_futex_args *);
>+int	linux_sched_setaffinity(struct thread *, struct linux_sched_setaffinity_args *);
>+int	linux_sched_getaffinity(struct thread *, struct linux_sched_getaffinity_args *);
>+int	linux_set_thread_area(struct thread *, struct linux_set_thread_area_args *);
>+int	linux_lookup_dcookie(struct thread *, struct linux_lookup_dcookie_args *);
>+int	linux_epoll_create(struct thread *, struct linux_epoll_create_args *);
>+int	linux_epoll_ctl_old(struct thread *, struct linux_epoll_ctl_old_args *);
>+int	linux_epoll_wait_old(struct thread *, struct linux_epoll_wait_old_args *);
>+int	linux_remap_file_pages(struct thread *, struct linux_remap_file_pages_args *);
>+int	linux_getdents64(struct thread *, struct linux_getdents64_args *);
>+int	linux_set_tid_address(struct thread *, struct linux_set_tid_address_args *);
>+int	linux_semtimedop(struct thread *, struct linux_semtimedop_args *);
>+int	linux_fadvise64(struct thread *, struct linux_fadvise64_args *);
>+int	linux_timer_create(struct thread *, struct linux_timer_create_args *);
>+int	linux_timer_settime(struct thread *, struct linux_timer_settime_args *);
>+int	linux_timer_gettime(struct thread *, struct linux_timer_gettime_args *);
>+int	linux_timer_getoverrun(struct thread *, struct linux_timer_getoverrun_args *);
>+int	linux_timer_delete(struct thread *, struct linux_timer_delete_args *);
>+int	linux_clock_settime(struct thread *, struct linux_clock_settime_args *);
>+int	linux_clock_gettime(struct thread *, struct linux_clock_gettime_args *);
>+int	linux_clock_getres(struct thread *, struct linux_clock_getres_args *);
>+int	linux_clock_nanosleep(struct thread *, struct linux_clock_nanosleep_args *);
>+int	linux_exit_group(struct thread *, struct linux_exit_group_args *);
>+int	linux_epoll_wait(struct thread *, struct linux_epoll_wait_args *);
>+int	linux_epoll_ctl(struct thread *, struct linux_epoll_ctl_args *);
>+int	linux_tgkill(struct thread *, struct linux_tgkill_args *);
>+int	linux_utimes(struct thread *, struct linux_utimes_args *);
>+int	linux_mbind(struct thread *, struct linux_mbind_args *);
>+int	linux_set_mempolicy(struct thread *, struct linux_set_mempolicy_args *);
>+int	linux_get_mempolicy(struct thread *, struct linux_get_mempolicy_args *);
>+int	linux_mq_open(struct thread *, struct linux_mq_open_args *);
>+int	linux_mq_unlink(struct thread *, struct linux_mq_unlink_args *);
>+int	linux_mq_timedsend(struct thread *, struct linux_mq_timedsend_args *);
>+int	linux_mq_timedreceive(struct thread *, struct linux_mq_timedreceive_args *);
>+int	linux_mq_notify(struct thread *, struct linux_mq_notify_args *);
>+int	linux_mq_getsetattr(struct thread *, struct linux_mq_getsetattr_args *);
>+int	linux_kexec_load(struct thread *, struct linux_kexec_load_args *);
>+int	linux_waitid(struct thread *, struct linux_waitid_args *);
>+int	linux_add_key(struct thread *, struct linux_add_key_args *);
>+int	linux_request_key(struct thread *, struct linux_request_key_args *);
>+int	linux_keyctl(struct thread *, struct linux_keyctl_args *);
>+int	linux_ioprio_set(struct thread *, struct linux_ioprio_set_args *);
>+int	linux_ioprio_get(struct thread *, struct linux_ioprio_get_args *);
>+int	linux_inotify_init(struct thread *, struct linux_inotify_init_args *);
>+int	linux_inotify_add_watch(struct thread *, struct linux_inotify_add_watch_args *);
>+int	linux_inotify_rm_watch(struct thread *, struct linux_inotify_rm_watch_args *);
>+int	linux_migrate_pages(struct thread *, struct linux_migrate_pages_args *);
>+int	linux_openat(struct thread *, struct linux_openat_args *);
>+int	linux_mkdirat(struct thread *, struct linux_mkdirat_args *);
>+int	linux_mknodat(struct thread *, struct linux_mknodat_args *);
>+int	linux_fchownat(struct thread *, struct linux_fchownat_args *);
>+int	linux_futimesat(struct thread *, struct linux_futimesat_args *);
>+int	linux_newfstatat(struct thread *, struct linux_newfstatat_args *);
>+int	linux_unlinkat(struct thread *, struct linux_unlinkat_args *);
>+int	linux_renameat(struct thread *, struct linux_renameat_args *);
>+int	linux_linkat(struct thread *, struct linux_linkat_args *);
>+int	linux_symlinkat(struct thread *, struct linux_symlinkat_args *);
>+int	linux_readlinkat(struct thread *, struct linux_readlinkat_args *);
>+int	linux_fchmodat(struct thread *, struct linux_fchmodat_args *);
>+int	linux_faccessat(struct thread *, struct linux_faccessat_args *);
>+int	linux_pselect6(struct thread *, struct linux_pselect6_args *);
>+int	linux_ppoll(struct thread *, struct linux_ppoll_args *);
>+int	linux_unshare(struct thread *, struct linux_unshare_args *);
>+int	linux_set_robust_list(struct thread *, struct linux_set_robust_list_args *);
>+int	linux_get_robust_list(struct thread *, struct linux_get_robust_list_args *);
>+int	linux_splice(struct thread *, struct linux_splice_args *);
>+int	linux_tee(struct thread *, struct linux_tee_args *);
>+int	linux_sync_file_range(struct thread *, struct linux_sync_file_range_args *);
>+int	linux_vmsplice(struct thread *, struct linux_vmsplice_args *);
>+int	linux_move_pages(struct thread *, struct linux_move_pages_args *);
>+int	linux_utimensat(struct thread *, struct linux_utimensat_args *);
>+int	linux_epoll_pwait(struct thread *, struct linux_epoll_pwait_args *);
>+int	linux_signalfd(struct thread *, struct linux_signalfd_args *);
>+int	linux_timerfd(struct thread *, struct linux_timerfd_args *);
>+int	linux_eventfd(struct thread *, struct linux_eventfd_args *);
>+int	linux_fallocate(struct thread *, struct linux_fallocate_args *);
>+int	linux_timerfd_settime(struct thread *, struct linux_timerfd_settime_args *);
>+int	linux_timerfd_gettime(struct thread *, struct linux_timerfd_gettime_args *);
>+int	linux_accept4(struct thread *, struct linux_accept4_args *);
>+int	linux_signalfd4(struct thread *, struct linux_signalfd4_args *);
>+int	linux_eventfd2(struct thread *, struct linux_eventfd2_args *);
>+int	linux_epoll_create1(struct thread *, struct linux_epoll_create1_args *);
>+int	linux_dup3(struct thread *, struct linux_dup3_args *);
>+int	linux_pipe2(struct thread *, struct linux_pipe2_args *);
>+int	linux_inotify_init1(struct thread *, struct linux_inotify_init1_args *);
>+int	linux_preadv(struct thread *, struct linux_preadv_args *);
>+int	linux_pwritev(struct thread *, struct linux_pwritev_args *);
>+int	linux_rt_tsigqueueinfo(struct thread *, struct linux_rt_tsigqueueinfo_args *);
>+int	linux_perf_event_open(struct thread *, struct linux_perf_event_open_args *);
>+int	linux_recvmmsg(struct thread *, struct linux_recvmmsg_args *);
>+int	linux_fanotify_init(struct thread *, struct linux_fanotify_init_args *);
>+int	linux_fanotify_mark(struct thread *, struct linux_fanotify_mark_args *);
>+int	linux_prlimit64(struct thread *, struct linux_prlimit64_args *);
>+int	linux_name_to_handle_at(struct thread *, struct linux_name_to_handle_at_args *);
>+int	linux_open_by_handle_at(struct thread *, struct linux_open_by_handle_at_args *);
>+int	linux_clock_adjtime(struct thread *, struct linux_clock_adjtime_args *);
>+int	linux_syncfs(struct thread *, struct linux_syncfs_args *);
>+int	linux_sendmmsg(struct thread *, struct linux_sendmmsg_args *);
>+int	linux_setns(struct thread *, struct linux_setns_args *);
>+int	linux_process_vm_readv(struct thread *, struct linux_process_vm_readv_args *);
>+int	linux_process_vm_writev(struct thread *, struct linux_process_vm_writev_args *);
>+int	linux_kcmp(struct thread *, struct linux_kcmp_args *);
>+int	linux_finit_module(struct thread *, struct linux_finit_module_args *);
>+
>+#ifdef COMPAT_43
>+
>+#define	nosys	linux_nosys
>+
>+#endif /* COMPAT_43 */
>+
>+
>+#ifdef COMPAT_FREEBSD4
>+
>+#define	nosys	linux_nosys
>+
>+#endif /* COMPAT_FREEBSD4 */
>+
>+
>+#ifdef COMPAT_FREEBSD6
>+
>+#define	nosys	linux_nosys
>+
>+#endif /* COMPAT_FREEBSD6 */
>+
>+
>+#ifdef COMPAT_FREEBSD7
>+
>+#define	nosys	linux_nosys
>+
>+#endif /* COMPAT_FREEBSD7 */
>+
>+#define	LINUX_SYS_AUE_linux_open	AUE_OPEN_RWTC
>+#define	LINUX_SYS_AUE_linux_newstat	AUE_STAT
>+#define	LINUX_SYS_AUE_linux_newfstat	AUE_FSTAT
>+#define	LINUX_SYS_AUE_linux_newlstat	AUE_LSTAT
>+#define	LINUX_SYS_AUE_linux_lseek	AUE_LSEEK
>+#define	LINUX_SYS_AUE_linux_mmap2	AUE_MMAP
>+#define	LINUX_SYS_AUE_linux_mprotect	AUE_MPROTECT
>+#define	LINUX_SYS_AUE_linux_brk	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_sigaction	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_sigprocmask	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_sigreturn	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_ioctl	AUE_IOCTL
>+#define	LINUX_SYS_AUE_linux_pread	AUE_PREAD
>+#define	LINUX_SYS_AUE_linux_pwrite	AUE_PWRITE
>+#define	LINUX_SYS_AUE_linux_access	AUE_ACCESS
>+#define	LINUX_SYS_AUE_linux_pipe	AUE_PIPE
>+#define	LINUX_SYS_AUE_linux_select	AUE_SELECT
>+#define	LINUX_SYS_AUE_linux_mremap	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_msync	AUE_MSYNC
>+#define	LINUX_SYS_AUE_linux_mincore	AUE_MINCORE
>+#define	LINUX_SYS_AUE_linux_shmget	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_shmat	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_shmctl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_pause	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_nanosleep	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_getitimer	AUE_GETITIMER
>+#define	LINUX_SYS_AUE_linux_alarm	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_setitimer	AUE_SETITIMER
>+#define	LINUX_SYS_AUE_linux_getpid	AUE_GETPID
>+#define	LINUX_SYS_AUE_linux_sendfile	AUE_SENDFILE
>+#define	LINUX_SYS_AUE_linux_socket	AUE_SOCKET
>+#define	LINUX_SYS_AUE_linux_connect	AUE_CONNECT
>+#define	LINUX_SYS_AUE_linux_accept	AUE_ACCEPT
>+#define	LINUX_SYS_AUE_linux_sendto	AUE_SENDTO
>+#define	LINUX_SYS_AUE_linux_recvfrom	AUE_RECVFROM
>+#define	LINUX_SYS_AUE_linux_sendmsg	AUE_SENDMSG
>+#define	LINUX_SYS_AUE_linux_recvmsg	AUE_RECVMSG
>+#define	LINUX_SYS_AUE_linux_shutdown	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_bind	AUE_BIND
>+#define	LINUX_SYS_AUE_linux_listen	AUE_LISTEN
>+#define	LINUX_SYS_AUE_linux_getsockname	AUE_GETSOCKNAME
>+#define	LINUX_SYS_AUE_linux_getpeername	AUE_GETPEERNAME
>+#define	LINUX_SYS_AUE_linux_socketpair	AUE_SOCKETPAIR
>+#define	LINUX_SYS_AUE_linux_setsockopt	AUE_SETSOCKOPT
>+#define	LINUX_SYS_AUE_linux_getsockopt	AUE_GETSOCKOPT
>+#define	LINUX_SYS_AUE_linux_clone	AUE_RFORK
>+#define	LINUX_SYS_AUE_linux_fork	AUE_FORK
>+#define	LINUX_SYS_AUE_linux_vfork	AUE_VFORK
>+#define	LINUX_SYS_AUE_linux_execve	AUE_EXECVE
>+#define	LINUX_SYS_AUE_linux_exit	AUE_EXIT
>+#define	LINUX_SYS_AUE_linux_wait4	AUE_WAIT4
>+#define	LINUX_SYS_AUE_linux_kill	AUE_KILL
>+#define	LINUX_SYS_AUE_linux_newuname	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_semget	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_semop	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_semctl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_shmdt	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_msgget	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_msgsnd	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_msgrcv	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_msgctl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fcntl	AUE_FCNTL
>+#define	LINUX_SYS_AUE_linux_fdatasync	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_truncate	AUE_TRUNCATE
>+#define	LINUX_SYS_AUE_linux_ftruncate	AUE_FTRUNCATE
>+#define	LINUX_SYS_AUE_linux_getdents	AUE_GETDIRENTRIES
>+#define	LINUX_SYS_AUE_linux_getcwd	AUE_GETCWD
>+#define	LINUX_SYS_AUE_linux_chdir	AUE_CHDIR
>+#define	LINUX_SYS_AUE_linux_rename	AUE_RENAME
>+#define	LINUX_SYS_AUE_linux_mkdir	AUE_MKDIR
>+#define	LINUX_SYS_AUE_linux_rmdir	AUE_RMDIR
>+#define	LINUX_SYS_AUE_linux_creat	AUE_CREAT
>+#define	LINUX_SYS_AUE_linux_link	AUE_LINK
>+#define	LINUX_SYS_AUE_linux_unlink	AUE_UNLINK
>+#define	LINUX_SYS_AUE_linux_symlink	AUE_SYMLINK
>+#define	LINUX_SYS_AUE_linux_readlink	AUE_READLINK
>+#define	LINUX_SYS_AUE_linux_chmod	AUE_CHMOD
>+#define	LINUX_SYS_AUE_linux_chown	AUE_LCHOWN
>+#define	LINUX_SYS_AUE_linux_lchown	AUE_LCHOWN
>+#define	LINUX_SYS_AUE_linux_getrlimit	AUE_GETRLIMIT
>+#define	LINUX_SYS_AUE_linux_sysinfo	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_times	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_ptrace	AUE_PTRACE
>+#define	LINUX_SYS_AUE_linux_getuid	AUE_GETUID
>+#define	LINUX_SYS_AUE_linux_syslog	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_getgid	AUE_GETGID
>+#define	LINUX_SYS_AUE_linux_getppid	AUE_GETPPID
>+#define	LINUX_SYS_AUE_linux_getgroups	AUE_GETGROUPS
>+#define	LINUX_SYS_AUE_linux_setgroups	AUE_SETGROUPS
>+#define	LINUX_SYS_AUE_linux_setfsuid	AUE_SETFSUID
>+#define	LINUX_SYS_AUE_linux_setfsgid	AUE_SETFSGID
>+#define	LINUX_SYS_AUE_linux_getsid	AUE_GETSID
>+#define	LINUX_SYS_AUE_linux_capget	AUE_CAPGET
>+#define	LINUX_SYS_AUE_linux_capset	AUE_CAPSET
>+#define	LINUX_SYS_AUE_linux_rt_sigpending	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_sigtimedwait	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_sigqueueinfo	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_sigsuspend	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_sigaltstack	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_utime	AUE_UTIME
>+#define	LINUX_SYS_AUE_linux_mknod	AUE_MKNOD
>+#define	LINUX_SYS_AUE_linux_personality	AUE_PERSONALITY
>+#define	LINUX_SYS_AUE_linux_ustat	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_statfs	AUE_STATFS
>+#define	LINUX_SYS_AUE_linux_fstatfs	AUE_FSTATFS
>+#define	LINUX_SYS_AUE_linux_sysfs	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_getpriority	AUE_GETPRIORITY
>+#define	LINUX_SYS_AUE_linux_sched_setparam	AUE_SCHED_SETPARAM
>+#define	LINUX_SYS_AUE_linux_sched_getparam	AUE_SCHED_GETPARAM
>+#define	LINUX_SYS_AUE_linux_sched_setscheduler	AUE_SCHED_SETSCHEDULER
>+#define	LINUX_SYS_AUE_linux_sched_getscheduler	AUE_SCHED_GETSCHEDULER
>+#define	LINUX_SYS_AUE_linux_sched_get_priority_max	AUE_SCHED_GET_PRIORITY_MAX
>+#define	LINUX_SYS_AUE_linux_sched_get_priority_min	AUE_SCHED_GET_PRIORITY_MIN
>+#define	LINUX_SYS_AUE_linux_sched_rr_get_interval	AUE_SCHED_RR_GET_INTERVAL
>+#define	LINUX_SYS_AUE_linux_vhangup	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_pivot_root	AUE_PIVOT_ROOT
>+#define	LINUX_SYS_AUE_linux_sysctl	AUE_SYSCTL
>+#define	LINUX_SYS_AUE_linux_prctl	AUE_PRCTL
>+#define	LINUX_SYS_AUE_linux_arch_prctl	AUE_PRCTL
>+#define	LINUX_SYS_AUE_linux_adjtimex	AUE_ADJTIME
>+#define	LINUX_SYS_AUE_linux_setrlimit	AUE_SETRLIMIT
>+#define	LINUX_SYS_AUE_linux_mount	AUE_MOUNT
>+#define	LINUX_SYS_AUE_linux_umount	AUE_UMOUNT
>+#define	LINUX_SYS_AUE_linux_swapoff	AUE_SWAPOFF
>+#define	LINUX_SYS_AUE_linux_reboot	AUE_REBOOT
>+#define	LINUX_SYS_AUE_linux_sethostname	AUE_SYSCTL
>+#define	LINUX_SYS_AUE_linux_setdomainname	AUE_SYSCTL
>+#define	LINUX_SYS_AUE_linux_iopl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_create_module	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_init_module	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_delete_module	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_get_kernel_syms	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_query_module	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_quotactl	AUE_QUOTACTL
>+#define	LINUX_SYS_AUE_linux_nfsservctl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_getpmsg	AUE_GETPMSG
>+#define	LINUX_SYS_AUE_linux_putpmsg	AUE_PUTPMSG
>+#define	LINUX_SYS_AUE_linux_afs_syscall	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_tuxcall	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_security	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_gettid	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_setxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_lsetxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fsetxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_getxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_lgetxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fgetxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_listxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_llistxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_flistxattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_removexattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_lremovexattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fremovexattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_tkill	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_time	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_sys_futex	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_sched_setaffinity	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_sched_getaffinity	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_set_thread_area	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_lookup_dcookie	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_epoll_create	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_epoll_ctl_old	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_epoll_wait_old	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_remap_file_pages	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_getdents64	AUE_GETDIRENTRIES
>+#define	LINUX_SYS_AUE_linux_set_tid_address	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_semtimedop	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fadvise64	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timer_create	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timer_settime	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timer_gettime	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timer_getoverrun	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timer_delete	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_clock_settime	AUE_CLOCK_SETTIME
>+#define	LINUX_SYS_AUE_linux_clock_gettime	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_clock_getres	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_clock_nanosleep	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_exit_group	AUE_EXIT
>+#define	LINUX_SYS_AUE_linux_epoll_wait	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_epoll_ctl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_tgkill	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_utimes	AUE_UTIMES
>+#define	LINUX_SYS_AUE_linux_mbind	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_set_mempolicy	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_get_mempolicy	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_mq_open	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_mq_unlink	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_mq_timedsend	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_mq_timedreceive	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_mq_notify	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_mq_getsetattr	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_kexec_load	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_waitid	AUE_WAIT6
>+#define	LINUX_SYS_AUE_linux_add_key	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_request_key	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_keyctl	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_ioprio_set	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_ioprio_get	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_inotify_init	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_inotify_add_watch	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_inotify_rm_watch	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_migrate_pages	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_openat	AUE_OPEN_RWTC
>+#define	LINUX_SYS_AUE_linux_mkdirat	AUE_MKDIRAT
>+#define	LINUX_SYS_AUE_linux_mknodat	AUE_MKNODAT
>+#define	LINUX_SYS_AUE_linux_fchownat	AUE_FCHOWNAT
>+#define	LINUX_SYS_AUE_linux_futimesat	AUE_FUTIMESAT
>+#define	LINUX_SYS_AUE_linux_newfstatat	AUE_FSTATAT
>+#define	LINUX_SYS_AUE_linux_unlinkat	AUE_UNLINKAT
>+#define	LINUX_SYS_AUE_linux_renameat	AUE_RENAMEAT
>+#define	LINUX_SYS_AUE_linux_linkat	AUE_LINKAT
>+#define	LINUX_SYS_AUE_linux_symlinkat	AUE_SYMLINKAT
>+#define	LINUX_SYS_AUE_linux_readlinkat	AUE_READLINKAT
>+#define	LINUX_SYS_AUE_linux_fchmodat	AUE_FCHMODAT
>+#define	LINUX_SYS_AUE_linux_faccessat	AUE_FACCESSAT
>+#define	LINUX_SYS_AUE_linux_pselect6	AUE_SELECT
>+#define	LINUX_SYS_AUE_linux_ppoll	AUE_POLL
>+#define	LINUX_SYS_AUE_linux_unshare	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_set_robust_list	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_get_robust_list	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_splice	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_tee	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_sync_file_range	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_vmsplice	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_move_pages	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_utimensat	AUE_FUTIMESAT
>+#define	LINUX_SYS_AUE_linux_epoll_pwait	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_signalfd	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timerfd	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_eventfd	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fallocate	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timerfd_settime	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_timerfd_gettime	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_accept4	AUE_ACCEPT
>+#define	LINUX_SYS_AUE_linux_signalfd4	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_eventfd2	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_epoll_create1	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_dup3	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_pipe2	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_inotify_init1	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_preadv	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_pwritev	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_rt_tsigqueueinfo	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_perf_event_open	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_recvmmsg	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fanotify_init	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_fanotify_mark	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_prlimit64	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_name_to_handle_at	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_open_by_handle_at	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_clock_adjtime	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_syncfs	AUE_SYNC
>+#define	LINUX_SYS_AUE_linux_sendmmsg	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_setns	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_process_vm_readv	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_process_vm_writev	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_kcmp	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_finit_module	AUE_NULL
>+
>+#undef PAD_
>+#undef PADL_
>+#undef PADR_
>+
>+#endif /* !_LINUX_SYSPROTO_H_ */
>Index: sys/amd64/linux/linux_support.s
>===================================================================
>--- sys/amd64/linux/linux_support.s	(revision 0)
>+++ sys/amd64/linux/linux_support.s	(working copy)
>@@ -0,0 +1,124 @@
>+/*-
>+ * Copyright (c) 2007 Konstantin Belousov
>+ * 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.
>+ * 4. Neither the name of the University nor the names of its contributors
>+ *    may be used to endorse or promote products derived from this software
>+ *    without specific prior written permission.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
>+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
>+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>+ * SUCH DAMAGE.
>+ *
>+ * $FreeBSD$
>+ */
>+
>+#include "linux_assym.h"		/* system definitions */
>+#include <machine/asmacros.h>		/* miscellaneous asm macros */
>+
>+#include "assym.s"
>+
>+futex_fault:
>+	movq	$0,PCB_ONFAULT(%r8)
>+	movl	$-EFAULT,%eax
>+	ret
>+
>+ENTRY(futex_xchgl)
>+	movq	PCPU(CURPCB),%r8
>+	movq	$futex_fault,PCB_ONFAULT(%r8)
>+	movq	$VM_MAXUSER_ADDRESS-4,%rax
>+	cmpq	%rax,%rsi
>+	ja	futex_fault
>+	xchgl	%edi,(%rsi)
>+	movl	%edi,(%rdx)
>+	xorl	%eax,%eax
>+	movq	%rax,PCB_ONFAULT(%r8)
>+	ret
>+
>+ENTRY(futex_addl)
>+	movq	PCPU(CURPCB),%r8
>+	movq	$futex_fault,PCB_ONFAULT(%r8)
>+	movq	$VM_MAXUSER_ADDRESS-4,%rax
>+	cmpq	%rax,%rsi
>+	ja	futex_fault
>+#ifdef SMP
>+	lock
>+#endif
>+	xaddl	%edi,(%rsi)
>+	movl	%edi,(%rdx)
>+	xorl	%eax,%eax
>+	movq	%rax,PCB_ONFAULT(%r8)
>+	ret
>+
>+ENTRY(futex_orl)
>+	movq	PCPU(CURPCB),%r8
>+	movq	$futex_fault,PCB_ONFAULT(%r8)
>+	movq	$VM_MAXUSER_ADDRESS-4,%rax
>+	cmpq	%rax,%rsi
>+	ja	futex_fault
>+	movl	(%rsi),%eax
>+1:	movl	%eax,%ecx
>+	orl	%edi,%ecx
>+#ifdef SMP
>+	lock
>+#endif
>+	cmpxchgl %ecx,(%rsi)
>+	jnz	1b
>+	movl	%eax,(%rdx)
>+	xorl	%eax,%eax
>+	movq	%rax,PCB_ONFAULT(%r8)
>+	ret
>+
>+ENTRY(futex_andl)
>+	movq	PCPU(CURPCB),%r8
>+	movq	$futex_fault,PCB_ONFAULT(%r8)
>+	movq	$VM_MAXUSER_ADDRESS-4,%rax
>+	cmpq	%rax,%rsi
>+	ja	futex_fault
>+	movl	(%rsi),%eax
>+1:	movl	%eax,%ecx
>+	andl	%edi,%ecx
>+#ifdef SMP
>+	lock
>+#endif
>+	cmpxchgl %ecx,(%rsi)
>+	jnz	1b
>+	movl	%eax,(%rdx)
>+	xorl	%eax,%eax
>+	movq	%rax,PCB_ONFAULT(%r8)
>+	ret
>+
>+ENTRY(futex_xorl)
>+	movq	PCPU(CURPCB),%r8
>+	movq	$futex_fault,PCB_ONFAULT(%r8)
>+	movq	$VM_MAXUSER_ADDRESS-4,%rax
>+	cmpq	%rax,%rsi
>+	ja	futex_fault
>+	movl	(%rsi),%eax
>+1:	movl	%eax,%ecx
>+	xorl	%edi,%ecx
>+#ifdef SMP
>+	lock
>+#endif
>+	cmpxchgl %ecx,(%rsi)
>+	jnz	1b
>+	movl	%eax,(%rdx)
>+	xorl	%eax,%eax
>+	movq	%rax,PCB_ONFAULT(%r8)
>+	ret
>Index: sys/amd64/linux/linux_syscall.h
>===================================================================
>--- sys/amd64/linux/linux_syscall.h	(revision 0)
>+++ sys/amd64/linux/linux_syscall.h	(working copy)
>@@ -0,0 +1,310 @@
>+/*
>+ * System call numbers.
>+ *
>+ * DO NOT EDIT-- this file is automatically generated.
>+ * $FreeBSD$
>+ * created from FreeBSD
>+ */
>+
>+#define	LINUX_SYS_read	0
>+#define	LINUX_SYS_write	1
>+#define	LINUX_SYS_linux_open	2
>+#define	LINUX_SYS_close	3
>+#define	LINUX_SYS_linux_newstat	4
>+#define	LINUX_SYS_linux_newfstat	5
>+#define	LINUX_SYS_linux_newlstat	6
>+#define	LINUX_SYS_poll	7
>+#define	LINUX_SYS_linux_lseek	8
>+#define	LINUX_SYS_linux_mmap2	9
>+#define	LINUX_SYS_linux_mprotect	10
>+#define	LINUX_SYS_munmap	11
>+#define	LINUX_SYS_linux_brk	12
>+#define	LINUX_SYS_linux_rt_sigaction	13
>+#define	LINUX_SYS_linux_rt_sigprocmask	14
>+#define	LINUX_SYS_linux_rt_sigreturn	15
>+#define	LINUX_SYS_linux_ioctl	16
>+#define	LINUX_SYS_linux_pread	17
>+#define	LINUX_SYS_linux_pwrite	18
>+#define	LINUX_SYS_readv	19
>+#define	LINUX_SYS_writev	20
>+#define	LINUX_SYS_linux_access	21
>+#define	LINUX_SYS_linux_pipe	22
>+#define	LINUX_SYS_linux_select	23
>+#define	LINUX_SYS_sched_yield	24
>+#define	LINUX_SYS_linux_mremap	25
>+#define	LINUX_SYS_linux_msync	26
>+#define	LINUX_SYS_linux_mincore	27
>+#define	LINUX_SYS_madvise	28
>+#define	LINUX_SYS_linux_shmget	29
>+#define	LINUX_SYS_linux_shmat	30
>+#define	LINUX_SYS_linux_shmctl	31
>+#define	LINUX_SYS_dup	32
>+#define	LINUX_SYS_dup2	33
>+#define	LINUX_SYS_linux_pause	34
>+#define	LINUX_SYS_linux_nanosleep	35
>+#define	LINUX_SYS_linux_getitimer	36
>+#define	LINUX_SYS_linux_alarm	37
>+#define	LINUX_SYS_linux_setitimer	38
>+#define	LINUX_SYS_linux_getpid	39
>+#define	LINUX_SYS_linux_sendfile	40
>+#define	LINUX_SYS_linux_socket	41
>+#define	LINUX_SYS_linux_connect	42
>+#define	LINUX_SYS_linux_accept	43
>+#define	LINUX_SYS_linux_sendto	44
>+#define	LINUX_SYS_linux_recvfrom	45
>+#define	LINUX_SYS_linux_sendmsg	46
>+#define	LINUX_SYS_linux_recvmsg	47
>+#define	LINUX_SYS_linux_shutdown	48
>+#define	LINUX_SYS_linux_bind	49
>+#define	LINUX_SYS_linux_listen	50
>+#define	LINUX_SYS_linux_getsockname	51
>+#define	LINUX_SYS_linux_getpeername	52
>+#define	LINUX_SYS_linux_socketpair	53
>+#define	LINUX_SYS_linux_setsockopt	54
>+#define	LINUX_SYS_linux_getsockopt	55
>+#define	LINUX_SYS_linux_clone	56
>+#define	LINUX_SYS_linux_fork	57
>+#define	LINUX_SYS_linux_vfork	58
>+#define	LINUX_SYS_linux_execve	59
>+#define	LINUX_SYS_linux_exit	60
>+#define	LINUX_SYS_linux_wait4	61
>+#define	LINUX_SYS_linux_kill	62
>+#define	LINUX_SYS_linux_newuname	63
>+#define	LINUX_SYS_linux_semget	64
>+#define	LINUX_SYS_linux_semop	65
>+#define	LINUX_SYS_linux_semctl	66
>+#define	LINUX_SYS_linux_shmdt	67
>+#define	LINUX_SYS_linux_msgget	68
>+#define	LINUX_SYS_linux_msgsnd	69
>+#define	LINUX_SYS_linux_msgrcv	70
>+#define	LINUX_SYS_linux_msgctl	71
>+#define	LINUX_SYS_linux_fcntl	72
>+#define	LINUX_SYS_flock	73
>+#define	LINUX_SYS_fsync	74
>+#define	LINUX_SYS_linux_fdatasync	75
>+#define	LINUX_SYS_linux_truncate	76
>+#define	LINUX_SYS_linux_ftruncate	77
>+#define	LINUX_SYS_linux_getdents	78
>+#define	LINUX_SYS_linux_getcwd	79
>+#define	LINUX_SYS_linux_chdir	80
>+#define	LINUX_SYS_fchdir	81
>+#define	LINUX_SYS_linux_rename	82
>+#define	LINUX_SYS_linux_mkdir	83
>+#define	LINUX_SYS_linux_rmdir	84
>+#define	LINUX_SYS_linux_creat	85
>+#define	LINUX_SYS_linux_link	86
>+#define	LINUX_SYS_linux_unlink	87
>+#define	LINUX_SYS_linux_symlink	88
>+#define	LINUX_SYS_linux_readlink	89
>+#define	LINUX_SYS_linux_chmod	90
>+#define	LINUX_SYS_fchmod	91
>+#define	LINUX_SYS_linux_chown	92
>+#define	LINUX_SYS_fchown	93
>+#define	LINUX_SYS_linux_lchown	94
>+#define	LINUX_SYS_umask	95
>+#define	LINUX_SYS_gettimeofday	96
>+#define	LINUX_SYS_linux_getrlimit	97
>+#define	LINUX_SYS_getrusage	98
>+#define	LINUX_SYS_linux_sysinfo	99
>+#define	LINUX_SYS_linux_times	100
>+#define	LINUX_SYS_linux_ptrace	101
>+#define	LINUX_SYS_linux_getuid	102
>+#define	LINUX_SYS_linux_syslog	103
>+#define	LINUX_SYS_linux_getgid	104
>+#define	LINUX_SYS_setuid	105
>+#define	LINUX_SYS_setgid	106
>+#define	LINUX_SYS_geteuid	107
>+#define	LINUX_SYS_getegid	108
>+#define	LINUX_SYS_setpgid	109
>+#define	LINUX_SYS_linux_getppid	110
>+#define	LINUX_SYS_getpgrp	111
>+#define	LINUX_SYS_setsid	112
>+#define	LINUX_SYS_setreuid	113
>+#define	LINUX_SYS_setregid	114
>+#define	LINUX_SYS_linux_getgroups	115
>+#define	LINUX_SYS_linux_setgroups	116
>+#define	LINUX_SYS_setresuid	117
>+#define	LINUX_SYS_getresuid	118
>+#define	LINUX_SYS_setresgid	119
>+#define	LINUX_SYS_getresgid	120
>+#define	LINUX_SYS_getpgid	121
>+#define	LINUX_SYS_linux_setfsuid	122
>+#define	LINUX_SYS_linux_setfsgid	123
>+#define	LINUX_SYS_linux_getsid	124
>+#define	LINUX_SYS_linux_capget	125
>+#define	LINUX_SYS_linux_capset	126
>+#define	LINUX_SYS_linux_rt_sigpending	127
>+#define	LINUX_SYS_linux_rt_sigtimedwait	128
>+#define	LINUX_SYS_linux_rt_sigqueueinfo	129
>+#define	LINUX_SYS_linux_rt_sigsuspend	130
>+#define	LINUX_SYS_linux_sigaltstack	131
>+#define	LINUX_SYS_linux_utime	132
>+#define	LINUX_SYS_linux_mknod	133
>+#define	LINUX_SYS_linux_personality	135
>+#define	LINUX_SYS_linux_ustat	136
>+#define	LINUX_SYS_linux_statfs	137
>+#define	LINUX_SYS_linux_fstatfs	138
>+#define	LINUX_SYS_linux_sysfs	139
>+#define	LINUX_SYS_linux_getpriority	140
>+#define	LINUX_SYS_setpriority	141
>+#define	LINUX_SYS_linux_sched_setparam	142
>+#define	LINUX_SYS_linux_sched_getparam	143
>+#define	LINUX_SYS_linux_sched_setscheduler	144
>+#define	LINUX_SYS_linux_sched_getscheduler	145
>+#define	LINUX_SYS_linux_sched_get_priority_max	146
>+#define	LINUX_SYS_linux_sched_get_priority_min	147
>+#define	LINUX_SYS_linux_sched_rr_get_interval	148
>+#define	LINUX_SYS_mlock	149
>+#define	LINUX_SYS_munlock	150
>+#define	LINUX_SYS_mlockall	151
>+#define	LINUX_SYS_munlockall	152
>+#define	LINUX_SYS_linux_vhangup	153
>+#define	LINUX_SYS_linux_pivot_root	155
>+#define	LINUX_SYS_linux_sysctl	156
>+#define	LINUX_SYS_linux_prctl	157
>+#define	LINUX_SYS_linux_arch_prctl	158
>+#define	LINUX_SYS_linux_adjtimex	159
>+#define	LINUX_SYS_linux_setrlimit	160
>+#define	LINUX_SYS_chroot	161
>+#define	LINUX_SYS_sync	162
>+#define	LINUX_SYS_acct	163
>+#define	LINUX_SYS_settimeofday	164
>+#define	LINUX_SYS_linux_mount	165
>+#define	LINUX_SYS_linux_umount	166
>+#define	LINUX_SYS_swapon	167
>+#define	LINUX_SYS_linux_swapoff	168
>+#define	LINUX_SYS_linux_reboot	169
>+#define	LINUX_SYS_linux_sethostname	170
>+#define	LINUX_SYS_linux_setdomainname	171
>+#define	LINUX_SYS_linux_iopl	172
>+#define	LINUX_SYS_linux_create_module	174
>+#define	LINUX_SYS_linux_init_module	175
>+#define	LINUX_SYS_linux_delete_module	176
>+#define	LINUX_SYS_linux_get_kernel_syms	177
>+#define	LINUX_SYS_linux_query_module	178
>+#define	LINUX_SYS_linux_quotactl	179
>+#define	LINUX_SYS_linux_nfsservctl	180
>+#define	LINUX_SYS_linux_getpmsg	181
>+#define	LINUX_SYS_linux_putpmsg	182
>+#define	LINUX_SYS_linux_afs_syscall	183
>+#define	LINUX_SYS_linux_tuxcall	184
>+#define	LINUX_SYS_linux_security	185
>+#define	LINUX_SYS_linux_gettid	186
>+#define	LINUX_SYS_linux_setxattr	188
>+#define	LINUX_SYS_linux_lsetxattr	189
>+#define	LINUX_SYS_linux_fsetxattr	190
>+#define	LINUX_SYS_linux_getxattr	191
>+#define	LINUX_SYS_linux_lgetxattr	192
>+#define	LINUX_SYS_linux_fgetxattr	193
>+#define	LINUX_SYS_linux_listxattr	194
>+#define	LINUX_SYS_linux_llistxattr	195
>+#define	LINUX_SYS_linux_flistxattr	196
>+#define	LINUX_SYS_linux_removexattr	197
>+#define	LINUX_SYS_linux_lremovexattr	198
>+#define	LINUX_SYS_linux_fremovexattr	199
>+#define	LINUX_SYS_linux_tkill	200
>+#define	LINUX_SYS_linux_time	201
>+#define	LINUX_SYS_linux_sys_futex	202
>+#define	LINUX_SYS_linux_sched_setaffinity	203
>+#define	LINUX_SYS_linux_sched_getaffinity	204
>+#define	LINUX_SYS_linux_set_thread_area	205
>+#define	LINUX_SYS_linux_lookup_dcookie	212
>+#define	LINUX_SYS_linux_epoll_create	213
>+#define	LINUX_SYS_linux_epoll_ctl_old	214
>+#define	LINUX_SYS_linux_epoll_wait_old	215
>+#define	LINUX_SYS_linux_remap_file_pages	216
>+#define	LINUX_SYS_linux_getdents64	217
>+#define	LINUX_SYS_linux_set_tid_address	218
>+#define	LINUX_SYS_linux_semtimedop	220
>+#define	LINUX_SYS_linux_fadvise64	221
>+#define	LINUX_SYS_linux_timer_create	222
>+#define	LINUX_SYS_linux_timer_settime	223
>+#define	LINUX_SYS_linux_timer_gettime	224
>+#define	LINUX_SYS_linux_timer_getoverrun	225
>+#define	LINUX_SYS_linux_timer_delete	226
>+#define	LINUX_SYS_linux_clock_settime	227
>+#define	LINUX_SYS_linux_clock_gettime	228
>+#define	LINUX_SYS_linux_clock_getres	229
>+#define	LINUX_SYS_linux_clock_nanosleep	230
>+#define	LINUX_SYS_linux_exit_group	231
>+#define	LINUX_SYS_linux_epoll_wait	232
>+#define	LINUX_SYS_linux_epoll_ctl	233
>+#define	LINUX_SYS_linux_tgkill	234
>+#define	LINUX_SYS_linux_utimes	235
>+#define	LINUX_SYS_linux_mbind	237
>+#define	LINUX_SYS_linux_set_mempolicy	238
>+#define	LINUX_SYS_linux_get_mempolicy	239
>+#define	LINUX_SYS_linux_mq_open	240
>+#define	LINUX_SYS_linux_mq_unlink	241
>+#define	LINUX_SYS_linux_mq_timedsend	242
>+#define	LINUX_SYS_linux_mq_timedreceive	243
>+#define	LINUX_SYS_linux_mq_notify	244
>+#define	LINUX_SYS_linux_mq_getsetattr	245
>+#define	LINUX_SYS_linux_kexec_load	246
>+#define	LINUX_SYS_linux_waitid	247
>+#define	LINUX_SYS_linux_add_key	248
>+#define	LINUX_SYS_linux_request_key	249
>+#define	LINUX_SYS_linux_keyctl	250
>+#define	LINUX_SYS_linux_ioprio_set	251
>+#define	LINUX_SYS_linux_ioprio_get	252
>+#define	LINUX_SYS_linux_inotify_init	253
>+#define	LINUX_SYS_linux_inotify_add_watch	254
>+#define	LINUX_SYS_linux_inotify_rm_watch	255
>+#define	LINUX_SYS_linux_migrate_pages	256
>+#define	LINUX_SYS_linux_openat	257
>+#define	LINUX_SYS_linux_mkdirat	258
>+#define	LINUX_SYS_linux_mknodat	259
>+#define	LINUX_SYS_linux_fchownat	260
>+#define	LINUX_SYS_linux_futimesat	261
>+#define	LINUX_SYS_linux_newfstatat	262
>+#define	LINUX_SYS_linux_unlinkat	263
>+#define	LINUX_SYS_linux_renameat	264
>+#define	LINUX_SYS_linux_linkat	265
>+#define	LINUX_SYS_linux_symlinkat	266
>+#define	LINUX_SYS_linux_readlinkat	267
>+#define	LINUX_SYS_linux_fchmodat	268
>+#define	LINUX_SYS_linux_faccessat	269
>+#define	LINUX_SYS_linux_pselect6	270
>+#define	LINUX_SYS_linux_ppoll	271
>+#define	LINUX_SYS_linux_unshare	272
>+#define	LINUX_SYS_linux_set_robust_list	273
>+#define	LINUX_SYS_linux_get_robust_list	274
>+#define	LINUX_SYS_linux_splice	275
>+#define	LINUX_SYS_linux_tee	276
>+#define	LINUX_SYS_linux_sync_file_range	277
>+#define	LINUX_SYS_linux_vmsplice	278
>+#define	LINUX_SYS_linux_move_pages	279
>+#define	LINUX_SYS_linux_utimensat	280
>+#define	LINUX_SYS_linux_epoll_pwait	281
>+#define	LINUX_SYS_linux_signalfd	282
>+#define	LINUX_SYS_linux_timerfd	283
>+#define	LINUX_SYS_linux_eventfd	284
>+#define	LINUX_SYS_linux_fallocate	285
>+#define	LINUX_SYS_linux_timerfd_settime	286
>+#define	LINUX_SYS_linux_timerfd_gettime	287
>+#define	LINUX_SYS_linux_accept4	288
>+#define	LINUX_SYS_linux_signalfd4	289
>+#define	LINUX_SYS_linux_eventfd2	290
>+#define	LINUX_SYS_linux_epoll_create1	291
>+#define	LINUX_SYS_linux_dup3	292
>+#define	LINUX_SYS_linux_pipe2	293
>+#define	LINUX_SYS_linux_inotify_init1	294
>+#define	LINUX_SYS_linux_preadv	295
>+#define	LINUX_SYS_linux_pwritev	296
>+#define	LINUX_SYS_linux_rt_tsigqueueinfo	297
>+#define	LINUX_SYS_linux_perf_event_open	298
>+#define	LINUX_SYS_linux_recvmmsg	299
>+#define	LINUX_SYS_linux_fanotify_init	300
>+#define	LINUX_SYS_linux_fanotify_mark	301
>+#define	LINUX_SYS_linux_prlimit64	302
>+#define	LINUX_SYS_linux_name_to_handle_at	303
>+#define	LINUX_SYS_linux_open_by_handle_at	304
>+#define	LINUX_SYS_linux_clock_adjtime	305
>+#define	LINUX_SYS_linux_syncfs	306
>+#define	LINUX_SYS_linux_sendmmsg	307
>+#define	LINUX_SYS_linux_setns	308
>+#define	LINUX_SYS_linux_process_vm_readv	309
>+#define	LINUX_SYS_linux_process_vm_writev	310
>+#define	LINUX_SYS_linux_kcmp	311
>+#define	LINUX_SYS_linux_finit_module	312
>+#define	LINUX_SYS_MAXSYSCALL	314
>Index: sys/amd64/linux/linux_syscalls.c
>===================================================================
>--- sys/amd64/linux/linux_syscalls.c	(revision 0)
>+++ sys/amd64/linux/linux_syscalls.c	(working copy)
>@@ -0,0 +1,325 @@
>+/*
>+ * System call names.
>+ *
>+ * DO NOT EDIT-- this file is automatically generated.
>+ * $FreeBSD$
>+ * created from FreeBSD
>+ */
>+
>+const char *linux_syscallnames[] = {
>+#define	nosys	linux_nosys
>+	"read",			/* 0 = read */
>+	"write",			/* 1 = write */
>+	"linux_open",			/* 2 = linux_open */
>+	"close",			/* 3 = close */
>+	"linux_newstat",			/* 4 = linux_newstat */
>+	"linux_newfstat",			/* 5 = linux_newfstat */
>+	"linux_newlstat",			/* 6 = linux_newlstat */
>+	"poll",			/* 7 = poll */
>+	"linux_lseek",			/* 8 = linux_lseek */
>+	"linux_mmap2",			/* 9 = linux_mmap2 */
>+	"linux_mprotect",			/* 10 = linux_mprotect */
>+	"munmap",			/* 11 = munmap */
>+	"linux_brk",			/* 12 = linux_brk */
>+	"linux_rt_sigaction",			/* 13 = linux_rt_sigaction */
>+	"linux_rt_sigprocmask",			/* 14 = linux_rt_sigprocmask */
>+	"linux_rt_sigreturn",			/* 15 = linux_rt_sigreturn */
>+	"linux_ioctl",			/* 16 = linux_ioctl */
>+	"linux_pread",			/* 17 = linux_pread */
>+	"linux_pwrite",			/* 18 = linux_pwrite */
>+	"readv",			/* 19 = readv */
>+	"writev",			/* 20 = writev */
>+	"linux_access",			/* 21 = linux_access */
>+	"linux_pipe",			/* 22 = linux_pipe */
>+	"linux_select",			/* 23 = linux_select */
>+	"sched_yield",			/* 24 = sched_yield */
>+	"linux_mremap",			/* 25 = linux_mremap */
>+	"linux_msync",			/* 26 = linux_msync */
>+	"linux_mincore",			/* 27 = linux_mincore */
>+	"madvise",			/* 28 = madvise */
>+	"linux_shmget",			/* 29 = linux_shmget */
>+	"linux_shmat",			/* 30 = linux_shmat */
>+	"linux_shmctl",			/* 31 = linux_shmctl */
>+	"dup",			/* 32 = dup */
>+	"dup2",			/* 33 = dup2 */
>+	"linux_pause",			/* 34 = linux_pause */
>+	"linux_nanosleep",			/* 35 = linux_nanosleep */
>+	"linux_getitimer",			/* 36 = linux_getitimer */
>+	"linux_alarm",			/* 37 = linux_alarm */
>+	"linux_setitimer",			/* 38 = linux_setitimer */
>+	"linux_getpid",			/* 39 = linux_getpid */
>+	"linux_sendfile",			/* 40 = linux_sendfile */
>+	"linux_socket",			/* 41 = linux_socket */
>+	"linux_connect",			/* 42 = linux_connect */
>+	"linux_accept",			/* 43 = linux_accept */
>+	"linux_sendto",			/* 44 = linux_sendto */
>+	"linux_recvfrom",			/* 45 = linux_recvfrom */
>+	"linux_sendmsg",			/* 46 = linux_sendmsg */
>+	"linux_recvmsg",			/* 47 = linux_recvmsg */
>+	"linux_shutdown",			/* 48 = linux_shutdown */
>+	"linux_bind",			/* 49 = linux_bind */
>+	"linux_listen",			/* 50 = linux_listen */
>+	"linux_getsockname",			/* 51 = linux_getsockname */
>+	"linux_getpeername",			/* 52 = linux_getpeername */
>+	"linux_socketpair",			/* 53 = linux_socketpair */
>+	"linux_setsockopt",			/* 54 = linux_setsockopt */
>+	"linux_getsockopt",			/* 55 = linux_getsockopt */
>+	"linux_clone",			/* 56 = linux_clone */
>+	"linux_fork",			/* 57 = linux_fork */
>+	"linux_vfork",			/* 58 = linux_vfork */
>+	"linux_execve",			/* 59 = linux_execve */
>+	"linux_exit",			/* 60 = linux_exit */
>+	"linux_wait4",			/* 61 = linux_wait4 */
>+	"linux_kill",			/* 62 = linux_kill */
>+	"linux_newuname",			/* 63 = linux_newuname */
>+	"linux_semget",			/* 64 = linux_semget */
>+	"linux_semop",			/* 65 = linux_semop */
>+	"linux_semctl",			/* 66 = linux_semctl */
>+	"linux_shmdt",			/* 67 = linux_shmdt */
>+	"linux_msgget",			/* 68 = linux_msgget */
>+	"linux_msgsnd",			/* 69 = linux_msgsnd */
>+	"linux_msgrcv",			/* 70 = linux_msgrcv */
>+	"linux_msgctl",			/* 71 = linux_msgctl */
>+	"linux_fcntl",			/* 72 = linux_fcntl */
>+	"flock",			/* 73 = flock */
>+	"fsync",			/* 74 = fsync */
>+	"linux_fdatasync",			/* 75 = linux_fdatasync */
>+	"linux_truncate",			/* 76 = linux_truncate */
>+	"linux_ftruncate",			/* 77 = linux_ftruncate */
>+	"linux_getdents",			/* 78 = linux_getdents */
>+	"linux_getcwd",			/* 79 = linux_getcwd */
>+	"linux_chdir",			/* 80 = linux_chdir */
>+	"fchdir",			/* 81 = fchdir */
>+	"linux_rename",			/* 82 = linux_rename */
>+	"linux_mkdir",			/* 83 = linux_mkdir */
>+	"linux_rmdir",			/* 84 = linux_rmdir */
>+	"linux_creat",			/* 85 = linux_creat */
>+	"linux_link",			/* 86 = linux_link */
>+	"linux_unlink",			/* 87 = linux_unlink */
>+	"linux_symlink",			/* 88 = linux_symlink */
>+	"linux_readlink",			/* 89 = linux_readlink */
>+	"linux_chmod",			/* 90 = linux_chmod */
>+	"fchmod",			/* 91 = fchmod */
>+	"linux_chown",			/* 92 = linux_chown */
>+	"fchown",			/* 93 = fchown */
>+	"linux_lchown",			/* 94 = linux_lchown */
>+	"umask",			/* 95 = umask */
>+	"gettimeofday",			/* 96 = gettimeofday */
>+	"linux_getrlimit",			/* 97 = linux_getrlimit */
>+	"getrusage",			/* 98 = getrusage */
>+	"linux_sysinfo",			/* 99 = linux_sysinfo */
>+	"linux_times",			/* 100 = linux_times */
>+	"linux_ptrace",			/* 101 = linux_ptrace */
>+	"linux_getuid",			/* 102 = linux_getuid */
>+	"linux_syslog",			/* 103 = linux_syslog */
>+	"linux_getgid",			/* 104 = linux_getgid */
>+	"setuid",			/* 105 = setuid */
>+	"setgid",			/* 106 = setgid */
>+	"geteuid",			/* 107 = geteuid */
>+	"getegid",			/* 108 = getegid */
>+	"setpgid",			/* 109 = setpgid */
>+	"linux_getppid",			/* 110 = linux_getppid */
>+	"getpgrp",			/* 111 = getpgrp */
>+	"setsid",			/* 112 = setsid */
>+	"setreuid",			/* 113 = setreuid */
>+	"setregid",			/* 114 = setregid */
>+	"linux_getgroups",			/* 115 = linux_getgroups */
>+	"linux_setgroups",			/* 116 = linux_setgroups */
>+	"setresuid",			/* 117 = setresuid */
>+	"getresuid",			/* 118 = getresuid */
>+	"setresgid",			/* 119 = setresgid */
>+	"getresgid",			/* 120 = getresgid */
>+	"getpgid",			/* 121 = getpgid */
>+	"linux_setfsuid",			/* 122 = linux_setfsuid */
>+	"linux_setfsgid",			/* 123 = linux_setfsgid */
>+	"linux_getsid",			/* 124 = linux_getsid */
>+	"linux_capget",			/* 125 = linux_capget */
>+	"linux_capset",			/* 126 = linux_capset */
>+	"linux_rt_sigpending",			/* 127 = linux_rt_sigpending */
>+	"linux_rt_sigtimedwait",			/* 128 = linux_rt_sigtimedwait */
>+	"linux_rt_sigqueueinfo",			/* 129 = linux_rt_sigqueueinfo */
>+	"linux_rt_sigsuspend",			/* 130 = linux_rt_sigsuspend */
>+	"linux_sigaltstack",			/* 131 = linux_sigaltstack */
>+	"linux_utime",			/* 132 = linux_utime */
>+	"linux_mknod",			/* 133 = linux_mknod */
>+	"#134",			/* 134 = uselib */
>+	"linux_personality",			/* 135 = linux_personality */
>+	"linux_ustat",			/* 136 = linux_ustat */
>+	"linux_statfs",			/* 137 = linux_statfs */
>+	"linux_fstatfs",			/* 138 = linux_fstatfs */
>+	"linux_sysfs",			/* 139 = linux_sysfs */
>+	"linux_getpriority",			/* 140 = linux_getpriority */
>+	"setpriority",			/* 141 = setpriority */
>+	"linux_sched_setparam",			/* 142 = linux_sched_setparam */
>+	"linux_sched_getparam",			/* 143 = linux_sched_getparam */
>+	"linux_sched_setscheduler",			/* 144 = linux_sched_setscheduler */
>+	"linux_sched_getscheduler",			/* 145 = linux_sched_getscheduler */
>+	"linux_sched_get_priority_max",			/* 146 = linux_sched_get_priority_max */
>+	"linux_sched_get_priority_min",			/* 147 = linux_sched_get_priority_min */
>+	"linux_sched_rr_get_interval",			/* 148 = linux_sched_rr_get_interval */
>+	"mlock",			/* 149 = mlock */
>+	"munlock",			/* 150 = munlock */
>+	"mlockall",			/* 151 = mlockall */
>+	"munlockall",			/* 152 = munlockall */
>+	"linux_vhangup",			/* 153 = linux_vhangup */
>+	"#154",			/* 154 = modify_ldt */
>+	"linux_pivot_root",			/* 155 = linux_pivot_root */
>+	"linux_sysctl",			/* 156 = linux_sysctl */
>+	"linux_prctl",			/* 157 = linux_prctl */
>+	"linux_arch_prctl",			/* 158 = linux_arch_prctl */
>+	"linux_adjtimex",			/* 159 = linux_adjtimex */
>+	"linux_setrlimit",			/* 160 = linux_setrlimit */
>+	"chroot",			/* 161 = chroot */
>+	"sync",			/* 162 = sync */
>+	"acct",			/* 163 = acct */
>+	"settimeofday",			/* 164 = settimeofday */
>+	"linux_mount",			/* 165 = linux_mount */
>+	"linux_umount",			/* 166 = linux_umount */
>+	"swapon",			/* 167 = swapon */
>+	"linux_swapoff",			/* 168 = linux_swapoff */
>+	"linux_reboot",			/* 169 = linux_reboot */
>+	"linux_sethostname",			/* 170 = linux_sethostname */
>+	"linux_setdomainname",			/* 171 = linux_setdomainname */
>+	"linux_iopl",			/* 172 = linux_iopl */
>+	"#173",			/* 173 = ioperm */
>+	"linux_create_module",			/* 174 = linux_create_module */
>+	"linux_init_module",			/* 175 = linux_init_module */
>+	"linux_delete_module",			/* 176 = linux_delete_module */
>+	"linux_get_kernel_syms",			/* 177 = linux_get_kernel_syms */
>+	"linux_query_module",			/* 178 = linux_query_module */
>+	"linux_quotactl",			/* 179 = linux_quotactl */
>+	"linux_nfsservctl",			/* 180 = linux_nfsservctl */
>+	"linux_getpmsg",			/* 181 = linux_getpmsg */
>+	"linux_putpmsg",			/* 182 = linux_putpmsg */
>+	"linux_afs_syscall",			/* 183 = linux_afs_syscall */
>+	"linux_tuxcall",			/* 184 = linux_tuxcall */
>+	"linux_security",			/* 185 = linux_security */
>+	"linux_gettid",			/* 186 = linux_gettid */
>+	"#187",			/* 187 = linux_readahead */
>+	"linux_setxattr",			/* 188 = linux_setxattr */
>+	"linux_lsetxattr",			/* 189 = linux_lsetxattr */
>+	"linux_fsetxattr",			/* 190 = linux_fsetxattr */
>+	"linux_getxattr",			/* 191 = linux_getxattr */
>+	"linux_lgetxattr",			/* 192 = linux_lgetxattr */
>+	"linux_fgetxattr",			/* 193 = linux_fgetxattr */
>+	"linux_listxattr",			/* 194 = linux_listxattr */
>+	"linux_llistxattr",			/* 195 = linux_llistxattr */
>+	"linux_flistxattr",			/* 196 = linux_flistxattr */
>+	"linux_removexattr",			/* 197 = linux_removexattr */
>+	"linux_lremovexattr",			/* 198 = linux_lremovexattr */
>+	"linux_fremovexattr",			/* 199 = linux_fremovexattr */
>+	"linux_tkill",			/* 200 = linux_tkill */
>+	"linux_time",			/* 201 = linux_time */
>+	"linux_sys_futex",			/* 202 = linux_sys_futex */
>+	"linux_sched_setaffinity",			/* 203 = linux_sched_setaffinity */
>+	"linux_sched_getaffinity",			/* 204 = linux_sched_getaffinity */
>+	"linux_set_thread_area",			/* 205 = linux_set_thread_area */
>+	"#206",			/* 206 = linux_io_setup */
>+	"#207",			/* 207 = linux_io_destroy */
>+	"#208",			/* 208 = linux_io_getevents */
>+	"#209",			/* 209 = inux_io_submit */
>+	"#210",			/* 210 = linux_io_cancel */
>+	"#211",			/* 211 = linux_get_thread_area */
>+	"linux_lookup_dcookie",			/* 212 = linux_lookup_dcookie */
>+	"linux_epoll_create",			/* 213 = linux_epoll_create */
>+	"linux_epoll_ctl_old",			/* 214 = linux_epoll_ctl_old */
>+	"linux_epoll_wait_old",			/* 215 = linux_epoll_wait_old */
>+	"linux_remap_file_pages",			/* 216 = linux_remap_file_pages */
>+	"linux_getdents64",			/* 217 = linux_getdents64 */
>+	"linux_set_tid_address",			/* 218 = linux_set_tid_address */
>+	"#219",			/* 219 = restart_syscall */
>+	"linux_semtimedop",			/* 220 = linux_semtimedop */
>+	"linux_fadvise64",			/* 221 = linux_fadvise64 */
>+	"linux_timer_create",			/* 222 = linux_timer_create */
>+	"linux_timer_settime",			/* 223 = linux_timer_settime */
>+	"linux_timer_gettime",			/* 224 = linux_timer_gettime */
>+	"linux_timer_getoverrun",			/* 225 = linux_timer_getoverrun */
>+	"linux_timer_delete",			/* 226 = linux_timer_delete */
>+	"linux_clock_settime",			/* 227 = linux_clock_settime */
>+	"linux_clock_gettime",			/* 228 = linux_clock_gettime */
>+	"linux_clock_getres",			/* 229 = linux_clock_getres */
>+	"linux_clock_nanosleep",			/* 230 = linux_clock_nanosleep */
>+	"linux_exit_group",			/* 231 = linux_exit_group */
>+	"linux_epoll_wait",			/* 232 = linux_epoll_wait */
>+	"linux_epoll_ctl",			/* 233 = linux_epoll_ctl */
>+	"linux_tgkill",			/* 234 = linux_tgkill */
>+	"linux_utimes",			/* 235 = linux_utimes */
>+	"#236",			/* 236 = vserver */
>+	"linux_mbind",			/* 237 = linux_mbind */
>+	"linux_set_mempolicy",			/* 238 = linux_set_mempolicy */
>+	"linux_get_mempolicy",			/* 239 = linux_get_mempolicy */
>+	"linux_mq_open",			/* 240 = linux_mq_open */
>+	"linux_mq_unlink",			/* 241 = linux_mq_unlink */
>+	"linux_mq_timedsend",			/* 242 = linux_mq_timedsend */
>+	"linux_mq_timedreceive",			/* 243 = linux_mq_timedreceive */
>+	"linux_mq_notify",			/* 244 = linux_mq_notify */
>+	"linux_mq_getsetattr",			/* 245 = linux_mq_getsetattr */
>+	"linux_kexec_load",			/* 246 = linux_kexec_load */
>+	"linux_waitid",			/* 247 = linux_waitid */
>+	"linux_add_key",			/* 248 = linux_add_key */
>+	"linux_request_key",			/* 249 = linux_request_key */
>+	"linux_keyctl",			/* 250 = linux_keyctl */
>+	"linux_ioprio_set",			/* 251 = linux_ioprio_set */
>+	"linux_ioprio_get",			/* 252 = linux_ioprio_get */
>+	"linux_inotify_init",			/* 253 = linux_inotify_init */
>+	"linux_inotify_add_watch",			/* 254 = linux_inotify_add_watch */
>+	"linux_inotify_rm_watch",			/* 255 = linux_inotify_rm_watch */
>+	"linux_migrate_pages",			/* 256 = linux_migrate_pages */
>+	"linux_openat",			/* 257 = linux_openat */
>+	"linux_mkdirat",			/* 258 = linux_mkdirat */
>+	"linux_mknodat",			/* 259 = linux_mknodat */
>+	"linux_fchownat",			/* 260 = linux_fchownat */
>+	"linux_futimesat",			/* 261 = linux_futimesat */
>+	"linux_newfstatat",			/* 262 = linux_newfstatat */
>+	"linux_unlinkat",			/* 263 = linux_unlinkat */
>+	"linux_renameat",			/* 264 = linux_renameat */
>+	"linux_linkat",			/* 265 = linux_linkat */
>+	"linux_symlinkat",			/* 266 = linux_symlinkat */
>+	"linux_readlinkat",			/* 267 = linux_readlinkat */
>+	"linux_fchmodat",			/* 268 = linux_fchmodat */
>+	"linux_faccessat",			/* 269 = linux_faccessat */
>+	"linux_pselect6",			/* 270 = linux_pselect6 */
>+	"linux_ppoll",			/* 271 = linux_ppoll */
>+	"linux_unshare",			/* 272 = linux_unshare */
>+	"linux_set_robust_list",			/* 273 = linux_set_robust_list */
>+	"linux_get_robust_list",			/* 274 = linux_get_robust_list */
>+	"linux_splice",			/* 275 = linux_splice */
>+	"linux_tee",			/* 276 = linux_tee */
>+	"linux_sync_file_range",			/* 277 = linux_sync_file_range */
>+	"linux_vmsplice",			/* 278 = linux_vmsplice */
>+	"linux_move_pages",			/* 279 = linux_move_pages */
>+	"linux_utimensat",			/* 280 = linux_utimensat */
>+	"linux_epoll_pwait",			/* 281 = linux_epoll_pwait */
>+	"linux_signalfd",			/* 282 = linux_signalfd */
>+	"linux_timerfd",			/* 283 = linux_timerfd */
>+	"linux_eventfd",			/* 284 = linux_eventfd */
>+	"linux_fallocate",			/* 285 = linux_fallocate */
>+	"linux_timerfd_settime",			/* 286 = linux_timerfd_settime */
>+	"linux_timerfd_gettime",			/* 287 = linux_timerfd_gettime */
>+	"linux_accept4",			/* 288 = linux_accept4 */
>+	"linux_signalfd4",			/* 289 = linux_signalfd4 */
>+	"linux_eventfd2",			/* 290 = linux_eventfd2 */
>+	"linux_epoll_create1",			/* 291 = linux_epoll_create1 */
>+	"linux_dup3",			/* 292 = linux_dup3 */
>+	"linux_pipe2",			/* 293 = linux_pipe2 */
>+	"linux_inotify_init1",			/* 294 = linux_inotify_init1 */
>+	"linux_preadv",			/* 295 = linux_preadv */
>+	"linux_pwritev",			/* 296 = linux_pwritev */
>+	"linux_rt_tsigqueueinfo",			/* 297 = linux_rt_tsigqueueinfo */
>+	"linux_perf_event_open",			/* 298 = linux_perf_event_open */
>+	"linux_recvmmsg",			/* 299 = linux_recvmmsg */
>+	"linux_fanotify_init",			/* 300 = linux_fanotify_init */
>+	"linux_fanotify_mark",			/* 301 = linux_fanotify_mark */
>+	"linux_prlimit64",			/* 302 = linux_prlimit64 */
>+	"linux_name_to_handle_at",			/* 303 = linux_name_to_handle_at */
>+	"linux_open_by_handle_at",			/* 304 = linux_open_by_handle_at */
>+	"linux_clock_adjtime",			/* 305 = linux_clock_adjtime */
>+	"linux_syncfs",			/* 306 = linux_syncfs */
>+	"linux_sendmmsg",			/* 307 = linux_sendmmsg */
>+	"linux_setns",			/* 308 = linux_setns */
>+	"linux_process_vm_readv",			/* 309 = linux_process_vm_readv */
>+	"linux_process_vm_writev",			/* 310 = linux_process_vm_writev */
>+	"linux_kcmp",			/* 311 = linux_kcmp */
>+	"linux_finit_module",			/* 312 = linux_finit_module */
>+	"#313",			/* 313 = nosys */
>+};
>Index: sys/amd64/linux/linux_sysent.c
>===================================================================
>--- sys/amd64/linux/linux_sysent.c	(revision 0)
>+++ sys/amd64/linux/linux_sysent.c	(working copy)
>@@ -0,0 +1,335 @@
>+/*
>+ * System call switch table.
>+ *
>+ * DO NOT EDIT-- this file is automatically generated.
>+ * $FreeBSD$
>+ * created from FreeBSD
>+ */
>+
>+#include <sys/param.h>
>+#include <sys/sysent.h>
>+#include <sys/sysproto.h>
>+#include <compat/linux/linux_sysproto.h>
>+#include <amd64/linux/linux.h>
>+#include <amd64/linux/linux_proto.h>
>+
>+#define AS(name) (sizeof(struct name) / sizeof(register_t))
>+
>+/* The casts are bogus but will do for now. */
>+struct sysent linux_sysent[] = {
>+#define	nosys	linux_nosys
>+	{ AS(read_args), (sy_call_t *)sys_read, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 0 = read */
>+	{ AS(write_args), (sy_call_t *)sys_write, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 1 = write */
>+	{ AS(linux_open_args), (sy_call_t *)linux_open, AUE_OPEN_RWTC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 2 = linux_open */
>+	{ AS(close_args), (sy_call_t *)sys_close, AUE_CLOSE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 3 = close */
>+	{ AS(linux_newstat_args), (sy_call_t *)linux_newstat, AUE_STAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 4 = linux_newstat */
>+	{ AS(linux_newfstat_args), (sy_call_t *)linux_newfstat, AUE_FSTAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 5 = linux_newfstat */
>+	{ AS(linux_newlstat_args), (sy_call_t *)linux_newlstat, AUE_LSTAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 6 = linux_newlstat */
>+	{ AS(poll_args), (sy_call_t *)sys_poll, AUE_POLL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 7 = poll */
>+	{ AS(linux_lseek_args), (sy_call_t *)linux_lseek, AUE_LSEEK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 8 = linux_lseek */
>+	{ AS(linux_mmap2_args), (sy_call_t *)linux_mmap2, AUE_MMAP, NULL, 0, 0, 0, SY_THR_STATIC },	/* 9 = linux_mmap2 */
>+	{ AS(linux_mprotect_args), (sy_call_t *)linux_mprotect, AUE_MPROTECT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 10 = linux_mprotect */
>+	{ AS(munmap_args), (sy_call_t *)sys_munmap, AUE_MUNMAP, NULL, 0, 0, 0, SY_THR_STATIC },	/* 11 = munmap */
>+	{ AS(linux_brk_args), (sy_call_t *)linux_brk, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 12 = linux_brk */
>+	{ AS(linux_rt_sigaction_args), (sy_call_t *)linux_rt_sigaction, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 13 = linux_rt_sigaction */
>+	{ AS(linux_rt_sigprocmask_args), (sy_call_t *)linux_rt_sigprocmask, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 14 = linux_rt_sigprocmask */
>+	{ AS(linux_rt_sigreturn_args), (sy_call_t *)linux_rt_sigreturn, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 15 = linux_rt_sigreturn */
>+	{ AS(linux_ioctl_args), (sy_call_t *)linux_ioctl, AUE_IOCTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 16 = linux_ioctl */
>+	{ AS(linux_pread_args), (sy_call_t *)linux_pread, AUE_PREAD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 17 = linux_pread */
>+	{ AS(linux_pwrite_args), (sy_call_t *)linux_pwrite, AUE_PWRITE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 18 = linux_pwrite */
>+	{ AS(readv_args), (sy_call_t *)sys_readv, AUE_READV, NULL, 0, 0, 0, SY_THR_STATIC },	/* 19 = readv */
>+	{ AS(writev_args), (sy_call_t *)sys_writev, AUE_WRITEV, NULL, 0, 0, 0, SY_THR_STATIC },	/* 20 = writev */
>+	{ AS(linux_access_args), (sy_call_t *)linux_access, AUE_ACCESS, NULL, 0, 0, 0, SY_THR_STATIC },	/* 21 = linux_access */
>+	{ AS(linux_pipe_args), (sy_call_t *)linux_pipe, AUE_PIPE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 22 = linux_pipe */
>+	{ AS(linux_select_args), (sy_call_t *)linux_select, AUE_SELECT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 23 = linux_select */
>+	{ 0, (sy_call_t *)sys_sched_yield, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 24 = sched_yield */
>+	{ AS(linux_mremap_args), (sy_call_t *)linux_mremap, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 25 = linux_mremap */
>+	{ AS(linux_msync_args), (sy_call_t *)linux_msync, AUE_MSYNC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 26 = linux_msync */
>+	{ AS(linux_mincore_args), (sy_call_t *)linux_mincore, AUE_MINCORE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 27 = linux_mincore */
>+	{ AS(madvise_args), (sy_call_t *)sys_madvise, AUE_MADVISE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 28 = madvise */
>+	{ AS(linux_shmget_args), (sy_call_t *)linux_shmget, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 29 = linux_shmget */
>+	{ AS(linux_shmat_args), (sy_call_t *)linux_shmat, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 30 = linux_shmat */
>+	{ AS(linux_shmctl_args), (sy_call_t *)linux_shmctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 31 = linux_shmctl */
>+	{ AS(dup_args), (sy_call_t *)sys_dup, AUE_DUP, NULL, 0, 0, 0, SY_THR_STATIC },	/* 32 = dup */
>+	{ AS(dup2_args), (sy_call_t *)sys_dup2, AUE_DUP2, NULL, 0, 0, 0, SY_THR_STATIC },	/* 33 = dup2 */
>+	{ 0, (sy_call_t *)linux_pause, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 34 = linux_pause */
>+	{ AS(linux_nanosleep_args), (sy_call_t *)linux_nanosleep, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 35 = linux_nanosleep */
>+	{ AS(linux_getitimer_args), (sy_call_t *)linux_getitimer, AUE_GETITIMER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 36 = linux_getitimer */
>+	{ AS(linux_alarm_args), (sy_call_t *)linux_alarm, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 37 = linux_alarm */
>+	{ AS(linux_setitimer_args), (sy_call_t *)linux_setitimer, AUE_SETITIMER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 38 = linux_setitimer */
>+	{ 0, (sy_call_t *)linux_getpid, AUE_GETPID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 39 = linux_getpid */
>+	{ AS(linux_sendfile_args), (sy_call_t *)linux_sendfile, AUE_SENDFILE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 40 = linux_sendfile */
>+	{ AS(linux_socket_args), (sy_call_t *)linux_socket, AUE_SOCKET, NULL, 0, 0, 0, SY_THR_STATIC },	/* 41 = linux_socket */
>+	{ AS(linux_connect_args), (sy_call_t *)linux_connect, AUE_CONNECT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 42 = linux_connect */
>+	{ AS(linux_accept_args), (sy_call_t *)linux_accept, AUE_ACCEPT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 43 = linux_accept */
>+	{ AS(linux_sendto_args), (sy_call_t *)linux_sendto, AUE_SENDTO, NULL, 0, 0, 0, SY_THR_STATIC },	/* 44 = linux_sendto */
>+	{ AS(linux_recvfrom_args), (sy_call_t *)linux_recvfrom, AUE_RECVFROM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 45 = linux_recvfrom */
>+	{ AS(linux_sendmsg_args), (sy_call_t *)linux_sendmsg, AUE_SENDMSG, NULL, 0, 0, 0, SY_THR_STATIC },	/* 46 = linux_sendmsg */
>+	{ AS(linux_recvmsg_args), (sy_call_t *)linux_recvmsg, AUE_RECVMSG, NULL, 0, 0, 0, SY_THR_STATIC },	/* 47 = linux_recvmsg */
>+	{ AS(linux_shutdown_args), (sy_call_t *)linux_shutdown, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 48 = linux_shutdown */
>+	{ AS(linux_bind_args), (sy_call_t *)linux_bind, AUE_BIND, NULL, 0, 0, 0, SY_THR_STATIC },	/* 49 = linux_bind */
>+	{ AS(linux_listen_args), (sy_call_t *)linux_listen, AUE_LISTEN, NULL, 0, 0, 0, SY_THR_STATIC },	/* 50 = linux_listen */
>+	{ AS(linux_getsockname_args), (sy_call_t *)linux_getsockname, AUE_GETSOCKNAME, NULL, 0, 0, 0, SY_THR_STATIC },	/* 51 = linux_getsockname */
>+	{ AS(linux_getpeername_args), (sy_call_t *)linux_getpeername, AUE_GETPEERNAME, NULL, 0, 0, 0, SY_THR_STATIC },	/* 52 = linux_getpeername */
>+	{ AS(linux_socketpair_args), (sy_call_t *)linux_socketpair, AUE_SOCKETPAIR, NULL, 0, 0, 0, SY_THR_STATIC },	/* 53 = linux_socketpair */
>+	{ AS(linux_setsockopt_args), (sy_call_t *)linux_setsockopt, AUE_SETSOCKOPT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 54 = linux_setsockopt */
>+	{ AS(linux_getsockopt_args), (sy_call_t *)linux_getsockopt, AUE_GETSOCKOPT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 55 = linux_getsockopt */
>+	{ AS(linux_clone_args), (sy_call_t *)linux_clone, AUE_RFORK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 56 = linux_clone */
>+	{ 0, (sy_call_t *)linux_fork, AUE_FORK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 57 = linux_fork */
>+	{ 0, (sy_call_t *)linux_vfork, AUE_VFORK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 58 = linux_vfork */
>+	{ AS(linux_execve_args), (sy_call_t *)linux_execve, AUE_EXECVE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 59 = linux_execve */
>+	{ AS(linux_exit_args), (sy_call_t *)linux_exit, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 60 = linux_exit */
>+	{ AS(linux_wait4_args), (sy_call_t *)linux_wait4, AUE_WAIT4, NULL, 0, 0, 0, SY_THR_STATIC },	/* 61 = linux_wait4 */
>+	{ AS(linux_kill_args), (sy_call_t *)linux_kill, AUE_KILL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 62 = linux_kill */
>+	{ AS(linux_newuname_args), (sy_call_t *)linux_newuname, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 63 = linux_newuname */
>+	{ AS(linux_semget_args), (sy_call_t *)linux_semget, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 64 = linux_semget */
>+	{ AS(linux_semop_args), (sy_call_t *)linux_semop, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 65 = linux_semop */
>+	{ AS(linux_semctl_args), (sy_call_t *)linux_semctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 66 = linux_semctl */
>+	{ AS(linux_shmdt_args), (sy_call_t *)linux_shmdt, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 67 = linux_shmdt */
>+	{ AS(linux_msgget_args), (sy_call_t *)linux_msgget, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 68 = linux_msgget */
>+	{ AS(linux_msgsnd_args), (sy_call_t *)linux_msgsnd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 69 = linux_msgsnd */
>+	{ AS(linux_msgrcv_args), (sy_call_t *)linux_msgrcv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 70 = linux_msgrcv */
>+	{ AS(linux_msgctl_args), (sy_call_t *)linux_msgctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 71 = linux_msgctl */
>+	{ AS(linux_fcntl_args), (sy_call_t *)linux_fcntl, AUE_FCNTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 72 = linux_fcntl */
>+	{ AS(flock_args), (sy_call_t *)sys_flock, AUE_FLOCK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 73 = flock */
>+	{ AS(fsync_args), (sy_call_t *)sys_fsync, AUE_FSYNC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 74 = fsync */
>+	{ AS(linux_fdatasync_args), (sy_call_t *)linux_fdatasync, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 75 = linux_fdatasync */
>+	{ AS(linux_truncate_args), (sy_call_t *)linux_truncate, AUE_TRUNCATE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 76 = linux_truncate */
>+	{ AS(linux_ftruncate_args), (sy_call_t *)linux_ftruncate, AUE_FTRUNCATE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 77 = linux_ftruncate */
>+	{ AS(linux_getdents_args), (sy_call_t *)linux_getdents, AUE_GETDIRENTRIES, NULL, 0, 0, 0, SY_THR_STATIC },	/* 78 = linux_getdents */
>+	{ AS(linux_getcwd_args), (sy_call_t *)linux_getcwd, AUE_GETCWD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 79 = linux_getcwd */
>+	{ AS(linux_chdir_args), (sy_call_t *)linux_chdir, AUE_CHDIR, NULL, 0, 0, 0, SY_THR_STATIC },	/* 80 = linux_chdir */
>+	{ AS(fchdir_args), (sy_call_t *)sys_fchdir, AUE_FCHDIR, NULL, 0, 0, 0, SY_THR_STATIC },	/* 81 = fchdir */
>+	{ AS(linux_rename_args), (sy_call_t *)linux_rename, AUE_RENAME, NULL, 0, 0, 0, SY_THR_STATIC },	/* 82 = linux_rename */
>+	{ AS(linux_mkdir_args), (sy_call_t *)linux_mkdir, AUE_MKDIR, NULL, 0, 0, 0, SY_THR_STATIC },	/* 83 = linux_mkdir */
>+	{ AS(linux_rmdir_args), (sy_call_t *)linux_rmdir, AUE_RMDIR, NULL, 0, 0, 0, SY_THR_STATIC },	/* 84 = linux_rmdir */
>+	{ AS(linux_creat_args), (sy_call_t *)linux_creat, AUE_CREAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 85 = linux_creat */
>+	{ AS(linux_link_args), (sy_call_t *)linux_link, AUE_LINK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 86 = linux_link */
>+	{ AS(linux_unlink_args), (sy_call_t *)linux_unlink, AUE_UNLINK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 87 = linux_unlink */
>+	{ AS(linux_symlink_args), (sy_call_t *)linux_symlink, AUE_SYMLINK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 88 = linux_symlink */
>+	{ AS(linux_readlink_args), (sy_call_t *)linux_readlink, AUE_READLINK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 89 = linux_readlink */
>+	{ AS(linux_chmod_args), (sy_call_t *)linux_chmod, AUE_CHMOD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 90 = linux_chmod */
>+	{ AS(fchmod_args), (sy_call_t *)sys_fchmod, AUE_FCHMOD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 91 = fchmod */
>+	{ AS(linux_chown_args), (sy_call_t *)linux_chown, AUE_LCHOWN, NULL, 0, 0, 0, SY_THR_STATIC },	/* 92 = linux_chown */
>+	{ AS(fchown_args), (sy_call_t *)sys_fchown, AUE_FCHOWN, NULL, 0, 0, 0, SY_THR_STATIC },	/* 93 = fchown */
>+	{ AS(linux_lchown_args), (sy_call_t *)linux_lchown, AUE_LCHOWN, NULL, 0, 0, 0, SY_THR_STATIC },	/* 94 = linux_lchown */
>+	{ AS(umask_args), (sy_call_t *)sys_umask, AUE_UMASK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 95 = umask */
>+	{ AS(gettimeofday_args), (sy_call_t *)sys_gettimeofday, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 96 = gettimeofday */
>+	{ AS(linux_getrlimit_args), (sy_call_t *)linux_getrlimit, AUE_GETRLIMIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 97 = linux_getrlimit */
>+	{ AS(getrusage_args), (sy_call_t *)sys_getrusage, AUE_GETRUSAGE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 98 = getrusage */
>+	{ AS(linux_sysinfo_args), (sy_call_t *)linux_sysinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 99 = linux_sysinfo */
>+	{ AS(linux_times_args), (sy_call_t *)linux_times, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 100 = linux_times */
>+	{ AS(linux_ptrace_args), (sy_call_t *)linux_ptrace, AUE_PTRACE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 101 = linux_ptrace */
>+	{ 0, (sy_call_t *)linux_getuid, AUE_GETUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 102 = linux_getuid */
>+	{ AS(linux_syslog_args), (sy_call_t *)linux_syslog, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 103 = linux_syslog */
>+	{ 0, (sy_call_t *)linux_getgid, AUE_GETGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 104 = linux_getgid */
>+	{ AS(setuid_args), (sy_call_t *)sys_setuid, AUE_SETUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 105 = setuid */
>+	{ AS(setgid_args), (sy_call_t *)sys_setgid, AUE_SETGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 106 = setgid */
>+	{ 0, (sy_call_t *)sys_geteuid, AUE_GETEUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 107 = geteuid */
>+	{ 0, (sy_call_t *)sys_getegid, AUE_GETEGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 108 = getegid */
>+	{ AS(setpgid_args), (sy_call_t *)sys_setpgid, AUE_SETPGRP, NULL, 0, 0, 0, SY_THR_STATIC },	/* 109 = setpgid */
>+	{ 0, (sy_call_t *)linux_getppid, AUE_GETPPID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 110 = linux_getppid */
>+	{ 0, (sy_call_t *)sys_getpgrp, AUE_GETPGRP, NULL, 0, 0, 0, SY_THR_STATIC },	/* 111 = getpgrp */
>+	{ 0, (sy_call_t *)sys_setsid, AUE_SETSID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 112 = setsid */
>+	{ AS(setreuid_args), (sy_call_t *)sys_setreuid, AUE_SETREUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 113 = setreuid */
>+	{ AS(setregid_args), (sy_call_t *)sys_setregid, AUE_SETREGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 114 = setregid */
>+	{ AS(linux_getgroups_args), (sy_call_t *)linux_getgroups, AUE_GETGROUPS, NULL, 0, 0, 0, SY_THR_STATIC },	/* 115 = linux_getgroups */
>+	{ AS(linux_setgroups_args), (sy_call_t *)linux_setgroups, AUE_SETGROUPS, NULL, 0, 0, 0, SY_THR_STATIC },	/* 116 = linux_setgroups */
>+	{ AS(setresuid_args), (sy_call_t *)sys_setresuid, AUE_SETRESUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 117 = setresuid */
>+	{ AS(getresuid_args), (sy_call_t *)sys_getresuid, AUE_GETRESUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 118 = getresuid */
>+	{ AS(setresgid_args), (sy_call_t *)sys_setresgid, AUE_SETRESGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 119 = setresgid */
>+	{ AS(getresgid_args), (sy_call_t *)sys_getresgid, AUE_GETRESGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 120 = getresgid */
>+	{ AS(getpgid_args), (sy_call_t *)sys_getpgid, AUE_GETPGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 121 = getpgid */
>+	{ AS(linux_setfsuid_args), (sy_call_t *)linux_setfsuid, AUE_SETFSUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 122 = linux_setfsuid */
>+	{ AS(linux_setfsgid_args), (sy_call_t *)linux_setfsgid, AUE_SETFSGID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 123 = linux_setfsgid */
>+	{ AS(linux_getsid_args), (sy_call_t *)linux_getsid, AUE_GETSID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 124 = linux_getsid */
>+	{ AS(linux_capget_args), (sy_call_t *)linux_capget, AUE_CAPGET, NULL, 0, 0, 0, SY_THR_STATIC },	/* 125 = linux_capget */
>+	{ AS(linux_capset_args), (sy_call_t *)linux_capset, AUE_CAPSET, NULL, 0, 0, 0, SY_THR_STATIC },	/* 126 = linux_capset */
>+	{ AS(linux_rt_sigpending_args), (sy_call_t *)linux_rt_sigpending, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 127 = linux_rt_sigpending */
>+	{ AS(linux_rt_sigtimedwait_args), (sy_call_t *)linux_rt_sigtimedwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 128 = linux_rt_sigtimedwait */
>+	{ AS(linux_rt_sigqueueinfo_args), (sy_call_t *)linux_rt_sigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 129 = linux_rt_sigqueueinfo */
>+	{ AS(linux_rt_sigsuspend_args), (sy_call_t *)linux_rt_sigsuspend, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 130 = linux_rt_sigsuspend */
>+	{ AS(linux_sigaltstack_args), (sy_call_t *)linux_sigaltstack, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 131 = linux_sigaltstack */
>+	{ AS(linux_utime_args), (sy_call_t *)linux_utime, AUE_UTIME, NULL, 0, 0, 0, SY_THR_STATIC },	/* 132 = linux_utime */
>+	{ AS(linux_mknod_args), (sy_call_t *)linux_mknod, AUE_MKNOD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 133 = linux_mknod */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 134 = uselib */
>+	{ AS(linux_personality_args), (sy_call_t *)linux_personality, AUE_PERSONALITY, NULL, 0, 0, 0, SY_THR_STATIC },	/* 135 = linux_personality */
>+	{ AS(linux_ustat_args), (sy_call_t *)linux_ustat, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 136 = linux_ustat */
>+	{ AS(linux_statfs_args), (sy_call_t *)linux_statfs, AUE_STATFS, NULL, 0, 0, 0, SY_THR_STATIC },	/* 137 = linux_statfs */
>+	{ AS(linux_fstatfs_args), (sy_call_t *)linux_fstatfs, AUE_FSTATFS, NULL, 0, 0, 0, SY_THR_STATIC },	/* 138 = linux_fstatfs */
>+	{ AS(linux_sysfs_args), (sy_call_t *)linux_sysfs, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 139 = linux_sysfs */
>+	{ AS(linux_getpriority_args), (sy_call_t *)linux_getpriority, AUE_GETPRIORITY, NULL, 0, 0, 0, SY_THR_STATIC },	/* 140 = linux_getpriority */
>+	{ AS(setpriority_args), (sy_call_t *)sys_setpriority, AUE_SETPRIORITY, NULL, 0, 0, 0, SY_THR_STATIC },	/* 141 = setpriority */
>+	{ AS(linux_sched_setparam_args), (sy_call_t *)linux_sched_setparam, AUE_SCHED_SETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 142 = linux_sched_setparam */
>+	{ AS(linux_sched_getparam_args), (sy_call_t *)linux_sched_getparam, AUE_SCHED_GETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 143 = linux_sched_getparam */
>+	{ AS(linux_sched_setscheduler_args), (sy_call_t *)linux_sched_setscheduler, AUE_SCHED_SETSCHEDULER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 144 = linux_sched_setscheduler */
>+	{ AS(linux_sched_getscheduler_args), (sy_call_t *)linux_sched_getscheduler, AUE_SCHED_GETSCHEDULER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 145 = linux_sched_getscheduler */
>+	{ AS(linux_sched_get_priority_max_args), (sy_call_t *)linux_sched_get_priority_max, AUE_SCHED_GET_PRIORITY_MAX, NULL, 0, 0, 0, SY_THR_STATIC },	/* 146 = linux_sched_get_priority_max */
>+	{ AS(linux_sched_get_priority_min_args), (sy_call_t *)linux_sched_get_priority_min, AUE_SCHED_GET_PRIORITY_MIN, NULL, 0, 0, 0, SY_THR_STATIC },	/* 147 = linux_sched_get_priority_min */
>+	{ AS(linux_sched_rr_get_interval_args), (sy_call_t *)linux_sched_rr_get_interval, AUE_SCHED_RR_GET_INTERVAL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 148 = linux_sched_rr_get_interval */
>+	{ AS(mlock_args), (sy_call_t *)sys_mlock, AUE_MLOCK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 149 = mlock */
>+	{ AS(munlock_args), (sy_call_t *)sys_munlock, AUE_MUNLOCK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 150 = munlock */
>+	{ AS(mlockall_args), (sy_call_t *)sys_mlockall, AUE_MLOCKALL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 151 = mlockall */
>+	{ 0, (sy_call_t *)sys_munlockall, AUE_MUNLOCKALL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 152 = munlockall */
>+	{ 0, (sy_call_t *)linux_vhangup, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 153 = linux_vhangup */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 154 = modify_ldt */
>+	{ 0, (sy_call_t *)linux_pivot_root, AUE_PIVOT_ROOT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 155 = linux_pivot_root */
>+	{ AS(linux_sysctl_args), (sy_call_t *)linux_sysctl, AUE_SYSCTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 156 = linux_sysctl */
>+	{ AS(linux_prctl_args), (sy_call_t *)linux_prctl, AUE_PRCTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 157 = linux_prctl */
>+	{ AS(linux_arch_prctl_args), (sy_call_t *)linux_arch_prctl, AUE_PRCTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 158 = linux_arch_prctl */
>+	{ 0, (sy_call_t *)linux_adjtimex, AUE_ADJTIME, NULL, 0, 0, 0, SY_THR_STATIC },	/* 159 = linux_adjtimex */
>+	{ AS(linux_setrlimit_args), (sy_call_t *)linux_setrlimit, AUE_SETRLIMIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 160 = linux_setrlimit */
>+	{ AS(chroot_args), (sy_call_t *)sys_chroot, AUE_CHROOT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 161 = chroot */
>+	{ 0, (sy_call_t *)sys_sync, AUE_SYNC, NULL, 0, 0, 0, SY_THR_STATIC },		/* 162 = sync */
>+	{ AS(acct_args), (sy_call_t *)sys_acct, AUE_ACCT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 163 = acct */
>+	{ AS(settimeofday_args), (sy_call_t *)sys_settimeofday, AUE_SETTIMEOFDAY, NULL, 0, 0, 0, SY_THR_STATIC },	/* 164 = settimeofday */
>+	{ AS(linux_mount_args), (sy_call_t *)linux_mount, AUE_MOUNT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 165 = linux_mount */
>+	{ AS(linux_umount_args), (sy_call_t *)linux_umount, AUE_UMOUNT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 166 = linux_umount */
>+	{ AS(swapon_args), (sy_call_t *)sys_swapon, AUE_SWAPON, NULL, 0, 0, 0, SY_THR_STATIC },	/* 167 = swapon */
>+	{ 0, (sy_call_t *)linux_swapoff, AUE_SWAPOFF, NULL, 0, 0, 0, SY_THR_STATIC },	/* 168 = linux_swapoff */
>+	{ AS(linux_reboot_args), (sy_call_t *)linux_reboot, AUE_REBOOT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 169 = linux_reboot */
>+	{ AS(linux_sethostname_args), (sy_call_t *)linux_sethostname, AUE_SYSCTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 170 = linux_sethostname */
>+	{ AS(linux_setdomainname_args), (sy_call_t *)linux_setdomainname, AUE_SYSCTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 171 = linux_setdomainname */
>+	{ AS(linux_iopl_args), (sy_call_t *)linux_iopl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 172 = linux_iopl */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 173 = ioperm */
>+	{ 0, (sy_call_t *)linux_create_module, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 174 = linux_create_module */
>+	{ 0, (sy_call_t *)linux_init_module, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 175 = linux_init_module */
>+	{ 0, (sy_call_t *)linux_delete_module, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 176 = linux_delete_module */
>+	{ 0, (sy_call_t *)linux_get_kernel_syms, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 177 = linux_get_kernel_syms */
>+	{ 0, (sy_call_t *)linux_query_module, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 178 = linux_query_module */
>+	{ 0, (sy_call_t *)linux_quotactl, AUE_QUOTACTL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 179 = linux_quotactl */
>+	{ 0, (sy_call_t *)linux_nfsservctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 180 = linux_nfsservctl */
>+	{ 0, (sy_call_t *)linux_getpmsg, AUE_GETPMSG, NULL, 0, 0, 0, SY_THR_STATIC },	/* 181 = linux_getpmsg */
>+	{ 0, (sy_call_t *)linux_putpmsg, AUE_PUTPMSG, NULL, 0, 0, 0, SY_THR_STATIC },	/* 182 = linux_putpmsg */
>+	{ 0, (sy_call_t *)linux_afs_syscall, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 183 = linux_afs_syscall */
>+	{ 0, (sy_call_t *)linux_tuxcall, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 184 = linux_tuxcall */
>+	{ 0, (sy_call_t *)linux_security, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 185 = linux_security */
>+	{ 0, (sy_call_t *)linux_gettid, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 186 = linux_gettid */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 187 = linux_readahead */
>+	{ 0, (sy_call_t *)linux_setxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 188 = linux_setxattr */
>+	{ 0, (sy_call_t *)linux_lsetxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 189 = linux_lsetxattr */
>+	{ 0, (sy_call_t *)linux_fsetxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 190 = linux_fsetxattr */
>+	{ 0, (sy_call_t *)linux_getxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 191 = linux_getxattr */
>+	{ 0, (sy_call_t *)linux_lgetxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 192 = linux_lgetxattr */
>+	{ 0, (sy_call_t *)linux_fgetxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 193 = linux_fgetxattr */
>+	{ 0, (sy_call_t *)linux_listxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 194 = linux_listxattr */
>+	{ 0, (sy_call_t *)linux_llistxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 195 = linux_llistxattr */
>+	{ 0, (sy_call_t *)linux_flistxattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 196 = linux_flistxattr */
>+	{ 0, (sy_call_t *)linux_removexattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 197 = linux_removexattr */
>+	{ 0, (sy_call_t *)linux_lremovexattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 198 = linux_lremovexattr */
>+	{ 0, (sy_call_t *)linux_fremovexattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 199 = linux_fremovexattr */
>+	{ AS(linux_tkill_args), (sy_call_t *)linux_tkill, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 200 = linux_tkill */
>+	{ AS(linux_time_args), (sy_call_t *)linux_time, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 201 = linux_time */
>+	{ AS(linux_sys_futex_args), (sy_call_t *)linux_sys_futex, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 202 = linux_sys_futex */
>+	{ AS(linux_sched_setaffinity_args), (sy_call_t *)linux_sched_setaffinity, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 203 = linux_sched_setaffinity */
>+	{ AS(linux_sched_getaffinity_args), (sy_call_t *)linux_sched_getaffinity, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 204 = linux_sched_getaffinity */
>+	{ 0, (sy_call_t *)linux_set_thread_area, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 205 = linux_set_thread_area */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 206 = linux_io_setup */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 207 = linux_io_destroy */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 208 = linux_io_getevents */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 209 = inux_io_submit */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 210 = linux_io_cancel */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 211 = linux_get_thread_area */
>+	{ 0, (sy_call_t *)linux_lookup_dcookie, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 212 = linux_lookup_dcookie */
>+	{ AS(linux_epoll_create_args), (sy_call_t *)linux_epoll_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 213 = linux_epoll_create */
>+	{ 0, (sy_call_t *)linux_epoll_ctl_old, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 214 = linux_epoll_ctl_old */
>+	{ 0, (sy_call_t *)linux_epoll_wait_old, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 215 = linux_epoll_wait_old */
>+	{ 0, (sy_call_t *)linux_remap_file_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 216 = linux_remap_file_pages */
>+	{ AS(linux_getdents64_args), (sy_call_t *)linux_getdents64, AUE_GETDIRENTRIES, NULL, 0, 0, 0, SY_THR_STATIC },	/* 217 = linux_getdents64 */
>+	{ AS(linux_set_tid_address_args), (sy_call_t *)linux_set_tid_address, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 218 = linux_set_tid_address */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 219 = restart_syscall */
>+	{ 0, (sy_call_t *)linux_semtimedop, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 220 = linux_semtimedop */
>+	{ AS(linux_fadvise64_args), (sy_call_t *)linux_fadvise64, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 221 = linux_fadvise64 */
>+	{ AS(linux_timer_create_args), (sy_call_t *)linux_timer_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 222 = linux_timer_create */
>+	{ AS(linux_timer_settime_args), (sy_call_t *)linux_timer_settime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 223 = linux_timer_settime */
>+	{ AS(linux_timer_gettime_args), (sy_call_t *)linux_timer_gettime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 224 = linux_timer_gettime */
>+	{ AS(linux_timer_getoverrun_args), (sy_call_t *)linux_timer_getoverrun, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 225 = linux_timer_getoverrun */
>+	{ AS(linux_timer_delete_args), (sy_call_t *)linux_timer_delete, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 226 = linux_timer_delete */
>+	{ AS(linux_clock_settime_args), (sy_call_t *)linux_clock_settime, AUE_CLOCK_SETTIME, NULL, 0, 0, 0, SY_THR_STATIC },	/* 227 = linux_clock_settime */
>+	{ AS(linux_clock_gettime_args), (sy_call_t *)linux_clock_gettime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 228 = linux_clock_gettime */
>+	{ AS(linux_clock_getres_args), (sy_call_t *)linux_clock_getres, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 229 = linux_clock_getres */
>+	{ AS(linux_clock_nanosleep_args), (sy_call_t *)linux_clock_nanosleep, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 230 = linux_clock_nanosleep */
>+	{ AS(linux_exit_group_args), (sy_call_t *)linux_exit_group, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 231 = linux_exit_group */
>+	{ AS(linux_epoll_wait_args), (sy_call_t *)linux_epoll_wait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 232 = linux_epoll_wait */
>+	{ AS(linux_epoll_ctl_args), (sy_call_t *)linux_epoll_ctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 233 = linux_epoll_ctl */
>+	{ AS(linux_tgkill_args), (sy_call_t *)linux_tgkill, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 234 = linux_tgkill */
>+	{ AS(linux_utimes_args), (sy_call_t *)linux_utimes, AUE_UTIMES, NULL, 0, 0, 0, SY_THR_STATIC },	/* 235 = linux_utimes */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 236 = vserver */
>+	{ 0, (sy_call_t *)linux_mbind, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 237 = linux_mbind */
>+	{ 0, (sy_call_t *)linux_set_mempolicy, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 238 = linux_set_mempolicy */
>+	{ 0, (sy_call_t *)linux_get_mempolicy, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 239 = linux_get_mempolicy */
>+	{ 0, (sy_call_t *)linux_mq_open, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 240 = linux_mq_open */
>+	{ 0, (sy_call_t *)linux_mq_unlink, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 241 = linux_mq_unlink */
>+	{ 0, (sy_call_t *)linux_mq_timedsend, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 242 = linux_mq_timedsend */
>+	{ 0, (sy_call_t *)linux_mq_timedreceive, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 243 = linux_mq_timedreceive */
>+	{ 0, (sy_call_t *)linux_mq_notify, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 244 = linux_mq_notify */
>+	{ 0, (sy_call_t *)linux_mq_getsetattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 245 = linux_mq_getsetattr */
>+	{ 0, (sy_call_t *)linux_kexec_load, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 246 = linux_kexec_load */
>+	{ AS(linux_waitid_args), (sy_call_t *)linux_waitid, AUE_WAIT6, NULL, 0, 0, 0, SY_THR_STATIC },	/* 247 = linux_waitid */
>+	{ 0, (sy_call_t *)linux_add_key, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 248 = linux_add_key */
>+	{ 0, (sy_call_t *)linux_request_key, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 249 = linux_request_key */
>+	{ 0, (sy_call_t *)linux_keyctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 250 = linux_keyctl */
>+	{ 0, (sy_call_t *)linux_ioprio_set, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 251 = linux_ioprio_set */
>+	{ 0, (sy_call_t *)linux_ioprio_get, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 252 = linux_ioprio_get */
>+	{ 0, (sy_call_t *)linux_inotify_init, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 253 = linux_inotify_init */
>+	{ 0, (sy_call_t *)linux_inotify_add_watch, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 254 = linux_inotify_add_watch */
>+	{ 0, (sy_call_t *)linux_inotify_rm_watch, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 255 = linux_inotify_rm_watch */
>+	{ 0, (sy_call_t *)linux_migrate_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 256 = linux_migrate_pages */
>+	{ AS(linux_openat_args), (sy_call_t *)linux_openat, AUE_OPEN_RWTC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 257 = linux_openat */
>+	{ AS(linux_mkdirat_args), (sy_call_t *)linux_mkdirat, AUE_MKDIRAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 258 = linux_mkdirat */
>+	{ AS(linux_mknodat_args), (sy_call_t *)linux_mknodat, AUE_MKNODAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 259 = linux_mknodat */
>+	{ AS(linux_fchownat_args), (sy_call_t *)linux_fchownat, AUE_FCHOWNAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 260 = linux_fchownat */
>+	{ AS(linux_futimesat_args), (sy_call_t *)linux_futimesat, AUE_FUTIMESAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 261 = linux_futimesat */
>+	{ AS(linux_newfstatat_args), (sy_call_t *)linux_newfstatat, AUE_FSTATAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 262 = linux_newfstatat */
>+	{ AS(linux_unlinkat_args), (sy_call_t *)linux_unlinkat, AUE_UNLINKAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 263 = linux_unlinkat */
>+	{ AS(linux_renameat_args), (sy_call_t *)linux_renameat, AUE_RENAMEAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 264 = linux_renameat */
>+	{ AS(linux_linkat_args), (sy_call_t *)linux_linkat, AUE_LINKAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 265 = linux_linkat */
>+	{ AS(linux_symlinkat_args), (sy_call_t *)linux_symlinkat, AUE_SYMLINKAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 266 = linux_symlinkat */
>+	{ AS(linux_readlinkat_args), (sy_call_t *)linux_readlinkat, AUE_READLINKAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 267 = linux_readlinkat */
>+	{ AS(linux_fchmodat_args), (sy_call_t *)linux_fchmodat, AUE_FCHMODAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 268 = linux_fchmodat */
>+	{ AS(linux_faccessat_args), (sy_call_t *)linux_faccessat, AUE_FACCESSAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 269 = linux_faccessat */
>+	{ AS(linux_pselect6_args), (sy_call_t *)linux_pselect6, AUE_SELECT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 270 = linux_pselect6 */
>+	{ AS(linux_ppoll_args), (sy_call_t *)linux_ppoll, AUE_POLL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 271 = linux_ppoll */
>+	{ 0, (sy_call_t *)linux_unshare, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 272 = linux_unshare */
>+	{ AS(linux_set_robust_list_args), (sy_call_t *)linux_set_robust_list, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 273 = linux_set_robust_list */
>+	{ AS(linux_get_robust_list_args), (sy_call_t *)linux_get_robust_list, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 274 = linux_get_robust_list */
>+	{ 0, (sy_call_t *)linux_splice, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 275 = linux_splice */
>+	{ 0, (sy_call_t *)linux_tee, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },		/* 276 = linux_tee */
>+	{ 0, (sy_call_t *)linux_sync_file_range, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 277 = linux_sync_file_range */
>+	{ 0, (sy_call_t *)linux_vmsplice, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 278 = linux_vmsplice */
>+	{ 0, (sy_call_t *)linux_move_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 279 = linux_move_pages */
>+	{ AS(linux_utimensat_args), (sy_call_t *)linux_utimensat, AUE_FUTIMESAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 280 = linux_utimensat */
>+	{ AS(linux_epoll_pwait_args), (sy_call_t *)linux_epoll_pwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 281 = linux_epoll_pwait */
>+	{ 0, (sy_call_t *)linux_signalfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 282 = linux_signalfd */
>+	{ 0, (sy_call_t *)linux_timerfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 283 = linux_timerfd */
>+	{ AS(linux_eventfd_args), (sy_call_t *)linux_eventfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 284 = linux_eventfd */
>+	{ AS(linux_fallocate_args), (sy_call_t *)linux_fallocate, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 285 = linux_fallocate */
>+	{ 0, (sy_call_t *)linux_timerfd_settime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 286 = linux_timerfd_settime */
>+	{ 0, (sy_call_t *)linux_timerfd_gettime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 287 = linux_timerfd_gettime */
>+	{ AS(linux_accept4_args), (sy_call_t *)linux_accept4, AUE_ACCEPT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 288 = linux_accept4 */
>+	{ 0, (sy_call_t *)linux_signalfd4, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 289 = linux_signalfd4 */
>+	{ AS(linux_eventfd2_args), (sy_call_t *)linux_eventfd2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 290 = linux_eventfd2 */
>+	{ AS(linux_epoll_create1_args), (sy_call_t *)linux_epoll_create1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 291 = linux_epoll_create1 */
>+	{ AS(linux_dup3_args), (sy_call_t *)linux_dup3, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 292 = linux_dup3 */
>+	{ AS(linux_pipe2_args), (sy_call_t *)linux_pipe2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 293 = linux_pipe2 */
>+	{ 0, (sy_call_t *)linux_inotify_init1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 294 = linux_inotify_init1 */
>+	{ 0, (sy_call_t *)linux_preadv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 295 = linux_preadv */
>+	{ 0, (sy_call_t *)linux_pwritev, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 296 = linux_pwritev */
>+	{ 0, (sy_call_t *)linux_rt_tsigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 297 = linux_rt_tsigqueueinfo */
>+	{ 0, (sy_call_t *)linux_perf_event_open, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 298 = linux_perf_event_open */
>+	{ AS(linux_recvmmsg_args), (sy_call_t *)linux_recvmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 299 = linux_recvmmsg */
>+	{ 0, (sy_call_t *)linux_fanotify_init, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 300 = linux_fanotify_init */
>+	{ 0, (sy_call_t *)linux_fanotify_mark, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 301 = linux_fanotify_mark */
>+	{ AS(linux_prlimit64_args), (sy_call_t *)linux_prlimit64, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 302 = linux_prlimit64 */
>+	{ 0, (sy_call_t *)linux_name_to_handle_at, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 303 = linux_name_to_handle_at */
>+	{ 0, (sy_call_t *)linux_open_by_handle_at, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 304 = linux_open_by_handle_at */
>+	{ 0, (sy_call_t *)linux_clock_adjtime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 305 = linux_clock_adjtime */
>+	{ AS(linux_syncfs_args), (sy_call_t *)linux_syncfs, AUE_SYNC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 306 = linux_syncfs */
>+	{ AS(linux_sendmmsg_args), (sy_call_t *)linux_sendmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 307 = linux_sendmmsg */
>+	{ 0, (sy_call_t *)linux_setns, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 308 = linux_setns */
>+	{ 0, (sy_call_t *)linux_process_vm_readv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 309 = linux_process_vm_readv */
>+	{ 0, (sy_call_t *)linux_process_vm_writev, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 310 = linux_process_vm_writev */
>+	{ 0, (sy_call_t *)linux_kcmp, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 311 = linux_kcmp */
>+	{ 0, (sy_call_t *)linux_finit_module, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 312 = linux_finit_module */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 313 = nosys */
>+};
>Index: sys/amd64/linux/linux_systrace_args.c
>===================================================================
>--- sys/amd64/linux/linux_systrace_args.c	(revision 0)
>+++ sys/amd64/linux/linux_systrace_args.c	(working copy)
>@@ -0,0 +1,6885 @@
>+/*
>+ * System call argument to DTrace register array converstion.
>+ *
>+ * DO NOT EDIT-- this file is automatically generated.
>+ * $FreeBSD$
>+ * This file is part of the DTrace syscall provider.
>+ */
>+
>+static void
>+systrace_args(int sysnum, void *params, uint64_t *uarg, int *n_args)
>+{
>+	int64_t *iarg  = (int64_t *) uarg;
>+	switch (sysnum) {
>+#define	nosys	linux_nosys
>+	/* read */
>+	case 0: {
>+		struct read_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		uarg[1] = (intptr_t) p->buf; /* char * */
>+		uarg[2] = p->nbyte; /* u_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* write */
>+	case 1: {
>+		struct write_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		uarg[1] = (intptr_t) p->buf; /* char * */
>+		uarg[2] = p->nbyte; /* u_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_open */
>+	case 2: {
>+		struct linux_open_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->flags; /* l_int */
>+		iarg[2] = p->mode; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* close */
>+	case 3: {
>+		struct close_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_newstat */
>+	case 4: {
>+		struct linux_newstat_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		uarg[1] = (intptr_t) p->buf; /* struct l_newstat * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_newfstat */
>+	case 5: {
>+		struct linux_newfstat_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		uarg[1] = (intptr_t) p->buf; /* struct l_newstat * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_newlstat */
>+	case 6: {
>+		struct linux_newlstat_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		uarg[1] = (intptr_t) p->buf; /* struct l_newstat * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* poll */
>+	case 7: {
>+		struct poll_args *p = params;
>+		iarg[0] = p->*; /* struct pollfd */
>+		uarg[1] = p->nfds; /* unsigned int */
>+		iarg[2] = p->timeout; /* int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_lseek */
>+	case 8: {
>+		struct linux_lseek_args *p = params;
>+		iarg[0] = p->fdes; /* l_uint */
>+		iarg[1] = p->off; /* l_off_t */
>+		iarg[2] = p->whence; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_mmap2 */
>+	case 9: {
>+		struct linux_mmap2_args *p = params;
>+		iarg[0] = p->addr; /* l_ulong */
>+		iarg[1] = p->len; /* l_ulong */
>+		iarg[2] = p->prot; /* l_ulong */
>+		iarg[3] = p->flags; /* l_ulong */
>+		iarg[4] = p->fd; /* l_ulong */
>+		iarg[5] = p->pgoff; /* l_ulong */
>+		*n_args = 6;
>+		break;
>+	}
>+	/* linux_mprotect */
>+	case 10: {
>+		struct linux_mprotect_args *p = params;
>+		uarg[0] = (intptr_t) p->addr; /* caddr_t */
>+		iarg[1] = p->len; /* int */
>+		iarg[2] = p->prot; /* int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* munmap */
>+	case 11: {
>+		struct munmap_args *p = params;
>+		uarg[0] = (intptr_t) p->addr; /* caddr_t */
>+		iarg[1] = p->len; /* int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_brk */
>+	case 12: {
>+		struct linux_brk_args *p = params;
>+		iarg[0] = p->dsend; /* l_ulong */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_rt_sigaction */
>+	case 13: {
>+		struct linux_rt_sigaction_args *p = params;
>+		iarg[0] = p->sig; /* l_int */
>+		uarg[1] = (intptr_t) p->act; /* l_sigaction_t * */
>+		uarg[2] = (intptr_t) p->oact; /* l_sigaction_t * */
>+		iarg[3] = p->sigsetsize; /* l_size_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_rt_sigprocmask */
>+	case 14: {
>+		struct linux_rt_sigprocmask_args *p = params;
>+		iarg[0] = p->how; /* l_int */
>+		uarg[1] = (intptr_t) p->mask; /* l_sigset_t * */
>+		uarg[2] = (intptr_t) p->omask; /* l_sigset_t * */
>+		iarg[3] = p->sigsetsize; /* l_size_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_rt_sigreturn */
>+	case 15: {
>+		struct linux_rt_sigreturn_args *p = params;
>+		uarg[0] = (intptr_t) p->ucp; /* struct l_ucontext * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_ioctl */
>+	case 16: {
>+		struct linux_ioctl_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		iarg[1] = p->cmd; /* l_uint */
>+		uarg[2] = p->arg; /* uintptr_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_pread */
>+	case 17: {
>+		struct linux_pread_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		uarg[1] = (intptr_t) p->buf; /* char * */
>+		iarg[2] = p->nbyte; /* l_size_t */
>+		iarg[3] = p->offset; /* l_loff_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_pwrite */
>+	case 18: {
>+		struct linux_pwrite_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		uarg[1] = (intptr_t) p->buf; /* char * */
>+		iarg[2] = p->nbyte; /* l_size_t */
>+		iarg[3] = p->offset; /* l_loff_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* readv */
>+	case 19: {
>+		struct readv_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		uarg[1] = (intptr_t) p->iovp; /* struct iovec * */
>+		uarg[2] = p->iovcnt; /* u_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* writev */
>+	case 20: {
>+		struct writev_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		uarg[1] = (intptr_t) p->iovp; /* struct iovec * */
>+		uarg[2] = p->iovcnt; /* u_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_access */
>+	case 21: {
>+		struct linux_access_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->amode; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_pipe */
>+	case 22: {
>+		struct linux_pipe_args *p = params;
>+		uarg[0] = (intptr_t) p->pipefds; /* l_ulong * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_select */
>+	case 23: {
>+		struct linux_select_args *p = params;
>+		iarg[0] = p->nfds; /* l_int */
>+		uarg[1] = (intptr_t) p->readfds; /* l_fd_set * */
>+		uarg[2] = (intptr_t) p->writefds; /* l_fd_set * */
>+		uarg[3] = (intptr_t) p->exceptfds; /* l_fd_set * */
>+		uarg[4] = (intptr_t) p->timeout; /* struct l_timeval * */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* sched_yield */
>+	case 24: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mremap */
>+	case 25: {
>+		struct linux_mremap_args *p = params;
>+		iarg[0] = p->addr; /* l_ulong */
>+		iarg[1] = p->old_len; /* l_ulong */
>+		iarg[2] = p->new_len; /* l_ulong */
>+		iarg[3] = p->flags; /* l_ulong */
>+		iarg[4] = p->new_addr; /* l_ulong */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_msync */
>+	case 26: {
>+		struct linux_msync_args *p = params;
>+		iarg[0] = p->addr; /* l_ulong */
>+		iarg[1] = p->len; /* l_size_t */
>+		iarg[2] = p->fl; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_mincore */
>+	case 27: {
>+		struct linux_mincore_args *p = params;
>+		iarg[0] = p->start; /* l_ulong */
>+		iarg[1] = p->len; /* l_size_t */
>+		uarg[2] = (intptr_t) p->vec; /* u_char * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* madvise */
>+	case 28: {
>+		struct madvise_args *p = params;
>+		uarg[0] = (intptr_t) p->addr; /* void * */
>+		uarg[1] = p->len; /* size_t */
>+		iarg[2] = p->behav; /* int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_shmget */
>+	case 29: {
>+		struct linux_shmget_args *p = params;
>+		iarg[0] = p->key; /* l_key_t */
>+		iarg[1] = p->size; /* l_size_t */
>+		iarg[2] = p->shmflg; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_shmat */
>+	case 30: {
>+		struct linux_shmat_args *p = params;
>+		iarg[0] = p->shmid; /* l_int */
>+		uarg[1] = (intptr_t) p->shmaddr; /* char * */
>+		iarg[2] = p->shmflg; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_shmctl */
>+	case 31: {
>+		struct linux_shmctl_args *p = params;
>+		iarg[0] = p->shmid; /* l_int */
>+		iarg[1] = p->cmd; /* l_int */
>+		uarg[2] = (intptr_t) p->buf; /* struct l_shmid_ds * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* dup */
>+	case 32: {
>+		struct dup_args *p = params;
>+		uarg[0] = p->fd; /* u_int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* dup2 */
>+	case 33: {
>+		struct dup2_args *p = params;
>+		uarg[0] = p->from; /* u_int */
>+		uarg[1] = p->to; /* u_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_pause */
>+	case 34: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_nanosleep */
>+	case 35: {
>+		struct linux_nanosleep_args *p = params;
>+		uarg[0] = (intptr_t) p->rqtp; /* const struct l_timespec * */
>+		uarg[1] = (intptr_t) p->rmtp; /* struct l_timespec * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_getitimer */
>+	case 36: {
>+		struct linux_getitimer_args *p = params;
>+		iarg[0] = p->which; /* l_int */
>+		uarg[1] = (intptr_t) p->itv; /* struct l_itimerval * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_alarm */
>+	case 37: {
>+		struct linux_alarm_args *p = params;
>+		iarg[0] = p->secs; /* l_uint */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_setitimer */
>+	case 38: {
>+		struct linux_setitimer_args *p = params;
>+		iarg[0] = p->which; /* l_int */
>+		uarg[1] = (intptr_t) p->itv; /* struct l_itimerval * */
>+		uarg[2] = (intptr_t) p->oitv; /* struct l_itimerval * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_getpid */
>+	case 39: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_sendfile */
>+	case 40: {
>+		struct linux_sendfile_args *p = params;
>+		iarg[0] = p->out; /* int */
>+		iarg[1] = p->in; /* int */
>+		uarg[2] = (intptr_t) p->offset; /* l_long * */
>+		iarg[3] = p->count; /* l_size_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_socket */
>+	case 41: {
>+		struct linux_socket_args *p = params;
>+		iarg[0] = p->domain; /* l_int */
>+		iarg[1] = p->type; /* l_int */
>+		iarg[2] = p->protocol; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_connect */
>+	case 42: {
>+		struct linux_connect_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->name; /* l_uintptr_t */
>+		iarg[2] = p->namelen; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_accept */
>+	case 43: {
>+		struct linux_accept_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->addr; /* l_uintptr_t */
>+		iarg[2] = p->namelen; /* l_uintptr_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_sendto */
>+	case 44: {
>+		struct linux_sendto_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->msg; /* l_uintptr_t */
>+		iarg[2] = p->len; /* l_int */
>+		iarg[3] = p->flags; /* l_int */
>+		iarg[4] = p->to; /* l_uintptr_t */
>+		iarg[5] = p->tolen; /* l_int */
>+		*n_args = 6;
>+		break;
>+	}
>+	/* linux_recvfrom */
>+	case 45: {
>+		struct linux_recvfrom_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->buf; /* l_uintptr_t */
>+		iarg[2] = p->len; /* l_size_t */
>+		iarg[3] = p->flags; /* l_int */
>+		iarg[4] = p->from; /* l_uintptr_t */
>+		iarg[5] = p->fromlen; /* l_uintptr_t */
>+		*n_args = 6;
>+		break;
>+	}
>+	/* linux_sendmsg */
>+	case 46: {
>+		struct linux_sendmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->msg; /* l_uintptr_t */
>+		iarg[2] = p->flags; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_recvmsg */
>+	case 47: {
>+		struct linux_recvmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->msg; /* l_uintptr_t */
>+		iarg[2] = p->flags; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_shutdown */
>+	case 48: {
>+		struct linux_shutdown_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->how; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_bind */
>+	case 49: {
>+		struct linux_bind_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->name; /* l_uintptr_t */
>+		iarg[2] = p->namelen; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_listen */
>+	case 50: {
>+		struct linux_listen_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->backlog; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_getsockname */
>+	case 51: {
>+		struct linux_getsockname_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->addr; /* l_uintptr_t */
>+		iarg[2] = p->namelen; /* l_uintptr_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_getpeername */
>+	case 52: {
>+		struct linux_getpeername_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->addr; /* l_uintptr_t */
>+		iarg[2] = p->namelen; /* l_uintptr_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_socketpair */
>+	case 53: {
>+		struct linux_socketpair_args *p = params;
>+		iarg[0] = p->domain; /* l_int */
>+		iarg[1] = p->type; /* l_int */
>+		iarg[2] = p->protocol; /* l_int */
>+		iarg[3] = p->rsv; /* l_uintptr_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_setsockopt */
>+	case 54: {
>+		struct linux_setsockopt_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->level; /* l_int */
>+		iarg[2] = p->optname; /* l_int */
>+		iarg[3] = p->optval; /* l_uintptr_t */
>+		iarg[4] = p->optlen; /* l_int */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_getsockopt */
>+	case 55: {
>+		struct linux_getsockopt_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->level; /* l_int */
>+		iarg[2] = p->optname; /* l_int */
>+		iarg[3] = p->optval; /* l_uintptr_t */
>+		iarg[4] = p->optlen; /* l_uintptr_t */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_clone */
>+	case 56: {
>+		struct linux_clone_args *p = params;
>+		iarg[0] = p->flags; /* l_int */
>+		uarg[1] = (intptr_t) p->stack; /* void * */
>+		uarg[2] = (intptr_t) p->parent_tidptr; /* void * */
>+		uarg[3] = (intptr_t) p->child_tidptr; /* void * */
>+		uarg[4] = (intptr_t) p->tls; /* void * */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_fork */
>+	case 57: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_vfork */
>+	case 58: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_execve */
>+	case 59: {
>+		struct linux_execve_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		uarg[1] = (intptr_t) p->argp; /* char ** */
>+		uarg[2] = (intptr_t) p->envp; /* char ** */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_exit */
>+	case 60: {
>+		struct linux_exit_args *p = params;
>+		iarg[0] = p->rval; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_wait4 */
>+	case 61: {
>+		struct linux_wait4_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->status; /* l_int * */
>+		iarg[2] = p->options; /* l_int */
>+		uarg[3] = (intptr_t) p->rusage; /* struct l_rusage * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_kill */
>+	case 62: {
>+		struct linux_kill_args *p = params;
>+		iarg[0] = p->pid; /* l_int */
>+		iarg[1] = p->signum; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_newuname */
>+	case 63: {
>+		struct linux_newuname_args *p = params;
>+		uarg[0] = (intptr_t) p->buf; /* struct l_new_utsname * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_semget */
>+	case 64: {
>+		struct linux_semget_args *p = params;
>+		iarg[0] = p->key; /* l_key_t */
>+		iarg[1] = p->nsems; /* l_int */
>+		iarg[2] = p->semflg; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_semop */
>+	case 65: {
>+		struct linux_semop_args *p = params;
>+		iarg[0] = p->semid; /* l_int */
>+		uarg[1] = (intptr_t) p->tsops; /* struct l_sembuf * */
>+		iarg[2] = p->nsops; /* l_uint */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_semctl */
>+	case 66: {
>+		struct linux_semctl_args *p = params;
>+		iarg[0] = p->semid; /* l_int */
>+		iarg[1] = p->semnum; /* l_int */
>+		iarg[2] = p->cmd; /* l_int */
>+		uarg[3] = p->arg; /* union l_semun */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_shmdt */
>+	case 67: {
>+		struct linux_shmdt_args *p = params;
>+		uarg[0] = (intptr_t) p->shmaddr; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_msgget */
>+	case 68: {
>+		struct linux_msgget_args *p = params;
>+		iarg[0] = p->key; /* l_key_t */
>+		iarg[1] = p->msgflg; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_msgsnd */
>+	case 69: {
>+		struct linux_msgsnd_args *p = params;
>+		iarg[0] = p->msqid; /* l_int */
>+		uarg[1] = (intptr_t) p->msgp; /* struct l_msgbuf * */
>+		iarg[2] = p->msgsz; /* l_size_t */
>+		iarg[3] = p->msgflg; /* l_int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_msgrcv */
>+	case 70: {
>+		struct linux_msgrcv_args *p = params;
>+		iarg[0] = p->msqid; /* l_int */
>+		uarg[1] = (intptr_t) p->msgp; /* struct l_msgbuf * */
>+		iarg[2] = p->msgsz; /* l_size_t */
>+		iarg[3] = p->msgtyp; /* l_long */
>+		iarg[4] = p->msgflg; /* l_int */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_msgctl */
>+	case 71: {
>+		struct linux_msgctl_args *p = params;
>+		iarg[0] = p->msqid; /* l_int */
>+		iarg[1] = p->cmd; /* l_int */
>+		uarg[2] = (intptr_t) p->buf; /* struct l_msqid_ds * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_fcntl */
>+	case 72: {
>+		struct linux_fcntl_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		iarg[1] = p->cmd; /* l_uint */
>+		iarg[2] = p->arg; /* l_ulong */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* flock */
>+	case 73: {
>+		struct flock_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		iarg[1] = p->how; /* int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* fsync */
>+	case 74: {
>+		struct fsync_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_fdatasync */
>+	case 75: {
>+		struct linux_fdatasync_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_truncate */
>+	case 76: {
>+		struct linux_truncate_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->length; /* l_ulong */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_ftruncate */
>+	case 77: {
>+		struct linux_ftruncate_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		iarg[1] = p->length; /* l_long */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_getdents */
>+	case 78: {
>+		struct linux_getdents_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		uarg[1] = (intptr_t) p->dent; /* void * */
>+		iarg[2] = p->count; /* l_uint */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_getcwd */
>+	case 79: {
>+		struct linux_getcwd_args *p = params;
>+		uarg[0] = (intptr_t) p->buf; /* char * */
>+		iarg[1] = p->bufsize; /* l_ulong */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_chdir */
>+	case 80: {
>+		struct linux_chdir_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* fchdir */
>+	case 81: {
>+		struct fchdir_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_rename */
>+	case 82: {
>+		struct linux_rename_args *p = params;
>+		uarg[0] = (intptr_t) p->from; /* char * */
>+		uarg[1] = (intptr_t) p->to; /* char * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_mkdir */
>+	case 83: {
>+		struct linux_mkdir_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->mode; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_rmdir */
>+	case 84: {
>+		struct linux_rmdir_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_creat */
>+	case 85: {
>+		struct linux_creat_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->mode; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_link */
>+	case 86: {
>+		struct linux_link_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		uarg[1] = (intptr_t) p->to; /* char * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_unlink */
>+	case 87: {
>+		struct linux_unlink_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_symlink */
>+	case 88: {
>+		struct linux_symlink_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		uarg[1] = (intptr_t) p->to; /* char * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_readlink */
>+	case 89: {
>+		struct linux_readlink_args *p = params;
>+		uarg[0] = (intptr_t) p->name; /* char * */
>+		uarg[1] = (intptr_t) p->buf; /* char * */
>+		iarg[2] = p->count; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_chmod */
>+	case 90: {
>+		struct linux_chmod_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->mode; /* l_mode_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* fchmod */
>+	case 91: {
>+		struct fchmod_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		iarg[1] = p->mode; /* int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_chown */
>+	case 92: {
>+		struct linux_chown_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->uid; /* l_uid_t */
>+		iarg[2] = p->gid; /* l_gid_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* fchown */
>+	case 93: {
>+		struct fchown_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		iarg[1] = p->uid; /* int */
>+		iarg[2] = p->gid; /* int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_lchown */
>+	case 94: {
>+		struct linux_lchown_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->uid; /* l_uid_t */
>+		iarg[2] = p->gid; /* l_gid_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* umask */
>+	case 95: {
>+		struct umask_args *p = params;
>+		iarg[0] = p->newmask; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* gettimeofday */
>+	case 96: {
>+		struct gettimeofday_args *p = params;
>+		uarg[0] = (intptr_t) p->tp; /* struct l_timeval * */
>+		uarg[1] = (intptr_t) p->tzp; /* struct timezone * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_getrlimit */
>+	case 97: {
>+		struct linux_getrlimit_args *p = params;
>+		iarg[0] = p->resource; /* l_uint */
>+		uarg[1] = (intptr_t) p->rlim; /* struct l_rlimit * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* getrusage */
>+	case 98: {
>+		struct getrusage_args *p = params;
>+		iarg[0] = p->who; /* int */
>+		uarg[1] = (intptr_t) p->rusage; /* struct rusage * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_sysinfo */
>+	case 99: {
>+		struct linux_sysinfo_args *p = params;
>+		uarg[0] = (intptr_t) p->info; /* struct l_sysinfo * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_times */
>+	case 100: {
>+		struct linux_times_args *p = params;
>+		uarg[0] = (intptr_t) p->buf; /* struct l_times_argv * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_ptrace */
>+	case 101: {
>+		struct linux_ptrace_args *p = params;
>+		iarg[0] = p->req; /* l_long */
>+		iarg[1] = p->pid; /* l_long */
>+		iarg[2] = p->addr; /* l_long */
>+		iarg[3] = p->data; /* l_long */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_getuid */
>+	case 102: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_syslog */
>+	case 103: {
>+		struct linux_syslog_args *p = params;
>+		iarg[0] = p->type; /* l_int */
>+		uarg[1] = (intptr_t) p->buf; /* char * */
>+		iarg[2] = p->len; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_getgid */
>+	case 104: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* setuid */
>+	case 105: {
>+		struct setuid_args *p = params;
>+		uarg[0] = p->uid; /* uid_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* setgid */
>+	case 106: {
>+		struct setgid_args *p = params;
>+		iarg[0] = p->gid; /* gid_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* geteuid */
>+	case 107: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* getegid */
>+	case 108: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* setpgid */
>+	case 109: {
>+		struct setpgid_args *p = params;
>+		iarg[0] = p->pid; /* int */
>+		iarg[1] = p->pgid; /* int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_getppid */
>+	case 110: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* getpgrp */
>+	case 111: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* setsid */
>+	case 112: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* setreuid */
>+	case 113: {
>+		struct setreuid_args *p = params;
>+		uarg[0] = p->ruid; /* uid_t */
>+		uarg[1] = p->euid; /* uid_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* setregid */
>+	case 114: {
>+		struct setregid_args *p = params;
>+		iarg[0] = p->rgid; /* gid_t */
>+		iarg[1] = p->egid; /* gid_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_getgroups */
>+	case 115: {
>+		struct linux_getgroups_args *p = params;
>+		iarg[0] = p->gidsetsize; /* l_int */
>+		uarg[1] = (intptr_t) p->grouplist; /* l_gid_t * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_setgroups */
>+	case 116: {
>+		struct linux_setgroups_args *p = params;
>+		iarg[0] = p->gidsetsize; /* l_int */
>+		uarg[1] = (intptr_t) p->grouplist; /* l_gid_t * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* setresuid */
>+	case 117: {
>+		struct setresuid_args *p = params;
>+		uarg[0] = p->ruid; /* uid_t */
>+		uarg[1] = p->euid; /* uid_t */
>+		uarg[2] = p->suid; /* uid_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* getresuid */
>+	case 118: {
>+		struct getresuid_args *p = params;
>+		uarg[0] = (intptr_t) p->ruid; /* uid_t * */
>+		uarg[1] = (intptr_t) p->euid; /* uid_t * */
>+		uarg[2] = (intptr_t) p->suid; /* uid_t * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* setresgid */
>+	case 119: {
>+		struct setresgid_args *p = params;
>+		iarg[0] = p->rgid; /* gid_t */
>+		iarg[1] = p->egid; /* gid_t */
>+		iarg[2] = p->sgid; /* gid_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* getresgid */
>+	case 120: {
>+		struct getresgid_args *p = params;
>+		uarg[0] = (intptr_t) p->rgid; /* gid_t * */
>+		uarg[1] = (intptr_t) p->egid; /* gid_t * */
>+		uarg[2] = (intptr_t) p->sgid; /* gid_t * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* getpgid */
>+	case 121: {
>+		struct getpgid_args *p = params;
>+		iarg[0] = p->pid; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_setfsuid */
>+	case 122: {
>+		struct linux_setfsuid_args *p = params;
>+		iarg[0] = p->uid; /* l_uid_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_setfsgid */
>+	case 123: {
>+		struct linux_setfsgid_args *p = params;
>+		iarg[0] = p->gid; /* l_gid_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_getsid */
>+	case 124: {
>+		struct linux_getsid_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_capget */
>+	case 125: {
>+		struct linux_capget_args *p = params;
>+		uarg[0] = (intptr_t) p->hdrp; /* struct l_user_cap_header * */
>+		uarg[1] = (intptr_t) p->datap; /* struct l_user_cap_data * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_capset */
>+	case 126: {
>+		struct linux_capset_args *p = params;
>+		uarg[0] = (intptr_t) p->hdrp; /* struct l_user_cap_header * */
>+		uarg[1] = (intptr_t) p->datap; /* struct l_user_cap_data * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_rt_sigpending */
>+	case 127: {
>+		struct linux_rt_sigpending_args *p = params;
>+		uarg[0] = (intptr_t) p->set; /* l_sigset_t * */
>+		iarg[1] = p->sigsetsize; /* l_size_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_rt_sigtimedwait */
>+	case 128: {
>+		struct linux_rt_sigtimedwait_args *p = params;
>+		uarg[0] = (intptr_t) p->mask; /* l_sigset_t * */
>+		uarg[1] = (intptr_t) p->ptr; /* l_siginfo_t * */
>+		uarg[2] = (intptr_t) p->timeout; /* struct l_timeval * */
>+		iarg[3] = p->sigsetsize; /* l_size_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_rt_sigqueueinfo */
>+	case 129: {
>+		struct linux_rt_sigqueueinfo_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->sig; /* l_int */
>+		uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_rt_sigsuspend */
>+	case 130: {
>+		struct linux_rt_sigsuspend_args *p = params;
>+		uarg[0] = (intptr_t) p->newset; /* l_sigset_t * */
>+		iarg[1] = p->sigsetsize; /* l_size_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_sigaltstack */
>+	case 131: {
>+		struct linux_sigaltstack_args *p = params;
>+		uarg[0] = (intptr_t) p->uss; /* l_stack_t * */
>+		uarg[1] = (intptr_t) p->uoss; /* l_stack_t * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_utime */
>+	case 132: {
>+		struct linux_utime_args *p = params;
>+		uarg[0] = (intptr_t) p->fname; /* char * */
>+		uarg[1] = (intptr_t) p->times; /* struct l_utimbuf * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_mknod */
>+	case 133: {
>+		struct linux_mknod_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->mode; /* l_int */
>+		iarg[2] = p->dev; /* l_dev_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_personality */
>+	case 135: {
>+		struct linux_personality_args *p = params;
>+		iarg[0] = p->per; /* l_ulong */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_ustat */
>+	case 136: {
>+		struct linux_ustat_args *p = params;
>+		iarg[0] = p->dev; /* l_dev_t */
>+		uarg[1] = (intptr_t) p->ubuf; /* struct l_ustat * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_statfs */
>+	case 137: {
>+		struct linux_statfs_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		uarg[1] = (intptr_t) p->buf; /* struct l_statfs_buf * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_fstatfs */
>+	case 138: {
>+		struct linux_fstatfs_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		uarg[1] = (intptr_t) p->buf; /* struct l_statfs_buf * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_sysfs */
>+	case 139: {
>+		struct linux_sysfs_args *p = params;
>+		iarg[0] = p->option; /* l_int */
>+		iarg[1] = p->arg1; /* l_ulong */
>+		iarg[2] = p->arg2; /* l_ulong */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_getpriority */
>+	case 140: {
>+		struct linux_getpriority_args *p = params;
>+		iarg[0] = p->which; /* int */
>+		iarg[1] = p->who; /* int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* setpriority */
>+	case 141: {
>+		struct setpriority_args *p = params;
>+		iarg[0] = p->which; /* int */
>+		iarg[1] = p->who; /* int */
>+		iarg[2] = p->prio; /* int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_sched_setparam */
>+	case 142: {
>+		struct linux_sched_setparam_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->param; /* struct l_sched_param * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_sched_getparam */
>+	case 143: {
>+		struct linux_sched_getparam_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->param; /* struct l_sched_param * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_sched_setscheduler */
>+	case 144: {
>+		struct linux_sched_setscheduler_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->policy; /* l_int */
>+		uarg[2] = (intptr_t) p->param; /* struct l_sched_param * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_sched_getscheduler */
>+	case 145: {
>+		struct linux_sched_getscheduler_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_sched_get_priority_max */
>+	case 146: {
>+		struct linux_sched_get_priority_max_args *p = params;
>+		iarg[0] = p->policy; /* l_int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_sched_get_priority_min */
>+	case 147: {
>+		struct linux_sched_get_priority_min_args *p = params;
>+		iarg[0] = p->policy; /* l_int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_sched_rr_get_interval */
>+	case 148: {
>+		struct linux_sched_rr_get_interval_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->interval; /* struct l_timespec * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* mlock */
>+	case 149: {
>+		struct mlock_args *p = params;
>+		uarg[0] = (intptr_t) p->addr; /* const void * */
>+		uarg[1] = p->len; /* size_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* munlock */
>+	case 150: {
>+		struct munlock_args *p = params;
>+		uarg[0] = (intptr_t) p->addr; /* const void * */
>+		uarg[1] = p->len; /* size_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* mlockall */
>+	case 151: {
>+		struct mlockall_args *p = params;
>+		iarg[0] = p->how; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* munlockall */
>+	case 152: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_vhangup */
>+	case 153: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_pivot_root */
>+	case 155: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_sysctl */
>+	case 156: {
>+		struct linux_sysctl_args *p = params;
>+		uarg[0] = (intptr_t) p->args; /* struct l___sysctl_args * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_prctl */
>+	case 157: {
>+		struct linux_prctl_args *p = params;
>+		iarg[0] = p->option; /* l_int */
>+		iarg[1] = p->arg2; /* l_uintptr_t */
>+		iarg[2] = p->arg3; /* l_uintptr_t */
>+		iarg[3] = p->arg4; /* l_uintptr_t */
>+		iarg[4] = p->arg5; /* l_uintptr_t */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_arch_prctl */
>+	case 158: {
>+		struct linux_arch_prctl_args *p = params;
>+		iarg[0] = p->code; /* l_int */
>+		iarg[1] = p->addr; /* l_ulong */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_adjtimex */
>+	case 159: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_setrlimit */
>+	case 160: {
>+		struct linux_setrlimit_args *p = params;
>+		iarg[0] = p->resource; /* l_uint */
>+		uarg[1] = (intptr_t) p->rlim; /* struct l_rlimit * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* chroot */
>+	case 161: {
>+		struct chroot_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* sync */
>+	case 162: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* acct */
>+	case 163: {
>+		struct acct_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* settimeofday */
>+	case 164: {
>+		struct settimeofday_args *p = params;
>+		uarg[0] = (intptr_t) p->tp; /* struct l_timeval * */
>+		uarg[1] = (intptr_t) p->tzp; /* struct timezone * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_mount */
>+	case 165: {
>+		struct linux_mount_args *p = params;
>+		uarg[0] = (intptr_t) p->specialfile; /* char * */
>+		uarg[1] = (intptr_t) p->dir; /* char * */
>+		uarg[2] = (intptr_t) p->filesystemtype; /* char * */
>+		iarg[3] = p->rwflag; /* l_ulong */
>+		uarg[4] = (intptr_t) p->data; /* void * */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_umount */
>+	case 166: {
>+		struct linux_umount_args *p = params;
>+		uarg[0] = (intptr_t) p->path; /* char * */
>+		iarg[1] = p->flags; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* swapon */
>+	case 167: {
>+		struct swapon_args *p = params;
>+		uarg[0] = (intptr_t) p->name; /* char * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_swapoff */
>+	case 168: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_reboot */
>+	case 169: {
>+		struct linux_reboot_args *p = params;
>+		iarg[0] = p->magic1; /* l_int */
>+		iarg[1] = p->magic2; /* l_int */
>+		iarg[2] = p->cmd; /* l_uint */
>+		uarg[3] = (intptr_t) p->arg; /* void * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_sethostname */
>+	case 170: {
>+		struct linux_sethostname_args *p = params;
>+		uarg[0] = (intptr_t) p->hostname; /* char * */
>+		iarg[1] = p->len; /* l_uint */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_setdomainname */
>+	case 171: {
>+		struct linux_setdomainname_args *p = params;
>+		uarg[0] = (intptr_t) p->name; /* char * */
>+		iarg[1] = p->len; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_iopl */
>+	case 172: {
>+		struct linux_iopl_args *p = params;
>+		iarg[0] = p->level; /* l_uint */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_create_module */
>+	case 174: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_init_module */
>+	case 175: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_delete_module */
>+	case 176: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_get_kernel_syms */
>+	case 177: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_query_module */
>+	case 178: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_quotactl */
>+	case 179: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_nfsservctl */
>+	case 180: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_getpmsg */
>+	case 181: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_putpmsg */
>+	case 182: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_afs_syscall */
>+	case 183: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_tuxcall */
>+	case 184: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_security */
>+	case 185: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_gettid */
>+	case 186: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_setxattr */
>+	case 188: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_lsetxattr */
>+	case 189: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_fsetxattr */
>+	case 190: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_getxattr */
>+	case 191: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_lgetxattr */
>+	case 192: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_fgetxattr */
>+	case 193: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_listxattr */
>+	case 194: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_llistxattr */
>+	case 195: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_flistxattr */
>+	case 196: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_removexattr */
>+	case 197: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_lremovexattr */
>+	case 198: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_fremovexattr */
>+	case 199: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_tkill */
>+	case 200: {
>+		struct linux_tkill_args *p = params;
>+		iarg[0] = p->tid; /* int */
>+		iarg[1] = p->sig; /* int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_time */
>+	case 201: {
>+		struct linux_time_args *p = params;
>+		uarg[0] = (intptr_t) p->tm; /* l_time_t * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_sys_futex */
>+	case 202: {
>+		struct linux_sys_futex_args *p = params;
>+		uarg[0] = (intptr_t) p->uaddr; /* void * */
>+		iarg[1] = p->op; /* int */
>+		iarg[2] = p->val; /* int */
>+		uarg[3] = (intptr_t) p->timeout; /* struct l_timespec * */
>+		uarg[4] = (intptr_t) p->uaddr2; /* void * */
>+		iarg[5] = p->val3; /* int */
>+		*n_args = 6;
>+		break;
>+	}
>+	/* linux_sched_setaffinity */
>+	case 203: {
>+		struct linux_sched_setaffinity_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->len; /* l_uint */
>+		uarg[2] = (intptr_t) p->user_mask_ptr; /* l_ulong * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_sched_getaffinity */
>+	case 204: {
>+		struct linux_sched_getaffinity_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->len; /* l_uint */
>+		uarg[2] = (intptr_t) p->user_mask_ptr; /* l_ulong * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_set_thread_area */
>+	case 205: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_lookup_dcookie */
>+	case 212: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_epoll_create */
>+	case 213: {
>+		struct linux_epoll_create_args *p = params;
>+		iarg[0] = p->size; /* l_int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_epoll_ctl_old */
>+	case 214: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_epoll_wait_old */
>+	case 215: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_remap_file_pages */
>+	case 216: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_getdents64 */
>+	case 217: {
>+		struct linux_getdents64_args *p = params;
>+		iarg[0] = p->fd; /* l_uint */
>+		uarg[1] = (intptr_t) p->dirent; /* void * */
>+		iarg[2] = p->count; /* l_uint */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_set_tid_address */
>+	case 218: {
>+		struct linux_set_tid_address_args *p = params;
>+		uarg[0] = (intptr_t) p->tidptr; /* int * */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_semtimedop */
>+	case 220: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_fadvise64 */
>+	case 221: {
>+		struct linux_fadvise64_args *p = params;
>+		iarg[0] = p->fd; /* int */
>+		iarg[1] = p->offset; /* l_loff_t */
>+		iarg[2] = p->len; /* l_size_t */
>+		iarg[3] = p->advice; /* int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_timer_create */
>+	case 222: {
>+		struct linux_timer_create_args *p = params;
>+		iarg[0] = p->clock_id; /* clockid_t */
>+		uarg[1] = (intptr_t) p->evp; /* struct sigevent * */
>+		uarg[2] = (intptr_t) p->timerid; /* l_timer_t * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_timer_settime */
>+	case 223: {
>+		struct linux_timer_settime_args *p = params;
>+		iarg[0] = p->timerid; /* l_timer_t */
>+		iarg[1] = p->flags; /* l_int */
>+		uarg[2] = (intptr_t) p->new; /* const struct itimerspec * */
>+		uarg[3] = (intptr_t) p->old; /* struct itimerspec * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_timer_gettime */
>+	case 224: {
>+		struct linux_timer_gettime_args *p = params;
>+		iarg[0] = p->timerid; /* l_timer_t */
>+		uarg[1] = (intptr_t) p->setting; /* struct itimerspec * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_timer_getoverrun */
>+	case 225: {
>+		struct linux_timer_getoverrun_args *p = params;
>+		iarg[0] = p->timerid; /* l_timer_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_timer_delete */
>+	case 226: {
>+		struct linux_timer_delete_args *p = params;
>+		iarg[0] = p->timerid; /* l_timer_t */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_clock_settime */
>+	case 227: {
>+		struct linux_clock_settime_args *p = params;
>+		iarg[0] = p->which; /* clockid_t */
>+		uarg[1] = (intptr_t) p->tp; /* struct l_timespec * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_clock_gettime */
>+	case 228: {
>+		struct linux_clock_gettime_args *p = params;
>+		iarg[0] = p->which; /* clockid_t */
>+		uarg[1] = (intptr_t) p->tp; /* struct l_timespec * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_clock_getres */
>+	case 229: {
>+		struct linux_clock_getres_args *p = params;
>+		iarg[0] = p->which; /* clockid_t */
>+		uarg[1] = (intptr_t) p->tp; /* struct l_timespec * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_clock_nanosleep */
>+	case 230: {
>+		struct linux_clock_nanosleep_args *p = params;
>+		iarg[0] = p->which; /* clockid_t */
>+		iarg[1] = p->flags; /* int */
>+		uarg[2] = (intptr_t) p->rqtp; /* struct l_timespec * */
>+		uarg[3] = (intptr_t) p->rmtp; /* struct l_timespec * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_exit_group */
>+	case 231: {
>+		struct linux_exit_group_args *p = params;
>+		iarg[0] = p->error_code; /* int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_epoll_wait */
>+	case 232: {
>+		struct linux_epoll_wait_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		uarg[1] = (intptr_t) p->events; /* struct epoll_event * */
>+		iarg[2] = p->maxevents; /* l_int */
>+		iarg[3] = p->timeout; /* l_int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_epoll_ctl */
>+	case 233: {
>+		struct linux_epoll_ctl_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		iarg[1] = p->op; /* l_int */
>+		iarg[2] = p->fd; /* l_int */
>+		uarg[3] = (intptr_t) p->event; /* struct epoll_event * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_tgkill */
>+	case 234: {
>+		struct linux_tgkill_args *p = params;
>+		iarg[0] = p->tgid; /* int */
>+		iarg[1] = p->pid; /* int */
>+		iarg[2] = p->sig; /* int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_utimes */
>+	case 235: {
>+		struct linux_utimes_args *p = params;
>+		uarg[0] = (intptr_t) p->fname; /* char * */
>+		uarg[1] = (intptr_t) p->tptr; /* struct l_timeval * */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_mbind */
>+	case 237: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_set_mempolicy */
>+	case 238: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_get_mempolicy */
>+	case 239: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mq_open */
>+	case 240: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mq_unlink */
>+	case 241: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mq_timedsend */
>+	case 242: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mq_timedreceive */
>+	case 243: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mq_notify */
>+	case 244: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_mq_getsetattr */
>+	case 245: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_kexec_load */
>+	case 246: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_waitid */
>+	case 247: {
>+		struct linux_waitid_args *p = params;
>+		iarg[0] = p->idtype; /* int */
>+		iarg[1] = p->id; /* l_pid_t */
>+		uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */
>+		iarg[3] = p->options; /* int */
>+		uarg[4] = (intptr_t) p->rusage; /* struct l_rusage * */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_add_key */
>+	case 248: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_request_key */
>+	case 249: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_keyctl */
>+	case 250: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_ioprio_set */
>+	case 251: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_ioprio_get */
>+	case 252: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_inotify_init */
>+	case 253: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_inotify_add_watch */
>+	case 254: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_inotify_rm_watch */
>+	case 255: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_migrate_pages */
>+	case 256: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_openat */
>+	case 257: {
>+		struct linux_openat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->filename; /* const char * */
>+		iarg[2] = p->flags; /* l_int */
>+		iarg[3] = p->mode; /* l_int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_mkdirat */
>+	case 258: {
>+		struct linux_mkdirat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->pathname; /* const char * */
>+		iarg[2] = p->mode; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_mknodat */
>+	case 259: {
>+		struct linux_mknodat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->filename; /* const char * */
>+		iarg[2] = p->mode; /* l_int */
>+		iarg[3] = p->dev; /* l_uint */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_fchownat */
>+	case 260: {
>+		struct linux_fchownat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->filename; /* const char * */
>+		iarg[2] = p->uid; /* l_uid_t */
>+		iarg[3] = p->gid; /* l_gid_t */
>+		iarg[4] = p->flag; /* l_int */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_futimesat */
>+	case 261: {
>+		struct linux_futimesat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->filename; /* char * */
>+		uarg[2] = (intptr_t) p->utimes; /* struct l_timeval * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_newfstatat */
>+	case 262: {
>+		struct linux_newfstatat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->pathname; /* char * */
>+		uarg[2] = (intptr_t) p->statbuf; /* struct l_stat64 * */
>+		iarg[3] = p->flag; /* l_int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_unlinkat */
>+	case 263: {
>+		struct linux_unlinkat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->pathname; /* const char * */
>+		iarg[2] = p->flag; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_renameat */
>+	case 264: {
>+		struct linux_renameat_args *p = params;
>+		iarg[0] = p->olddfd; /* l_int */
>+		uarg[1] = (intptr_t) p->oldname; /* const char * */
>+		iarg[2] = p->newdfd; /* l_int */
>+		uarg[3] = (intptr_t) p->newname; /* const char * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_linkat */
>+	case 265: {
>+		struct linux_linkat_args *p = params;
>+		iarg[0] = p->olddfd; /* l_int */
>+		uarg[1] = (intptr_t) p->oldname; /* const char * */
>+		iarg[2] = p->newdfd; /* l_int */
>+		uarg[3] = (intptr_t) p->newname; /* const char * */
>+		iarg[4] = p->flag; /* l_int */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_symlinkat */
>+	case 266: {
>+		struct linux_symlinkat_args *p = params;
>+		uarg[0] = (intptr_t) p->oldname; /* const char * */
>+		iarg[1] = p->newdfd; /* l_int */
>+		uarg[2] = (intptr_t) p->newname; /* const char * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_readlinkat */
>+	case 267: {
>+		struct linux_readlinkat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->path; /* const char * */
>+		uarg[2] = (intptr_t) p->buf; /* char * */
>+		iarg[3] = p->bufsiz; /* l_int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_fchmodat */
>+	case 268: {
>+		struct linux_fchmodat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->filename; /* const char * */
>+		iarg[2] = p->mode; /* l_mode_t */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_faccessat */
>+	case 269: {
>+		struct linux_faccessat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->filename; /* const char * */
>+		iarg[2] = p->amode; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_pselect6 */
>+	case 270: {
>+		struct linux_pselect6_args *p = params;
>+		iarg[0] = p->nfds; /* l_int */
>+		uarg[1] = (intptr_t) p->readfds; /* l_fd_set * */
>+		uarg[2] = (intptr_t) p->writefds; /* l_fd_set * */
>+		uarg[3] = (intptr_t) p->exceptfds; /* l_fd_set * */
>+		uarg[4] = (intptr_t) p->tsp; /* struct l_timespec * */
>+		uarg[5] = (intptr_t) p->sig; /* l_uintptr_t * */
>+		*n_args = 6;
>+		break;
>+	}
>+	/* linux_ppoll */
>+	case 271: {
>+		struct linux_ppoll_args *p = params;
>+		uarg[0] = (intptr_t) p->fds; /* struct pollfd * */
>+		uarg[1] = p->nfds; /* uint32_t */
>+		uarg[2] = (intptr_t) p->tsp; /* struct l_timespec * */
>+		uarg[3] = (intptr_t) p->sset; /* l_sigset_t * */
>+		iarg[4] = p->ssize; /* l_size_t */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_unshare */
>+	case 272: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_set_robust_list */
>+	case 273: {
>+		struct linux_set_robust_list_args *p = params;
>+		uarg[0] = (intptr_t) p->head; /* struct linux_robust_list_head * */
>+		iarg[1] = p->len; /* l_size_t */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_get_robust_list */
>+	case 274: {
>+		struct linux_get_robust_list_args *p = params;
>+		iarg[0] = p->pid; /* l_int */
>+		uarg[1] = (intptr_t) p->head; /* struct linux_robust_list_head * */
>+		uarg[2] = (intptr_t) p->len; /* l_size_t * */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_splice */
>+	case 275: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_tee */
>+	case 276: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_sync_file_range */
>+	case 277: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_vmsplice */
>+	case 278: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_move_pages */
>+	case 279: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_utimensat */
>+	case 280: {
>+		struct linux_utimensat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->pathname; /* const char * */
>+		uarg[2] = (intptr_t) p->times; /* const struct l_timespec * */
>+		iarg[3] = p->flags; /* l_int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_epoll_pwait */
>+	case 281: {
>+		struct linux_epoll_pwait_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		uarg[1] = (intptr_t) p->events; /* struct epoll_event * */
>+		iarg[2] = p->maxevents; /* l_int */
>+		iarg[3] = p->timeout; /* l_int */
>+		uarg[4] = (intptr_t) p->mask; /* l_sigset_t * */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_signalfd */
>+	case 282: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_timerfd */
>+	case 283: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_eventfd */
>+	case 284: {
>+		struct linux_eventfd_args *p = params;
>+		iarg[0] = p->initval; /* l_uint */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_fallocate */
>+	case 285: {
>+		struct linux_fallocate_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		iarg[1] = p->mode; /* l_int */
>+		iarg[2] = p->offset; /* l_loff_t */
>+		iarg[3] = p->len; /* l_loff_t */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_timerfd_settime */
>+	case 286: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_timerfd_gettime */
>+	case 287: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_accept4 */
>+	case 288: {
>+		struct linux_accept4_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		iarg[1] = p->addr; /* l_uintptr_t */
>+		iarg[2] = p->namelen; /* l_uintptr_t */
>+		iarg[3] = p->flags; /* int */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_signalfd4 */
>+	case 289: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_eventfd2 */
>+	case 290: {
>+		struct linux_eventfd2_args *p = params;
>+		iarg[0] = p->initval; /* l_uint */
>+		iarg[1] = p->flags; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_epoll_create1 */
>+	case 291: {
>+		struct linux_epoll_create1_args *p = params;
>+		iarg[0] = p->flags; /* l_int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_dup3 */
>+	case 292: {
>+		struct linux_dup3_args *p = params;
>+		iarg[0] = p->oldfd; /* l_int */
>+		iarg[1] = p->newfd; /* l_int */
>+		iarg[2] = p->flags; /* l_int */
>+		*n_args = 3;
>+		break;
>+	}
>+	/* linux_pipe2 */
>+	case 293: {
>+		struct linux_pipe2_args *p = params;
>+		uarg[0] = (intptr_t) p->pipefds; /* l_int * */
>+		iarg[1] = p->flags; /* l_int */
>+		*n_args = 2;
>+		break;
>+	}
>+	/* linux_inotify_init1 */
>+	case 294: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_preadv */
>+	case 295: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_pwritev */
>+	case 296: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_rt_tsigqueueinfo */
>+	case 297: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_perf_event_open */
>+	case 298: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_recvmmsg */
>+	case 299: {
>+		struct linux_recvmmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */
>+		iarg[2] = p->vlen; /* l_uint */
>+		iarg[3] = p->flags; /* l_uint */
>+		uarg[4] = (intptr_t) p->timeout; /* struct l_timespec * */
>+		*n_args = 5;
>+		break;
>+	}
>+	/* linux_fanotify_init */
>+	case 300: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_fanotify_mark */
>+	case 301: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_prlimit64 */
>+	case 302: {
>+		struct linux_prlimit64_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->resource; /* l_uint */
>+		uarg[2] = (intptr_t) p->new; /* struct rlimit * */
>+		uarg[3] = (intptr_t) p->old; /* struct rlimit * */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_name_to_handle_at */
>+	case 303: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_open_by_handle_at */
>+	case 304: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_clock_adjtime */
>+	case 305: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_syncfs */
>+	case 306: {
>+		struct linux_syncfs_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		*n_args = 1;
>+		break;
>+	}
>+	/* linux_sendmmsg */
>+	case 307: {
>+		struct linux_sendmmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */
>+		iarg[2] = p->vlen; /* l_uint */
>+		iarg[3] = p->flags; /* l_uint */
>+		*n_args = 4;
>+		break;
>+	}
>+	/* linux_setns */
>+	case 308: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_process_vm_readv */
>+	case 309: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_process_vm_writev */
>+	case 310: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_kcmp */
>+	case 311: {
>+		*n_args = 0;
>+		break;
>+	}
>+	/* linux_finit_module */
>+	case 312: {
>+		*n_args = 0;
>+		break;
>+	}
>+	default:
>+		*n_args = 0;
>+		break;
>+	};
>+}
>+static void
>+systrace_entry_setargdesc(int sysnum, int ndx, char *desc, size_t descsz)
>+{
>+	const char *p = NULL;
>+	switch (sysnum) {
>+#define	nosys	linux_nosys
>+	/* read */
>+	case 0:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "u_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* write */
>+	case 1:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "u_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_open */
>+	case 2:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* close */
>+	case 3:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_newstat */
>+	case 4:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "struct l_newstat *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_newfstat */
>+	case 5:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "struct l_newstat *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_newlstat */
>+	case 6:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "struct l_newstat *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* poll */
>+	case 7:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct pollfd";
>+			break;
>+		case 1:
>+			p = "unsigned int";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_lseek */
>+	case 8:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "l_off_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mmap2 */
>+	case 9:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong";
>+			break;
>+		case 1:
>+			p = "l_ulong";
>+			break;
>+		case 2:
>+			p = "l_ulong";
>+			break;
>+		case 3:
>+			p = "l_ulong";
>+			break;
>+		case 4:
>+			p = "l_ulong";
>+			break;
>+		case 5:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mprotect */
>+	case 10:
>+		switch(ndx) {
>+		case 0:
>+			p = "caddr_t";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* munmap */
>+	case 11:
>+		switch(ndx) {
>+		case 0:
>+			p = "caddr_t";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_brk */
>+	case 12:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigaction */
>+	case 13:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_sigaction_t *";
>+			break;
>+		case 2:
>+			p = "l_sigaction_t *";
>+			break;
>+		case 3:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigprocmask */
>+	case 14:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_sigset_t *";
>+			break;
>+		case 2:
>+			p = "l_sigset_t *";
>+			break;
>+		case 3:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigreturn */
>+	case 15:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_ucontext *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_ioctl */
>+	case 16:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_pread */
>+	case 17:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "l_size_t";
>+			break;
>+		case 3:
>+			p = "l_loff_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_pwrite */
>+	case 18:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "l_size_t";
>+			break;
>+		case 3:
>+			p = "l_loff_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* readv */
>+	case 19:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "struct iovec *";
>+			break;
>+		case 2:
>+			p = "u_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* writev */
>+	case 20:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "struct iovec *";
>+			break;
>+		case 2:
>+			p = "u_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_access */
>+	case 21:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_pipe */
>+	case 22:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_select */
>+	case 23:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_fd_set *";
>+			break;
>+		case 2:
>+			p = "l_fd_set *";
>+			break;
>+		case 3:
>+			p = "l_fd_set *";
>+			break;
>+		case 4:
>+			p = "struct l_timeval *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* sched_yield */
>+	case 24:
>+		break;
>+	/* linux_mremap */
>+	case 25:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong";
>+			break;
>+		case 1:
>+			p = "l_ulong";
>+			break;
>+		case 2:
>+			p = "l_ulong";
>+			break;
>+		case 3:
>+			p = "l_ulong";
>+			break;
>+		case 4:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_msync */
>+	case 26:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong";
>+			break;
>+		case 1:
>+			p = "l_size_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mincore */
>+	case 27:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong";
>+			break;
>+		case 1:
>+			p = "l_size_t";
>+			break;
>+		case 2:
>+			p = "u_char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* madvise */
>+	case 28:
>+		switch(ndx) {
>+		case 0:
>+			p = "void *";
>+			break;
>+		case 1:
>+			p = "size_t";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_shmget */
>+	case 29:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_key_t";
>+			break;
>+		case 1:
>+			p = "l_size_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_shmat */
>+	case 30:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_shmctl */
>+	case 31:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "struct l_shmid_ds *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* dup */
>+	case 32:
>+		switch(ndx) {
>+		case 0:
>+			p = "u_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* dup2 */
>+	case 33:
>+		switch(ndx) {
>+		case 0:
>+			p = "u_int";
>+			break;
>+		case 1:
>+			p = "u_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_pause */
>+	case 34:
>+		break;
>+	/* linux_nanosleep */
>+	case 35:
>+		switch(ndx) {
>+		case 0:
>+			p = "const struct l_timespec *";
>+			break;
>+		case 1:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getitimer */
>+	case 36:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_itimerval *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_alarm */
>+	case 37:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setitimer */
>+	case 38:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_itimerval *";
>+			break;
>+		case 2:
>+			p = "struct l_itimerval *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getpid */
>+	case 39:
>+		break;
>+	/* linux_sendfile */
>+	case 40:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "l_long *";
>+			break;
>+		case 3:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_socket */
>+	case 41:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_connect */
>+	case 42:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_accept */
>+	case 43:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sendto */
>+	case 44:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		case 4:
>+			p = "l_uintptr_t";
>+			break;
>+		case 5:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_recvfrom */
>+	case 45:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_size_t";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		case 4:
>+			p = "l_uintptr_t";
>+			break;
>+		case 5:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sendmsg */
>+	case 46:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_recvmsg */
>+	case 47:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_shutdown */
>+	case 48:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_bind */
>+	case 49:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_listen */
>+	case 50:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getsockname */
>+	case 51:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getpeername */
>+	case 52:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_socketpair */
>+	case 53:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setsockopt */
>+	case 54:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_uintptr_t";
>+			break;
>+		case 4:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getsockopt */
>+	case 55:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_uintptr_t";
>+			break;
>+		case 4:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_clone */
>+	case 56:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "void *";
>+			break;
>+		case 2:
>+			p = "void *";
>+			break;
>+		case 3:
>+			p = "void *";
>+			break;
>+		case 4:
>+			p = "void *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fork */
>+	case 57:
>+		break;
>+	/* linux_vfork */
>+	case 58:
>+		break;
>+	/* linux_execve */
>+	case 59:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "char **";
>+			break;
>+		case 2:
>+			p = "char **";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_exit */
>+	case 60:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_wait4 */
>+	case 61:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_int *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "struct l_rusage *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_kill */
>+	case 62:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_newuname */
>+	case 63:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_new_utsname *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_semget */
>+	case 64:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_key_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_semop */
>+	case 65:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_sembuf *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_semctl */
>+	case 66:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "union l_semun";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_shmdt */
>+	case 67:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_msgget */
>+	case 68:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_key_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_msgsnd */
>+	case 69:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_msgbuf *";
>+			break;
>+		case 2:
>+			p = "l_size_t";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_msgrcv */
>+	case 70:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_msgbuf *";
>+			break;
>+		case 2:
>+			p = "l_size_t";
>+			break;
>+		case 3:
>+			p = "l_long";
>+			break;
>+		case 4:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_msgctl */
>+	case 71:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "struct l_msqid_ds *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fcntl */
>+	case 72:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* flock */
>+	case 73:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* fsync */
>+	case 74:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fdatasync */
>+	case 75:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_truncate */
>+	case 76:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_ftruncate */
>+	case 77:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_long";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getdents */
>+	case 78:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "void *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getcwd */
>+	case 79:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_chdir */
>+	case 80:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* fchdir */
>+	case 81:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rename */
>+	case 82:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mkdir */
>+	case 83:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rmdir */
>+	case 84:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_creat */
>+	case 85:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_link */
>+	case 86:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_unlink */
>+	case 87:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_symlink */
>+	case 88:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_readlink */
>+	case 89:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_chmod */
>+	case 90:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_mode_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* fchmod */
>+	case 91:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_chown */
>+	case 92:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_uid_t";
>+			break;
>+		case 2:
>+			p = "l_gid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* fchown */
>+	case 93:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_lchown */
>+	case 94:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_uid_t";
>+			break;
>+		case 2:
>+			p = "l_gid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* umask */
>+	case 95:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* gettimeofday */
>+	case 96:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_timeval *";
>+			break;
>+		case 1:
>+			p = "struct timezone *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getrlimit */
>+	case 97:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "struct l_rlimit *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* getrusage */
>+	case 98:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "struct rusage *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sysinfo */
>+	case 99:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_sysinfo *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_times */
>+	case 100:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_times_argv *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_ptrace */
>+	case 101:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_long";
>+			break;
>+		case 1:
>+			p = "l_long";
>+			break;
>+		case 2:
>+			p = "l_long";
>+			break;
>+		case 3:
>+			p = "l_long";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getuid */
>+	case 102:
>+		break;
>+	/* linux_syslog */
>+	case 103:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getgid */
>+	case 104:
>+		break;
>+	/* setuid */
>+	case 105:
>+		switch(ndx) {
>+		case 0:
>+			p = "uid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* setgid */
>+	case 106:
>+		switch(ndx) {
>+		case 0:
>+			p = "gid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* geteuid */
>+	case 107:
>+		break;
>+	/* getegid */
>+	case 108:
>+		break;
>+	/* setpgid */
>+	case 109:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getppid */
>+	case 110:
>+		break;
>+	/* getpgrp */
>+	case 111:
>+		break;
>+	/* setsid */
>+	case 112:
>+		break;
>+	/* setreuid */
>+	case 113:
>+		switch(ndx) {
>+		case 0:
>+			p = "uid_t";
>+			break;
>+		case 1:
>+			p = "uid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* setregid */
>+	case 114:
>+		switch(ndx) {
>+		case 0:
>+			p = "gid_t";
>+			break;
>+		case 1:
>+			p = "gid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getgroups */
>+	case 115:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_gid_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setgroups */
>+	case 116:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_gid_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* setresuid */
>+	case 117:
>+		switch(ndx) {
>+		case 0:
>+			p = "uid_t";
>+			break;
>+		case 1:
>+			p = "uid_t";
>+			break;
>+		case 2:
>+			p = "uid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* getresuid */
>+	case 118:
>+		switch(ndx) {
>+		case 0:
>+			p = "uid_t *";
>+			break;
>+		case 1:
>+			p = "uid_t *";
>+			break;
>+		case 2:
>+			p = "uid_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* setresgid */
>+	case 119:
>+		switch(ndx) {
>+		case 0:
>+			p = "gid_t";
>+			break;
>+		case 1:
>+			p = "gid_t";
>+			break;
>+		case 2:
>+			p = "gid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* getresgid */
>+	case 120:
>+		switch(ndx) {
>+		case 0:
>+			p = "gid_t *";
>+			break;
>+		case 1:
>+			p = "gid_t *";
>+			break;
>+		case 2:
>+			p = "gid_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* getpgid */
>+	case 121:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setfsuid */
>+	case 122:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setfsgid */
>+	case 123:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_gid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getsid */
>+	case 124:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_capget */
>+	case 125:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_user_cap_header *";
>+			break;
>+		case 1:
>+			p = "struct l_user_cap_data *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_capset */
>+	case 126:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_user_cap_header *";
>+			break;
>+		case 1:
>+			p = "struct l_user_cap_data *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigpending */
>+	case 127:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_sigset_t *";
>+			break;
>+		case 1:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigtimedwait */
>+	case 128:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_sigset_t *";
>+			break;
>+		case 1:
>+			p = "l_siginfo_t *";
>+			break;
>+		case 2:
>+			p = "struct l_timeval *";
>+			break;
>+		case 3:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigqueueinfo */
>+	case 129:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_siginfo_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_rt_sigsuspend */
>+	case 130:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_sigset_t *";
>+			break;
>+		case 1:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sigaltstack */
>+	case 131:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_stack_t *";
>+			break;
>+		case 1:
>+			p = "l_stack_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_utime */
>+	case 132:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "struct l_utimbuf *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mknod */
>+	case 133:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_dev_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_personality */
>+	case 135:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_ustat */
>+	case 136:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_dev_t";
>+			break;
>+		case 1:
>+			p = "struct l_ustat *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_statfs */
>+	case 137:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "struct l_statfs_buf *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fstatfs */
>+	case 138:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "struct l_statfs_buf *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sysfs */
>+	case 139:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_ulong";
>+			break;
>+		case 2:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_getpriority */
>+	case 140:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* setpriority */
>+	case 141:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_setparam */
>+	case 142:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "struct l_sched_param *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_getparam */
>+	case 143:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "struct l_sched_param *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_setscheduler */
>+	case 144:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "struct l_sched_param *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_getscheduler */
>+	case 145:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_get_priority_max */
>+	case 146:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_get_priority_min */
>+	case 147:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_rr_get_interval */
>+	case 148:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* mlock */
>+	case 149:
>+		switch(ndx) {
>+		case 0:
>+			p = "const void *";
>+			break;
>+		case 1:
>+			p = "size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* munlock */
>+	case 150:
>+		switch(ndx) {
>+		case 0:
>+			p = "const void *";
>+			break;
>+		case 1:
>+			p = "size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* mlockall */
>+	case 151:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* munlockall */
>+	case 152:
>+		break;
>+	/* linux_vhangup */
>+	case 153:
>+		break;
>+	/* linux_pivot_root */
>+	case 155:
>+		break;
>+	/* linux_sysctl */
>+	case 156:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l___sysctl_args *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_prctl */
>+	case 157:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_uintptr_t";
>+			break;
>+		case 3:
>+			p = "l_uintptr_t";
>+			break;
>+		case 4:
>+			p = "l_uintptr_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_arch_prctl */
>+	case 158:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_ulong";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_adjtimex */
>+	case 159:
>+		break;
>+	/* linux_setrlimit */
>+	case 160:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "struct l_rlimit *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* chroot */
>+	case 161:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* sync */
>+	case 162:
>+		break;
>+	/* acct */
>+	case 163:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* settimeofday */
>+	case 164:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct l_timeval *";
>+			break;
>+		case 1:
>+			p = "struct timezone *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mount */
>+	case 165:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "char *";
>+			break;
>+		case 3:
>+			p = "l_ulong";
>+			break;
>+		case 4:
>+			p = "void *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_umount */
>+	case 166:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* swapon */
>+	case 167:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_swapoff */
>+	case 168:
>+		break;
>+	/* linux_reboot */
>+	case 169:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "void *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sethostname */
>+	case 170:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setdomainname */
>+	case 171:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_iopl */
>+	case 172:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_create_module */
>+	case 174:
>+		break;
>+	/* linux_init_module */
>+	case 175:
>+		break;
>+	/* linux_delete_module */
>+	case 176:
>+		break;
>+	/* linux_get_kernel_syms */
>+	case 177:
>+		break;
>+	/* linux_query_module */
>+	case 178:
>+		break;
>+	/* linux_quotactl */
>+	case 179:
>+		break;
>+	/* linux_nfsservctl */
>+	case 180:
>+		break;
>+	/* linux_getpmsg */
>+	case 181:
>+		break;
>+	/* linux_putpmsg */
>+	case 182:
>+		break;
>+	/* linux_afs_syscall */
>+	case 183:
>+		break;
>+	/* linux_tuxcall */
>+	case 184:
>+		break;
>+	/* linux_security */
>+	case 185:
>+		break;
>+	/* linux_gettid */
>+	case 186:
>+		break;
>+	/* linux_setxattr */
>+	case 188:
>+		break;
>+	/* linux_lsetxattr */
>+	case 189:
>+		break;
>+	/* linux_fsetxattr */
>+	case 190:
>+		break;
>+	/* linux_getxattr */
>+	case 191:
>+		break;
>+	/* linux_lgetxattr */
>+	case 192:
>+		break;
>+	/* linux_fgetxattr */
>+	case 193:
>+		break;
>+	/* linux_listxattr */
>+	case 194:
>+		break;
>+	/* linux_llistxattr */
>+	case 195:
>+		break;
>+	/* linux_flistxattr */
>+	case 196:
>+		break;
>+	/* linux_removexattr */
>+	case 197:
>+		break;
>+	/* linux_lremovexattr */
>+	case 198:
>+		break;
>+	/* linux_fremovexattr */
>+	case 199:
>+		break;
>+	/* linux_tkill */
>+	case 200:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_time */
>+	case 201:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_time_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sys_futex */
>+	case 202:
>+		switch(ndx) {
>+		case 0:
>+			p = "void *";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		case 3:
>+			p = "struct l_timespec *";
>+			break;
>+		case 4:
>+			p = "void *";
>+			break;
>+		case 5:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_setaffinity */
>+	case 203:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "l_ulong *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sched_getaffinity */
>+	case 204:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "l_ulong *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_set_thread_area */
>+	case 205:
>+		break;
>+	/* linux_lookup_dcookie */
>+	case 212:
>+		break;
>+	/* linux_epoll_create */
>+	case 213:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_epoll_ctl_old */
>+	case 214:
>+		break;
>+	/* linux_epoll_wait_old */
>+	case 215:
>+		break;
>+	/* linux_remap_file_pages */
>+	case 216:
>+		break;
>+	/* linux_getdents64 */
>+	case 217:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "void *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_set_tid_address */
>+	case 218:
>+		switch(ndx) {
>+		case 0:
>+			p = "int *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_semtimedop */
>+	case 220:
>+		break;
>+	/* linux_fadvise64 */
>+	case 221:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "l_loff_t";
>+			break;
>+		case 2:
>+			p = "l_size_t";
>+			break;
>+		case 3:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_timer_create */
>+	case 222:
>+		switch(ndx) {
>+		case 0:
>+			p = "clockid_t";
>+			break;
>+		case 1:
>+			p = "struct sigevent *";
>+			break;
>+		case 2:
>+			p = "l_timer_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_timer_settime */
>+	case 223:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_timer_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "const struct itimerspec *";
>+			break;
>+		case 3:
>+			p = "struct itimerspec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_timer_gettime */
>+	case 224:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_timer_t";
>+			break;
>+		case 1:
>+			p = "struct itimerspec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_timer_getoverrun */
>+	case 225:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_timer_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_timer_delete */
>+	case 226:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_timer_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_clock_settime */
>+	case 227:
>+		switch(ndx) {
>+		case 0:
>+			p = "clockid_t";
>+			break;
>+		case 1:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_clock_gettime */
>+	case 228:
>+		switch(ndx) {
>+		case 0:
>+			p = "clockid_t";
>+			break;
>+		case 1:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_clock_getres */
>+	case 229:
>+		switch(ndx) {
>+		case 0:
>+			p = "clockid_t";
>+			break;
>+		case 1:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_clock_nanosleep */
>+	case 230:
>+		switch(ndx) {
>+		case 0:
>+			p = "clockid_t";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_exit_group */
>+	case 231:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_epoll_wait */
>+	case 232:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct epoll_event *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_epoll_ctl */
>+	case 233:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "struct epoll_event *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_tgkill */
>+	case 234:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "int";
>+			break;
>+		case 2:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_utimes */
>+	case 235:
>+		switch(ndx) {
>+		case 0:
>+			p = "char *";
>+			break;
>+		case 1:
>+			p = "struct l_timeval *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mbind */
>+	case 237:
>+		break;
>+	/* linux_set_mempolicy */
>+	case 238:
>+		break;
>+	/* linux_get_mempolicy */
>+	case 239:
>+		break;
>+	/* linux_mq_open */
>+	case 240:
>+		break;
>+	/* linux_mq_unlink */
>+	case 241:
>+		break;
>+	/* linux_mq_timedsend */
>+	case 242:
>+		break;
>+	/* linux_mq_timedreceive */
>+	case 243:
>+		break;
>+	/* linux_mq_notify */
>+	case 244:
>+		break;
>+	/* linux_mq_getsetattr */
>+	case 245:
>+		break;
>+	/* linux_kexec_load */
>+	case 246:
>+		break;
>+	/* linux_waitid */
>+	case 247:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "l_pid_t";
>+			break;
>+		case 2:
>+			p = "l_siginfo_t *";
>+			break;
>+		case 3:
>+			p = "int";
>+			break;
>+		case 4:
>+			p = "struct l_rusage *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_add_key */
>+	case 248:
>+		break;
>+	/* linux_request_key */
>+	case 249:
>+		break;
>+	/* linux_keyctl */
>+	case 250:
>+		break;
>+	/* linux_ioprio_set */
>+	case 251:
>+		break;
>+	/* linux_ioprio_get */
>+	case 252:
>+		break;
>+	/* linux_inotify_init */
>+	case 253:
>+		break;
>+	/* linux_inotify_add_watch */
>+	case 254:
>+		break;
>+	/* linux_inotify_rm_watch */
>+	case 255:
>+		break;
>+	/* linux_migrate_pages */
>+	case 256:
>+		break;
>+	/* linux_openat */
>+	case 257:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mkdirat */
>+	case 258:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_mknodat */
>+	case 259:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fchownat */
>+	case 260:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_uid_t";
>+			break;
>+		case 3:
>+			p = "l_gid_t";
>+			break;
>+		case 4:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_futimesat */
>+	case 261:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "struct l_timeval *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_newfstatat */
>+	case 262:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "char *";
>+			break;
>+		case 2:
>+			p = "struct l_stat64 *";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_unlinkat */
>+	case 263:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_renameat */
>+	case 264:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "const char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_linkat */
>+	case 265:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "const char *";
>+			break;
>+		case 4:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_symlinkat */
>+	case 266:
>+		switch(ndx) {
>+		case 0:
>+			p = "const char *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "const char *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_readlinkat */
>+	case 267:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "char *";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fchmodat */
>+	case 268:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_mode_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_faccessat */
>+	case 269:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_pselect6 */
>+	case 270:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_fd_set *";
>+			break;
>+		case 2:
>+			p = "l_fd_set *";
>+			break;
>+		case 3:
>+			p = "l_fd_set *";
>+			break;
>+		case 4:
>+			p = "struct l_timespec *";
>+			break;
>+		case 5:
>+			p = "l_uintptr_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_ppoll */
>+	case 271:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct pollfd *";
>+			break;
>+		case 1:
>+			p = "uint32_t";
>+			break;
>+		case 2:
>+			p = "struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "l_sigset_t *";
>+			break;
>+		case 4:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_unshare */
>+	case 272:
>+		break;
>+	/* linux_set_robust_list */
>+	case 273:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct linux_robust_list_head *";
>+			break;
>+		case 1:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_get_robust_list */
>+	case 274:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct linux_robust_list_head *";
>+			break;
>+		case 2:
>+			p = "l_size_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_splice */
>+	case 275:
>+		break;
>+	/* linux_tee */
>+	case 276:
>+		break;
>+	/* linux_sync_file_range */
>+	case 277:
>+		break;
>+	/* linux_vmsplice */
>+	case 278:
>+		break;
>+	/* linux_move_pages */
>+	case 279:
>+		break;
>+	/* linux_utimensat */
>+	case 280:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "const struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_epoll_pwait */
>+	case 281:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct epoll_event *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		case 4:
>+			p = "l_sigset_t *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_signalfd */
>+	case 282:
>+		break;
>+	/* linux_timerfd */
>+	case 283:
>+		break;
>+	/* linux_eventfd */
>+	case 284:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fallocate */
>+	case 285:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_loff_t";
>+			break;
>+		case 3:
>+			p = "l_loff_t";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_timerfd_settime */
>+	case 286:
>+		break;
>+	/* linux_timerfd_gettime */
>+	case 287:
>+		break;
>+	/* linux_accept4 */
>+	case 288:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_uintptr_t";
>+			break;
>+		case 2:
>+			p = "l_uintptr_t";
>+			break;
>+		case 3:
>+			p = "int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_signalfd4 */
>+	case 289:
>+		break;
>+	/* linux_eventfd2 */
>+	case 290:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_epoll_create1 */
>+	case 291:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_dup3 */
>+	case 292:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_pipe2 */
>+	case 293:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int *";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_inotify_init1 */
>+	case 294:
>+		break;
>+	/* linux_preadv */
>+	case 295:
>+		break;
>+	/* linux_pwritev */
>+	case 296:
>+		break;
>+	/* linux_rt_tsigqueueinfo */
>+	case 297:
>+		break;
>+	/* linux_perf_event_open */
>+	case 298:
>+		break;
>+	/* linux_recvmmsg */
>+	case 299:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_mmsghdr *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		case 4:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_fanotify_init */
>+	case 300:
>+		break;
>+	/* linux_fanotify_mark */
>+	case 301:
>+		break;
>+	/* linux_prlimit64 */
>+	case 302:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "struct rlimit *";
>+			break;
>+		case 3:
>+			p = "struct rlimit *";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_name_to_handle_at */
>+	case 303:
>+		break;
>+	/* linux_open_by_handle_at */
>+	case 304:
>+		break;
>+	/* linux_clock_adjtime */
>+	case 305:
>+		break;
>+	/* linux_syncfs */
>+	case 306:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_sendmmsg */
>+	case 307:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_mmsghdr *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
>+		break;
>+	/* linux_setns */
>+	case 308:
>+		break;
>+	/* linux_process_vm_readv */
>+	case 309:
>+		break;
>+	/* linux_process_vm_writev */
>+	case 310:
>+		break;
>+	/* linux_kcmp */
>+	case 311:
>+		break;
>+	/* linux_finit_module */
>+	case 312:
>+		break;
>+	default:
>+		break;
>+	};
>+	if (p != NULL)
>+		strlcpy(desc, p, descsz);
>+}
>+static void
>+systrace_return_setargdesc(int sysnum, int ndx, char *desc, size_t descsz)
>+{
>+	const char *p = NULL;
>+	switch (sysnum) {
>+#define	nosys	linux_nosys
>+	/* read */
>+	case 0:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* write */
>+	case 1:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_open */
>+	case 2:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* close */
>+	case 3:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_newstat */
>+	case 4:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_newfstat */
>+	case 5:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_newlstat */
>+	case 6:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* poll */
>+	case 7:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_lseek */
>+	case 8:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mmap2 */
>+	case 9:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mprotect */
>+	case 10:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* munmap */
>+	case 11:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_brk */
>+	case 12:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigaction */
>+	case 13:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigprocmask */
>+	case 14:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigreturn */
>+	case 15:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_ioctl */
>+	case 16:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_pread */
>+	case 17:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_pwrite */
>+	case 18:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* readv */
>+	case 19:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* writev */
>+	case 20:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_access */
>+	case 21:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_pipe */
>+	case 22:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_select */
>+	case 23:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* sched_yield */
>+	case 24:
>+	/* linux_mremap */
>+	case 25:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_msync */
>+	case 26:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mincore */
>+	case 27:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* madvise */
>+	case 28:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_shmget */
>+	case 29:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_shmat */
>+	case 30:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_shmctl */
>+	case 31:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* dup */
>+	case 32:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* dup2 */
>+	case 33:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_pause */
>+	case 34:
>+	/* linux_nanosleep */
>+	case 35:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getitimer */
>+	case 36:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_alarm */
>+	case 37:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setitimer */
>+	case 38:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getpid */
>+	case 39:
>+	/* linux_sendfile */
>+	case 40:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_socket */
>+	case 41:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_connect */
>+	case 42:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_accept */
>+	case 43:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sendto */
>+	case 44:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_recvfrom */
>+	case 45:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sendmsg */
>+	case 46:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_recvmsg */
>+	case 47:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_shutdown */
>+	case 48:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_bind */
>+	case 49:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_listen */
>+	case 50:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getsockname */
>+	case 51:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getpeername */
>+	case 52:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_socketpair */
>+	case 53:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setsockopt */
>+	case 54:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getsockopt */
>+	case 55:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_clone */
>+	case 56:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fork */
>+	case 57:
>+	/* linux_vfork */
>+	case 58:
>+	/* linux_execve */
>+	case 59:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_exit */
>+	case 60:
>+		if (ndx == 0 || ndx == 1)
>+			p = "void";
>+		break;
>+	/* linux_wait4 */
>+	case 61:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_kill */
>+	case 62:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_newuname */
>+	case 63:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_semget */
>+	case 64:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_semop */
>+	case 65:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_semctl */
>+	case 66:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_shmdt */
>+	case 67:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_msgget */
>+	case 68:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_msgsnd */
>+	case 69:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_msgrcv */
>+	case 70:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_msgctl */
>+	case 71:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fcntl */
>+	case 72:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* flock */
>+	case 73:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* fsync */
>+	case 74:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fdatasync */
>+	case 75:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_truncate */
>+	case 76:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_ftruncate */
>+	case 77:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getdents */
>+	case 78:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getcwd */
>+	case 79:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_chdir */
>+	case 80:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* fchdir */
>+	case 81:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rename */
>+	case 82:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mkdir */
>+	case 83:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rmdir */
>+	case 84:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_creat */
>+	case 85:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_link */
>+	case 86:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_unlink */
>+	case 87:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_symlink */
>+	case 88:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_readlink */
>+	case 89:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_chmod */
>+	case 90:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* fchmod */
>+	case 91:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_chown */
>+	case 92:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* fchown */
>+	case 93:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_lchown */
>+	case 94:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* umask */
>+	case 95:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* gettimeofday */
>+	case 96:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getrlimit */
>+	case 97:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* getrusage */
>+	case 98:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sysinfo */
>+	case 99:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_times */
>+	case 100:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_ptrace */
>+	case 101:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getuid */
>+	case 102:
>+	/* linux_syslog */
>+	case 103:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getgid */
>+	case 104:
>+	/* setuid */
>+	case 105:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* setgid */
>+	case 106:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* geteuid */
>+	case 107:
>+	/* getegid */
>+	case 108:
>+	/* setpgid */
>+	case 109:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getppid */
>+	case 110:
>+	/* getpgrp */
>+	case 111:
>+	/* setsid */
>+	case 112:
>+	/* setreuid */
>+	case 113:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* setregid */
>+	case 114:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getgroups */
>+	case 115:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setgroups */
>+	case 116:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* setresuid */
>+	case 117:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* getresuid */
>+	case 118:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* setresgid */
>+	case 119:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* getresgid */
>+	case 120:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* getpgid */
>+	case 121:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setfsuid */
>+	case 122:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setfsgid */
>+	case 123:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getsid */
>+	case 124:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_capget */
>+	case 125:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_capset */
>+	case 126:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigpending */
>+	case 127:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigtimedwait */
>+	case 128:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigqueueinfo */
>+	case 129:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_rt_sigsuspend */
>+	case 130:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sigaltstack */
>+	case 131:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_utime */
>+	case 132:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mknod */
>+	case 133:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_personality */
>+	case 135:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_ustat */
>+	case 136:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_statfs */
>+	case 137:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fstatfs */
>+	case 138:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sysfs */
>+	case 139:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_getpriority */
>+	case 140:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* setpriority */
>+	case 141:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_setparam */
>+	case 142:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_getparam */
>+	case 143:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_setscheduler */
>+	case 144:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_getscheduler */
>+	case 145:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_get_priority_max */
>+	case 146:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_get_priority_min */
>+	case 147:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_rr_get_interval */
>+	case 148:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* mlock */
>+	case 149:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* munlock */
>+	case 150:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* mlockall */
>+	case 151:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* munlockall */
>+	case 152:
>+	/* linux_vhangup */
>+	case 153:
>+	/* linux_pivot_root */
>+	case 155:
>+	/* linux_sysctl */
>+	case 156:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_prctl */
>+	case 157:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_arch_prctl */
>+	case 158:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_adjtimex */
>+	case 159:
>+	/* linux_setrlimit */
>+	case 160:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* chroot */
>+	case 161:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* sync */
>+	case 162:
>+	/* acct */
>+	case 163:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* settimeofday */
>+	case 164:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mount */
>+	case 165:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_umount */
>+	case 166:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* swapon */
>+	case 167:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_swapoff */
>+	case 168:
>+	/* linux_reboot */
>+	case 169:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sethostname */
>+	case 170:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setdomainname */
>+	case 171:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_iopl */
>+	case 172:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_create_module */
>+	case 174:
>+	/* linux_init_module */
>+	case 175:
>+	/* linux_delete_module */
>+	case 176:
>+	/* linux_get_kernel_syms */
>+	case 177:
>+	/* linux_query_module */
>+	case 178:
>+	/* linux_quotactl */
>+	case 179:
>+	/* linux_nfsservctl */
>+	case 180:
>+	/* linux_getpmsg */
>+	case 181:
>+	/* linux_putpmsg */
>+	case 182:
>+	/* linux_afs_syscall */
>+	case 183:
>+	/* linux_tuxcall */
>+	case 184:
>+	/* linux_security */
>+	case 185:
>+	/* linux_gettid */
>+	case 186:
>+	/* linux_setxattr */
>+	case 188:
>+	/* linux_lsetxattr */
>+	case 189:
>+	/* linux_fsetxattr */
>+	case 190:
>+	/* linux_getxattr */
>+	case 191:
>+	/* linux_lgetxattr */
>+	case 192:
>+	/* linux_fgetxattr */
>+	case 193:
>+	/* linux_listxattr */
>+	case 194:
>+	/* linux_llistxattr */
>+	case 195:
>+	/* linux_flistxattr */
>+	case 196:
>+	/* linux_removexattr */
>+	case 197:
>+	/* linux_lremovexattr */
>+	case 198:
>+	/* linux_fremovexattr */
>+	case 199:
>+	/* linux_tkill */
>+	case 200:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_time */
>+	case 201:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sys_futex */
>+	case 202:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_setaffinity */
>+	case 203:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sched_getaffinity */
>+	case 204:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_set_thread_area */
>+	case 205:
>+	/* linux_lookup_dcookie */
>+	case 212:
>+	/* linux_epoll_create */
>+	case 213:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_epoll_ctl_old */
>+	case 214:
>+	/* linux_epoll_wait_old */
>+	case 215:
>+	/* linux_remap_file_pages */
>+	case 216:
>+	/* linux_getdents64 */
>+	case 217:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_set_tid_address */
>+	case 218:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_semtimedop */
>+	case 220:
>+	/* linux_fadvise64 */
>+	case 221:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_timer_create */
>+	case 222:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_timer_settime */
>+	case 223:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_timer_gettime */
>+	case 224:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_timer_getoverrun */
>+	case 225:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_timer_delete */
>+	case 226:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_clock_settime */
>+	case 227:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_clock_gettime */
>+	case 228:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_clock_getres */
>+	case 229:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_clock_nanosleep */
>+	case 230:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_exit_group */
>+	case 231:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_epoll_wait */
>+	case 232:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_epoll_ctl */
>+	case 233:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_tgkill */
>+	case 234:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_utimes */
>+	case 235:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mbind */
>+	case 237:
>+	/* linux_set_mempolicy */
>+	case 238:
>+	/* linux_get_mempolicy */
>+	case 239:
>+	/* linux_mq_open */
>+	case 240:
>+	/* linux_mq_unlink */
>+	case 241:
>+	/* linux_mq_timedsend */
>+	case 242:
>+	/* linux_mq_timedreceive */
>+	case 243:
>+	/* linux_mq_notify */
>+	case 244:
>+	/* linux_mq_getsetattr */
>+	case 245:
>+	/* linux_kexec_load */
>+	case 246:
>+	/* linux_waitid */
>+	case 247:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_add_key */
>+	case 248:
>+	/* linux_request_key */
>+	case 249:
>+	/* linux_keyctl */
>+	case 250:
>+	/* linux_ioprio_set */
>+	case 251:
>+	/* linux_ioprio_get */
>+	case 252:
>+	/* linux_inotify_init */
>+	case 253:
>+	/* linux_inotify_add_watch */
>+	case 254:
>+	/* linux_inotify_rm_watch */
>+	case 255:
>+	/* linux_migrate_pages */
>+	case 256:
>+	/* linux_openat */
>+	case 257:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mkdirat */
>+	case 258:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_mknodat */
>+	case 259:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fchownat */
>+	case 260:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_futimesat */
>+	case 261:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_newfstatat */
>+	case 262:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_unlinkat */
>+	case 263:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_renameat */
>+	case 264:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_linkat */
>+	case 265:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_symlinkat */
>+	case 266:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_readlinkat */
>+	case 267:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fchmodat */
>+	case 268:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_faccessat */
>+	case 269:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_pselect6 */
>+	case 270:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_ppoll */
>+	case 271:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_unshare */
>+	case 272:
>+	/* linux_set_robust_list */
>+	case 273:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_get_robust_list */
>+	case 274:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_splice */
>+	case 275:
>+	/* linux_tee */
>+	case 276:
>+	/* linux_sync_file_range */
>+	case 277:
>+	/* linux_vmsplice */
>+	case 278:
>+	/* linux_move_pages */
>+	case 279:
>+	/* linux_utimensat */
>+	case 280:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_epoll_pwait */
>+	case 281:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_signalfd */
>+	case 282:
>+	/* linux_timerfd */
>+	case 283:
>+	/* linux_eventfd */
>+	case 284:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fallocate */
>+	case 285:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_timerfd_settime */
>+	case 286:
>+	/* linux_timerfd_gettime */
>+	case 287:
>+	/* linux_accept4 */
>+	case 288:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_signalfd4 */
>+	case 289:
>+	/* linux_eventfd2 */
>+	case 290:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_epoll_create1 */
>+	case 291:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_dup3 */
>+	case 292:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_pipe2 */
>+	case 293:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_inotify_init1 */
>+	case 294:
>+	/* linux_preadv */
>+	case 295:
>+	/* linux_pwritev */
>+	case 296:
>+	/* linux_rt_tsigqueueinfo */
>+	case 297:
>+	/* linux_perf_event_open */
>+	case 298:
>+	/* linux_recvmmsg */
>+	case 299:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_fanotify_init */
>+	case 300:
>+	/* linux_fanotify_mark */
>+	case 301:
>+	/* linux_prlimit64 */
>+	case 302:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_name_to_handle_at */
>+	case 303:
>+	/* linux_open_by_handle_at */
>+	case 304:
>+	/* linux_clock_adjtime */
>+	case 305:
>+	/* linux_syncfs */
>+	case 306:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_sendmmsg */
>+	case 307:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
>+	/* linux_setns */
>+	case 308:
>+	/* linux_process_vm_readv */
>+	case 309:
>+	/* linux_process_vm_writev */
>+	case 310:
>+	/* linux_kcmp */
>+	case 311:
>+	/* linux_finit_module */
>+	case 312:
>+	default:
>+		break;
>+	};
>+	if (p != NULL)
>+		strlcpy(desc, p, descsz);
>+}
>Index: sys/amd64/linux/linux_sysvec.c
>===================================================================
>--- sys/amd64/linux/linux_sysvec.c	(revision 0)
>+++ sys/amd64/linux/linux_sysvec.c	(working copy)
>@@ -0,0 +1,1000 @@
>+/*-
>+ * Copyright (c) 2013 Dmitry Chagin
>+ * Copyright (c) 2004 Tim J. Robbins
>+ * Copyright (c) 2003 Peter Wemm
>+ * Copyright (c) 2002 Doug Rabson
>+ * Copyright (c) 1998-1999 Andrew Gallatin
>+ * Copyright (c) 1994-1996 SÃ¸ren Schmidt
>+ * 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
>+ *    in this position and unchanged.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ * 3. The name of the author may not be used to endorse or promote products
>+ *    derived from this software without specific prior written permission
>+ *
>+ * 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include "opt_compat.h"
>+
>+#define	__ELF_WORD_SIZE	64
>+
>+#include <sys/param.h>
>+#include <sys/systm.h>
>+#include <sys/exec.h>
>+#include <sys/fcntl.h>
>+#include <sys/imgact.h>
>+#include <sys/imgact_elf.h>
>+#include <sys/kernel.h>
>+#include <sys/ktr.h>
>+#include <sys/lock.h>
>+#include <sys/malloc.h>
>+#include <sys/module.h>
>+#include <sys/mutex.h>
>+#include <sys/proc.h>
>+#include <sys/resourcevar.h>
>+#include <sys/signalvar.h>
>+#include <sys/sysctl.h>
>+#include <sys/syscallsubr.h>
>+#include <sys/sysent.h>
>+#include <sys/sysproto.h>
>+#include <sys/vnode.h>
>+#include <sys/eventhandler.h>
>+
>+#include <vm/vm.h>
>+#include <vm/pmap.h>
>+#include <vm/vm_extern.h>
>+#include <vm/vm_map.h>
>+#include <vm/vm_object.h>
>+#include <vm/vm_page.h>
>+#include <vm/vm_param.h>
>+
>+#include <machine/cpu.h>
>+#include <machine/md_var.h>
>+#include <machine/pcb.h>
>+#include <machine/specialreg.h>
>+
>+#include <amd64/linux/linux.h>
>+#include <amd64/linux/linux_proto.h>
>+#include <compat/linux/linux_emul.h>
>+#include <compat/linux/linux_futex.h>
>+#include <compat/linux/linux_ioctl.h>
>+#include <compat/linux/linux_mib.h>
>+#include <compat/linux/linux_misc.h>
>+#include <compat/linux/linux_signal.h>
>+#include <compat/linux/linux_sysproto.h>
>+#include <compat/linux/linux_util.h>
>+#include <compat/linux/linux_vdso.h>
>+
>+MODULE_VERSION(linux64, 1);
>+
>+#if BYTE_ORDER == LITTLE_ENDIAN
>+#define SHELLMAGIC      0x2123 /* #! */
>+#else
>+#define SHELLMAGIC      0x2321
>+#endif
>+
>+#if defined(DEBUG)
>+SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
>+	    CTLTYPE_STRING | CTLFLAG_RW,
>+	    0, 0, linux_sysctl_debug, "A",
>+	    "Linux 64 debugging control");
>+#endif
>+
>+/*
>+ * Allow the this functions to use the ldebug() facility
>+ * even though they are not syscalls themselves. Map them
>+ * to syscall 0. This is slightly less bogus than using
>+ * ldebug(sigreturn).
>+ */
>+#define	LINUX_SYS_linux_rt_sendsig	0
>+
>+const char *linux_kplatform;
>+static int linux_szsigcode;
>+static vm_object_t linux_shared_page_obj;
>+static char *linux_shared_page_mapping;
>+extern char _binary_linux_locore_o_start;
>+extern char _binary_linux_locore_o_end;
>+
>+extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
>+
>+SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
>+
>+static register_t * linux_copyout_strings(struct image_params *imgp);
>+static int	elf_linux_fixup(register_t **stack_base,
>+		    struct image_params *iparams);
>+static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
>+static void	linux_vdso_install(void *param);
>+static void	linux_vdso_deinstall(void *param);
>+static void	linux_set_syscall_retval(struct thread *td, int error);
>+static int	linux_fetch_syscall_args(struct thread *td, struct syscall_args *sa);
>+static void	linux_exec_setregs(struct thread *td, struct image_params *imgp,
>+		    u_long stack);
>+static int	linux_vsyscall(struct thread *td, struct trapframe *tf);
>+
>+/*
>+ * Linux syscalls return negative errno's, we do positive and map them
>+ * Reference:
>+ *   FreeBSD: src/sys/sys/errno.h
>+ *   Linux:   linux-2.6.17.8/include/asm-generic/errno-base.h
>+ *            linux-2.6.17.8/include/asm-generic/errno.h
>+ */
>+static int bsd_to_linux_errno[ELAST + 1] = {
>+	-0,  -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,  -9,
>+	-10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
>+	-20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
>+	-30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
>+	-90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
>+	-100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
>+	-110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
>+	-116, -66,  -6,  -6,  -6,  -6,  -6, -37, -38,  -9,
>+	  -6,  -6, -43, -42, -75,-125, -84, -95, -16, -74,
>+	 -72, -67, -71
>+};
>+
>+#define LINUX_T_UNKNOWN  255
>+static int _bsd_to_linux_trapcode[] = {
>+	LINUX_T_UNKNOWN,	/* 0 */
>+	6,			/* 1  T_PRIVINFLT */
>+	LINUX_T_UNKNOWN,	/* 2 */
>+	3,			/* 3  T_BPTFLT */
>+	LINUX_T_UNKNOWN,	/* 4 */
>+	LINUX_T_UNKNOWN,	/* 5 */
>+	16,			/* 6  T_ARITHTRAP */
>+	254,			/* 7  T_ASTFLT */
>+	LINUX_T_UNKNOWN,	/* 8 */
>+	13,			/* 9  T_PROTFLT */
>+	1,			/* 10 T_TRCTRAP */
>+	LINUX_T_UNKNOWN,	/* 11 */
>+	14,			/* 12 T_PAGEFLT */
>+	LINUX_T_UNKNOWN,	/* 13 */
>+	17,			/* 14 T_ALIGNFLT */
>+	LINUX_T_UNKNOWN,	/* 15 */
>+	LINUX_T_UNKNOWN,	/* 16 */
>+	LINUX_T_UNKNOWN,	/* 17 */
>+	0,			/* 18 T_DIVIDE */
>+	2,			/* 19 T_NMI */
>+	4,			/* 20 T_OFLOW */
>+	5,			/* 21 T_BOUND */
>+	7,			/* 22 T_DNA */
>+	8,			/* 23 T_DOUBLEFLT */
>+	9,			/* 24 T_FPOPFLT */
>+	10,			/* 25 T_TSSFLT */
>+	11,			/* 26 T_SEGNPFLT */
>+	12,			/* 27 T_STKFLT */
>+	18,			/* 28 T_MCHK */
>+	19,			/* 29 T_XMMFLT */
>+	15			/* 30 T_RESERVED */
>+};
>+#define bsd_to_linux_trapcode(code) \
>+    ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
>+     _bsd_to_linux_trapcode[(code)]: \
>+     LINUX_T_UNKNOWN)
>+
>+LINUX_VDSO_SYM_INTPTR(linux_rt_sigcode);
>+LINUX_VDSO_SYM_CHAR(linux_platform);
>+
>+/*
>+ * If FreeBSD & Linux have a difference of opinion about what a trap
>+ * means, deal with it here.
>+ *
>+ * MPSAFE
>+ */
>+static int
>+translate_traps(int signal, int trap_code)
>+{
>+
>+	if (signal != SIGBUS)
>+		return signal;
>+	switch (trap_code) {
>+	case T_PROTFLT:
>+	case T_TSSFLT:
>+	case T_DOUBLEFLT:
>+	case T_PAGEFLT:
>+		return SIGSEGV;
>+	default:
>+		return signal;
>+	}
>+}
>+
>+static int
>+linux_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
>+{
>+	struct proc *p;
>+	struct trapframe *frame;
>+
>+	p = td->td_proc;
>+	frame = td->td_frame;
>+
>+	sa->args[0] = frame->tf_rdi;
>+	sa->args[1] = frame->tf_rsi;
>+	sa->args[2] = frame->tf_rdx;
>+	sa->args[3] = frame->tf_rcx;
>+	sa->args[4] = frame->tf_r8;
>+	sa->args[5] = frame->tf_r9;
>+	sa->code = frame->tf_rax;
>+
>+	if (sa->code >= p->p_sysent->sv_size)
>+		/* nosys */
>+		sa->callp = &p->p_sysent->sv_table[LINUX_SYS_MAXSYSCALL];
>+	else
>+		sa->callp = &p->p_sysent->sv_table[sa->code];
>+	sa->narg = sa->callp->sy_narg;
>+
>+	td->td_retval[0] = 0;
>+	return (0);
>+}
>+
>+static void
>+linux_set_syscall_retval(struct thread *td, int error)
>+{
>+	struct trapframe *frame = td->td_frame;
>+
>+	/*
>+	 * On Linux only %rcx and %r11 values are not preserved across
>+	 * the syscall.
>+	 * So, do not clobber %rdx and %r10
>+	 */
>+	td->td_retval[1] = frame->tf_rdx;
>+	frame->tf_r10 = frame->tf_rcx;
>+
>+	cpu_set_syscall_retval(td, error);
>+
>+	 /* Restore all registers. */
>+	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
>+}
>+
>+static int
>+elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
>+{
>+	Elf_Auxargs *args;
>+	Elf_Addr *base;
>+	Elf_Addr *pos;
>+	struct ps_strings *arginfo;
>+	struct proc *p;
>+
>+	p = imgp->proc;
>+	arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
>+
>+	KASSERT(curthread->td_proc == imgp->proc,
>+	    ("unsafe elf_linux_fixup(), should be curproc"));
>+	base = (Elf64_Addr *)*stack_base;
>+	args = (Elf64_Auxargs *)imgp->auxargs;
>+	pos = base + (imgp->args->argc + imgp->args->envc + 2);
>+
>+	AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO_EHDR,
>+	    imgp->proc->p_sysent->sv_shared_page_base);
>+	AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, cpu_feature);
>+	AUXARGS_ENTRY(pos, LINUX_AT_CLKTCK, stclohz);
>+	AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
>+	AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
>+	AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
>+	AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
>+	AUXARGS_ENTRY(pos, AT_BASE, args->base);
>+	AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
>+	AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
>+	AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
>+	AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
>+	AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
>+	AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
>+	AUXARGS_ENTRY(pos, LINUX_AT_SECURE, 0);
>+	AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(linux_platform));
>+	AUXARGS_ENTRY(pos, LINUX_AT_RANDOM, imgp->canary);
>+	if (imgp->execpathp != 0)
>+		AUXARGS_ENTRY(pos, LINUX_AT_EXECFN, imgp->execpathp);
>+	if (args->execfd != -1)
>+		AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
>+	AUXARGS_ENTRY(pos, AT_NULL, 0);
>+	free(imgp->auxargs, M_TEMP);
>+	imgp->auxargs = NULL;
>+
>+	base--;
>+	suword(base, (uint64_t)imgp->args->argc);
>+
>+	*stack_base = (register_t *)base;
>+	return (0);
>+}
>+
>+/*
>+ * Copy strings out to the new process address space, constructing new arg
>+ * and env vector tables. Return a pointer to the base so that it can be used
>+ * as the initial stack pointer.
>+ */
>+static register_t *
>+linux_copyout_strings(struct image_params *imgp)
>+{
>+	int argc, envc;
>+	char **vectp;
>+	char *stringp, *destp;
>+	register_t *stack_base;
>+	struct ps_strings *arginfo;
>+	char canary[LINUX_AT_RANDOM_LEN];
>+	size_t execpath_len;
>+	struct proc *p;
>+
>+	/*
>+	 * Calculate string base and vector table pointers.
>+	 */
>+	if (imgp->execpath != NULL && imgp->auxargs != NULL)
>+		execpath_len = strlen(imgp->execpath) + 1;
>+	else
>+		execpath_len = 0;
>+
>+	p = imgp->proc;
>+	arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
>+	destp =	(caddr_t)arginfo - SPARE_USRSPACE -
>+	    roundup(sizeof(canary), sizeof(char *)) -
>+	    roundup(execpath_len, sizeof(char *)) -
>+	    roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
>+
>+	if (execpath_len != 0) {
>+		imgp->execpathp = (uintptr_t)arginfo - execpath_len;
>+		copyout(imgp->execpath, (void *)imgp->execpathp, execpath_len);
>+	}
>+
>+	/*
>+	 * Prepare the canary for SSP.
>+	 */
>+	arc4rand(canary, sizeof(canary), 0);
>+	imgp->canary = (uintptr_t)arginfo -
>+	    roundup(execpath_len, sizeof(char *)) -
>+	    roundup(sizeof(canary), sizeof(char *));
>+	copyout(canary, (void *)imgp->canary, sizeof(canary));
>+
>+	/*
>+	 * If we have a valid auxargs ptr, prepare some room
>+	 * on the stack.
>+	 */
>+	if (imgp->auxargs) {
>+		/*
>+		 * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
>+		 * lower compatibility.
>+		 */
>+		imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
>+		    (LINUX_AT_COUNT * 2);
>+
>+		/*
>+		 * The '+ 2' is for the null pointers at the end of each of
>+		 * the arg and env vector sets,and imgp->auxarg_size is room
>+		 * for argument of Runtime loader.
>+		 */
>+		vectp = (char **)(destp - (imgp->args->argc +
>+		    imgp->args->envc + 2 + imgp->auxarg_size) * sizeof(char *));
>+
>+	} else {
>+		/*
>+		 * The '+ 2' is for the null pointers at the end of each of
>+		 * the arg and env vector sets
>+		 */
>+		vectp = (char **)(destp - (imgp->args->argc +
>+		    imgp->args->envc + 2) * sizeof(char *));
>+	}
>+
>+	/*
>+	 * vectp also becomes our initial stack base
>+	 */
>+	stack_base = (register_t *)vectp;
>+
>+	stringp = imgp->args->begin_argv;
>+	argc = imgp->args->argc;
>+	envc = imgp->args->envc;
>+
>+	/*
>+	 * Copy out strings - arguments and environment.
>+	 */
>+	copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
>+
>+	/*
>+	 * Fill in "ps_strings" struct for ps, w, etc.
>+	 */
>+	suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp);
>+	suword(&arginfo->ps_nargvstr, argc);
>+
>+	/*
>+	 * Fill in argument portion of vector table.
>+	 */
>+	for (; argc > 0; --argc) {
>+		suword(vectp++, (long)(intptr_t)destp);
>+		while (*stringp++ != 0)
>+			destp++;
>+		destp++;
>+	}
>+
>+	/* a null vector table pointer separates the argp's from the envp's */
>+	suword(vectp++, 0);
>+
>+	suword(&arginfo->ps_envstr, (long)(intptr_t)vectp);
>+	suword(&arginfo->ps_nenvstr, envc);
>+
>+	/*
>+	 * Fill in environment portion of vector table.
>+	 */
>+	for (; envc > 0; --envc) {
>+		suword(vectp++, (long)(intptr_t)destp);
>+		while (*stringp++ != 0)
>+			destp++;
>+		destp++;
>+	}
>+
>+	/* end of vector table is a null pointer */
>+	suword(vectp, 0);
>+	return (stack_base);
>+}
>+
>+/*
>+ * Reset registers to default values on exec.
>+ */
>+static void
>+linux_exec_setregs(struct thread *td, struct image_params *imgp, u_long stack)
>+{
>+	struct trapframe *regs = td->td_frame;
>+	struct pcb *pcb = td->td_pcb;
>+
>+	mtx_lock(&dt_lock);
>+	if (td->td_proc->p_md.md_ldt != NULL)
>+		user_ldt_free(td);
>+	else
>+		mtx_unlock(&dt_lock);
>+
>+	pcb->pcb_fsbase = 0;
>+	pcb->pcb_gsbase = 0;
>+	clear_pcb_flags(pcb, PCB_32BIT);
>+	pcb->pcb_initial_fpucw = __LINUX_NPXCW__;
>+	set_pcb_flags(pcb, PCB_FULL_IRET);
>+
>+	bzero((char *)regs, sizeof(struct trapframe));
>+	regs->tf_rip = imgp->entry_addr;
>+	regs->tf_rsp = stack;
>+	regs->tf_rflags = PSL_USER | (regs->tf_rflags & PSL_T);
>+	regs->tf_ss = _udatasel;
>+	regs->tf_cs = _ucodesel;
>+	regs->tf_ds = _udatasel;
>+	regs->tf_es = _udatasel;
>+	regs->tf_fs = _ufssel;
>+	regs->tf_gs = _ugssel;
>+	regs->tf_flags = TF_HASSEGS;
>+
>+	/*
>+	 * Reset the hardware debug registers if they were in use.
>+	 * They won't have any meaning for the newly exec'd process.
>+	 */
>+	if (pcb->pcb_flags & PCB_DBREGS) {
>+		pcb->pcb_dr0 = 0;
>+		pcb->pcb_dr1 = 0;
>+		pcb->pcb_dr2 = 0;
>+		pcb->pcb_dr3 = 0;
>+		pcb->pcb_dr6 = 0;
>+		pcb->pcb_dr7 = 0;
>+		if (pcb == curpcb) {
>+			/*
>+			 * Clear the debug registers on the running
>+			 * CPU, otherwise they will end up affecting
>+			 * the next process we switch to.
>+			 */
>+			reset_dbregs();
>+		}
>+		clear_pcb_flags(pcb, PCB_DBREGS);
>+	}
>+
>+	/*
>+	 * Drop the FP state if we hold it, so that the process gets a
>+	 * clean FP state if it uses the FPU again.
>+	 */
>+	fpstate_drop(td);
>+}
>+
>+/*
>+ * Copied from amd64/amd64/machdep.c
>+ *
>+ * XXX fpu state need? don't think so
>+ */
>+int
>+linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
>+{
>+	struct proc *p;
>+	struct l_ucontext uc;
>+	struct l_sigcontext *context;
>+	struct trapframe *regs;
>+	unsigned long rflags;
>+	int error;
>+	ksiginfo_t ksi;
>+
>+	regs = td->td_frame;
>+	error = copyin((void *)regs->tf_rbx, &uc, sizeof(uc));
>+	if (error != 0)
>+		return (error);
>+
>+	p = td->td_proc;
>+	context = &uc.uc_mcontext;
>+	rflags = context->sc_rflags;
>+
>+	/*
>+	 * Don't allow users to change privileged or reserved flags.
>+	 */
>+	/*
>+	 * XXX do allow users to change the privileged flag PSL_RF.
>+	 * The cpu sets PSL_RF in tf_rflags for faults.  Debuggers
>+	 * should sometimes set it there too.  tf_rflags is kept in
>+	 * the signal context during signal handling and there is no
>+	 * other place to remember it, so the PSL_RF bit may be
>+	 * corrupted by the signal handler without us knowing.
>+	 * Corruption of the PSL_RF bit at worst causes one more or
>+	 * one less debugger trap, so allowing it is fairly harmless.
>+	 */
>+
>+#define RFLAG_SECURE(ef, oef)     ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
>+	if (!RFLAG_SECURE(rflags & ~PSL_RF, regs->tf_rflags & ~PSL_RF)) {
>+		printf("linux_rt_sigreturn: rflags = 0x%lx\n", rflags);
>+		return (EINVAL);
>+	}
>+
>+	/*
>+	 * Don't allow users to load a valid privileged %cs.  Let the
>+	 * hardware check for invalid selectors, excess privilege in
>+	 * other selectors, invalid %eip's and invalid %esp's.
>+	 */
>+#define CS_SECURE(cs)           (ISPL(cs) == SEL_UPL)
>+	if (!CS_SECURE(context->sc_cs)) {
>+		printf("linux_rt_sigreturn: cs = 0x%x\n", context->sc_cs);
>+		ksiginfo_init_trap(&ksi);
>+		ksi.ksi_signo = SIGBUS;
>+		ksi.ksi_code = BUS_OBJERR;
>+		ksi.ksi_trapno = T_PROTFLT;
>+		ksi.ksi_addr = (void *)regs->tf_rip;
>+		trapsignal(td, &ksi);
>+		return (EINVAL);
>+	}
>+
>+	PROC_LOCK(p);
>+	linux_to_bsd_sigset(&uc.uc_sigmask, &td->td_sigmask);
>+	SIG_CANTMASK(td->td_sigmask);
>+	signotify(td);
>+	PROC_UNLOCK(p);
>+
>+	regs->tf_rdi    = context->sc_rdi;
>+	regs->tf_rsi    = context->sc_rsi;
>+	regs->tf_rdx    = context->sc_rdx;
>+	regs->tf_rbp    = context->sc_rbp;
>+	regs->tf_rbx    = context->sc_rbx;
>+	regs->tf_rcx    = context->sc_rcx;
>+	regs->tf_rax    = context->sc_rax;
>+	regs->tf_rip    = context->sc_rip;
>+	regs->tf_rsp    = context->sc_rsp;
>+	regs->tf_r8     = context->sc_r8;
>+	regs->tf_r9     = context->sc_r9;
>+	regs->tf_r10    = context->sc_r10;
>+	regs->tf_r11    = context->sc_r11;
>+	regs->tf_r12    = context->sc_r12;
>+	regs->tf_r13    = context->sc_r13;
>+	regs->tf_r14    = context->sc_r14;
>+	regs->tf_r15    = context->sc_r15;
>+	regs->tf_cs     = context->sc_cs;
>+	regs->tf_err    = context->sc_err;
>+	regs->tf_rflags = rflags;
>+
>+	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
>+	return (EJUSTRETURN);
>+}
>+
>+/*
>+ * copied from amd64/amd64/machdep.c
>+ *
>+ * Send an interrupt to process.
>+ */
>+static void
>+linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
>+{
>+	struct l_rt_sigframe sf, *sfp;
>+	struct proc *p;
>+	struct thread *td;
>+	struct sigacts *psp;
>+	caddr_t sp;
>+	struct trapframe *regs;
>+	int sig, code;
>+	int oonstack;
>+
>+	td = curthread;
>+	p = td->td_proc;
>+	PROC_LOCK_ASSERT(p, MA_OWNED);
>+	sig = ksi->ksi_signo;
>+	psp = p->p_sigacts;
>+	code = ksi->ksi_code;
>+	mtx_assert(&psp->ps_mtx, MA_OWNED);
>+	regs = td->td_frame;
>+	oonstack = sigonstack(regs->tf_rsp);
>+
>+	LINUX_CTR4(rt_sendsig, "%p, %d, %p, %u",
>+	    catcher, sig, mask, code);
>+
>+	/* Allocate space for the signal handler context. */
>+	if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack &&
>+	    SIGISMEMBER(psp->ps_sigonstack, sig)) {
>+		sp = td->td_sigstk.ss_sp + td->td_sigstk.ss_size -
>+		    sizeof(struct l_rt_sigframe);
>+	} else
>+		sp = (caddr_t)regs->tf_rsp - sizeof(struct l_rt_sigframe) - 128;
>+	/* Align to 16 bytes. */
>+	sfp = (struct l_rt_sigframe *)((unsigned long)sp & ~0xFul);
>+	mtx_unlock(&psp->ps_mtx);
>+
>+	/* Translate the signal. */
>+	sig = bsd_to_linux_signal(sig);
>+
>+	/* Save user context. */
>+	bzero(&sf, sizeof(sf));
>+	bsd_to_linux_sigset(mask, &sf.sf_sc.uc_sigmask);
>+	bsd_to_linux_sigset(mask, &sf.sf_sc.uc_mcontext.sc_mask);
>+
>+	sf.sf_sc.uc_stack.ss_sp = PTROUT(td->td_sigstk.ss_sp);
>+	sf.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
>+	sf.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
>+	    ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
>+	PROC_UNLOCK(p);
>+
>+	sf.sf_sc.uc_mcontext.sc_rdi    = regs->tf_rdi;
>+	sf.sf_sc.uc_mcontext.sc_rsi    = regs->tf_rsi;
>+	sf.sf_sc.uc_mcontext.sc_rdx    = regs->tf_rdx;
>+	sf.sf_sc.uc_mcontext.sc_rbp    = regs->tf_rbp;
>+	sf.sf_sc.uc_mcontext.sc_rbx    = regs->tf_rbx;
>+	sf.sf_sc.uc_mcontext.sc_rcx    = regs->tf_rcx;
>+	sf.sf_sc.uc_mcontext.sc_rax    = regs->tf_rax;
>+	sf.sf_sc.uc_mcontext.sc_rip    = regs->tf_rip;
>+	sf.sf_sc.uc_mcontext.sc_rsp    = regs->tf_rsp;
>+	sf.sf_sc.uc_mcontext.sc_r8     = regs->tf_r8;
>+	sf.sf_sc.uc_mcontext.sc_r9     = regs->tf_r9;
>+	sf.sf_sc.uc_mcontext.sc_r10    = regs->tf_r10;
>+	sf.sf_sc.uc_mcontext.sc_r11    = regs->tf_r11;
>+	sf.sf_sc.uc_mcontext.sc_r12    = regs->tf_r12;
>+	sf.sf_sc.uc_mcontext.sc_r13    = regs->tf_r13;
>+	sf.sf_sc.uc_mcontext.sc_r14    = regs->tf_r14;
>+	sf.sf_sc.uc_mcontext.sc_r15    = regs->tf_r15;
>+	sf.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
>+	sf.sf_sc.uc_mcontext.sc_rflags = regs->tf_rflags;
>+	sf.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
>+	sf.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
>+	sf.sf_sc.uc_mcontext.sc_cr2    = (register_t)ksi->ksi_addr;
>+
>+	/* Build the argument list for the signal handler. */
>+	regs->tf_rdi = sig;			/* arg 1 in %rdi */
>+	regs->tf_rax = 0;
>+	regs->tf_rsi = (register_t)&sfp->sf_si;	/* arg 2 in %rsi */
>+	regs->tf_rdx = (register_t)&sfp->sf_sc;	/* arg 3 in %rdx */
>+
>+	sf.sf_handler = catcher;
>+	/* Fill in POSIX parts */
>+	ksiginfo_to_lsiginfo(ksi, &sf.sf_si, sig);
>+
>+	/*
>+	 * Copy the sigframe out to the user's stack.
>+	 */
>+	if (copyout(&sf, sfp, sizeof(*sfp)) != 0) {
>+#ifdef DEBUG
>+		printf("process %ld has trashed its stack\n", (long)p->p_pid);
>+#endif
>+		PROC_LOCK(p);
>+		sigexit(td, SIGILL);
>+	}
>+
>+	regs->tf_rsp = (long)sfp;
>+	regs->tf_rip = linux_rt_sigcode;
>+	regs->tf_rflags &= ~(PSL_T | PSL_D);
>+	regs->tf_cs = _ucodesel;
>+	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
>+	PROC_LOCK(p);
>+	mtx_lock(&psp->ps_mtx);
>+}
>+
>+/*
>+ * If a linux binary is exec'ing something, try this image activator
>+ * first.  We override standard shell script execution in order to
>+ * be able to modify the interpreter path.  We only do this if a linux
>+ * binary is doing the exec, so we do not create an EXEC module for it.
>+ */
>+static int exec_linux_imgact_try(struct image_params *iparams);
>+
>+static int
>+exec_linux_imgact_try(struct image_params *imgp)
>+{
>+	const char *head = (const char *)imgp->image_header;
>+	char *rpath;
>+	int error = -1, len;
>+
>+	/*
>+	 * The interpreter for shell scripts run from a linux binary needs
>+	 * to be located in /compat/linux if possible in order to recursively
>+	 * maintain linux path emulation.
>+	 */
>+	if (((const short *)head)[0] == SHELLMAGIC) {
>+		/*
>+		 * Run our normal shell image activator.  If it succeeds
>+		 * attempt to use the alternate path for the interpreter.
>+		 * If an alternate path is found, use our stringspace
>+		 * to store it.
>+		 */
>+		if ((error = exec_shell_imgact(imgp)) == 0) {
>+			linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
>+			    imgp->interpreter_name, UIO_SYSSPACE,
>+			    &rpath, 0, AT_FDCWD);
>+			if (rpath != NULL) {
>+				len = strlen(rpath) + 1;
>+
>+				if (len <= MAXSHELLCMDLEN)
>+					memcpy(imgp->interpreter_name,
>+					    rpath, len);
>+				free(rpath, M_TEMP);
>+			}
>+		}
>+	}
>+	return(error);
>+}
>+
>+/*
>+ * vsyscall area, temporary hack. XXX
>+ *
>+ * getcpu missied....
>+ */
>+#define	LINUX_VSYSCALL_START		(-10UL << 20)
>+#define	LINUX_VSYSCALL_SIZE		1024
>+#define	LINUX_VSYSCALL_NR		3
>+
>+const unsigned long linux_vsyscall_vector[] = {
>+	LINUX_SYS_gettimeofday,
>+	LINUX_SYS_linux_time,
>+	-1,
>+	-1
>+};
>+
>+static int
>+linux_vsyscall(struct thread *td, struct trapframe *tf)
>+{
>+	int code, error, traced;
>+	uint64_t retqaddr, trapaddr;
>+
>+	error = -1;
>+	trapaddr = tf->tf_rip;
>+
>+	/* check up %rip for LINUX_VSYSCALL AREA */
>+	if (__predict_true(trapaddr < LINUX_VSYSCALL_START))
>+		return (error);
>+	if ((tf->tf_rip & (LINUX_VSYSCALL_SIZE - 1)) != 0)
>+		return (error);
>+	code = (tf->tf_rip - LINUX_VSYSCALL_START) / LINUX_VSYSCALL_SIZE;
>+	if (code > LINUX_VSYSCALL_NR)
>+		return (error);
>+	/*
>+	 * vsyscall called as callq *(%rax), so we must
>+	 * use return address from %rsp and also fixup %rsp
>+	 */
>+	error = copyin((void *)tf->tf_rsp, &retqaddr, sizeof(retqaddr));
>+	if (error)
>+		return (error);
>+
>+	tf->tf_rip = retqaddr;
>+	tf->tf_rax = linux_vsyscall_vector[code];
>+	tf->tf_rsp += 8;
>+
>+	traced = (tf->tf_flags & PSL_T);
>+
>+	amd64_syscall(td, traced);
>+
>+	return (0);
>+}
>+
>+struct sysentvec elf_linux_sysvec = {
>+	.sv_size	= LINUX_SYS_MAXSYSCALL,
>+	.sv_table	= linux_sysent,
>+	.sv_mask	= 0,
>+	.sv_sigsize	= 0,
>+	.sv_sigtbl	= NULL,
>+	.sv_errsize	= ELAST + 1,
>+	.sv_errtbl	= bsd_to_linux_errno,
>+	.sv_transtrap	= translate_traps,
>+	.sv_fixup	= elf_linux_fixup,
>+	.sv_sendsig	= linux_rt_sendsig,
>+	.sv_sigcode	= &_binary_linux_locore_o_start,
>+	.sv_szsigcode	= &linux_szsigcode,
>+	.sv_prepsyscall	= NULL,
>+	.sv_name	= "Linux ELF64",
>+	.sv_coredump	= elf64_coredump,
>+	.sv_imgact_try	= exec_linux_imgact_try,
>+	.sv_minsigstksz	= LINUX_MINSIGSTKSZ,
>+	.sv_pagesize	= PAGE_SIZE,
>+	.sv_minuser	= VM_MIN_ADDRESS,
>+	.sv_maxuser	= VM_MAXUSER_ADDRESS,
>+	.sv_usrstack	= USRSTACK,
>+	.sv_psstrings	= PS_STRINGS,
>+	.sv_stackprot	= VM_PROT_ALL,
>+	.sv_copyout_strings = linux_copyout_strings,
>+	.sv_setregs	= linux_exec_setregs,
>+	.sv_fixlimit	= NULL,
>+	.sv_maxssiz	= NULL,
>+	.sv_flags	= SV_ABI_LINUX | SV_LP64 | SV_SHP,
>+	.sv_set_syscall_retval = linux_set_syscall_retval,
>+	.sv_fetch_syscall_args = linux_fetch_syscall_args,
>+	.sv_syscallnames = NULL,
>+	.sv_shared_page_base = SHAREDPAGE,
>+	.sv_shared_page_len = PAGE_SIZE,
>+	.sv_schedtail	= linux_schedtail,
>+	.sv_thread_detach = linux_thread_detach,
>+	.sv_trap	= linux_vsyscall,
>+};
>+
>+static void
>+linux_vdso_install(void *param)
>+{
>+
>+	linux_szsigcode = (&_binary_linux_locore_o_end - 
>+	    &_binary_linux_locore_o_start);
>+
>+	if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
>+		panic("Linux invalid vdso size\n");
>+
>+	__elfN(linux_vdso_fixup)(&elf_linux_sysvec);
>+
>+	linux_shared_page_obj = __elfN(linux_shared_page_init)
>+	    (&linux_shared_page_mapping);
>+
>+	__elfN(linux_vdso_reloc)(&elf_linux_sysvec, SHAREDPAGE);
>+
>+	bcopy(elf_linux_sysvec.sv_sigcode, linux_shared_page_mapping,
>+	    linux_szsigcode);
>+	elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
>+
>+	linux_kplatform = linux_shared_page_mapping +
>+	    (linux_platform - (caddr_t)SHAREDPAGE);
>+}
>+SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
>+    (sysinit_cfunc_t)linux_vdso_install, NULL);
>+
>+static void
>+linux_vdso_deinstall(void *param)
>+{
>+
>+	__elfN(linux_shared_page_fini)(linux_shared_page_obj);
>+};
>+SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
>+    (sysinit_cfunc_t)linux_vdso_deinstall, NULL);
>+
>+static char GNULINUX_ABI_VENDOR[] = "GNU";
>+static int GNULINUX_ABI_DESC = 0;
>+
>+static boolean_t
>+linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
>+{
>+	const Elf32_Word *desc;
>+	uintptr_t p;
>+
>+	p = (uintptr_t)(note + 1);
>+	p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
>+
>+	desc = (const Elf32_Word *)p;
>+	if (desc[0] != GNULINUX_ABI_DESC)
>+		return (FALSE);
>+
>+	/*
>+	 * For linux we encode osrel as follows (see linux_mib.c):
>+	 * VVVMMMIII (version, major, minor), see linux_mib.c.
>+	 */
>+	*osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
>+
>+	return (TRUE);
>+}
>+
>+static Elf_Brandnote linux64_brandnote = {
>+	.hdr.n_namesz	= sizeof(GNULINUX_ABI_VENDOR),
>+	.hdr.n_descsz	= 16,
>+	.hdr.n_type	= 1,
>+	.vendor		= GNULINUX_ABI_VENDOR,
>+	.flags		= BN_TRANSLATE_OSREL,
>+	.trans_osrel	= linux_trans_osrel
>+};
>+
>+static Elf64_Brandinfo linux_glibc2brand = {
>+	.brand		= ELFOSABI_LINUX,
>+	.machine	= EM_X86_64,
>+	.compat_3_brand	= "Linux",
>+	.emul_path	= "/compat/linux",
>+	.interp_path	= "/lib64/ld-linux-x86-64.so.2",
>+	.sysvec		= &elf_linux_sysvec,
>+	.interp_newpath	= NULL,
>+	.brand_note	= &linux64_brandnote,
>+	.flags		= BI_CAN_EXEC_DYN | BI_BRAND_NOTE
>+};
>+
>+static Elf64_Brandinfo linux_glibc2brandshort = {
>+	.brand		= ELFOSABI_LINUX,
>+	.machine	= EM_X86_64,
>+	.compat_3_brand	= "Linux",
>+	.emul_path	= "/compat/linux",
>+	.interp_path	= "/lib64/ld-linux.so.2",
>+	.sysvec		= &elf_linux_sysvec,
>+	.interp_newpath	= NULL,
>+	.brand_note	= &linux64_brandnote,
>+	.flags		= BI_CAN_EXEC_DYN | BI_BRAND_NOTE
>+};
>+
>+Elf64_Brandinfo *linux_brandlist[] = {
>+	&linux_glibc2brand,
>+	&linux_glibc2brandshort,
>+	NULL
>+};
>+
>+static int
>+linux64_elf_modevent(module_t mod, int type, void *data)
>+{
>+	Elf64_Brandinfo **brandinfo;
>+	int error;
>+	struct linux_ioctl_handler **lihp;
>+
>+	error = 0;
>+
>+	switch(type) {
>+	case MOD_LOAD:
>+		for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
>+		     ++brandinfo)
>+			if (elf64_insert_brand_entry(*brandinfo) < 0)
>+				error = EINVAL;
>+		if (error == 0) {
>+			SET_FOREACH(lihp, linux_ioctl_handler_set)
>+				linux_ioctl_register_handler(*lihp);
>+			LIST_INIT(&futex_list);
>+			mtx_init(&futex_mtx, "ftllk64", NULL, MTX_DEF);
>+			stclohz = (stathz ? stathz : hz);
>+			if (bootverbose)
>+				printf("Linux x86-64 ELF exec handler installed\n");
>+		} else
>+			printf("cannot insert Linux x86-64 ELF brand handler\n");
>+		break;
>+	case MOD_UNLOAD:
>+		for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
>+		     ++brandinfo)
>+			if (elf64_brand_inuse(*brandinfo))
>+				error = EBUSY;
>+		if (error == 0) {
>+			for (brandinfo = &linux_brandlist[0];
>+			     *brandinfo != NULL; ++brandinfo)
>+				if (elf64_remove_brand_entry(*brandinfo) < 0)
>+					error = EINVAL;
>+		}
>+		if (error == 0) {
>+			SET_FOREACH(lihp, linux_ioctl_handler_set)
>+				linux_ioctl_unregister_handler(*lihp);
>+			mtx_destroy(&futex_mtx);
>+			if (bootverbose)
>+				printf("Linux ELF exec handler removed\n");
>+		} else
>+			printf("Could not deinstall ELF interpreter entry\n");
>+		break;
>+	default:
>+		return (EOPNOTSUPP);
>+	}
>+	return (error);
>+}
>+
>+static moduledata_t linux64_elf_mod = {
>+	"linux64elf",
>+	linux64_elf_modevent,
>+	0
>+};
>+
>+DECLARE_MODULE_TIED(linux64elf, linux64_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);
>+MODULE_DEPEND(linux64elf, linux_common, 1, 1, 1);
>Index: sys/amd64/linux/linux_vdso.lds.s
>===================================================================
>--- sys/amd64/linux/linux_vdso.lds.s	(revision 0)
>+++ sys/amd64/linux/linux_vdso.lds.s	(working copy)
>@@ -0,0 +1,69 @@
>+/*
>+ * Linker script for 64-bit vDSO.
>+ * Copied from Linux kernel arch/x86/vdso/vdso-layout.lds.S
>+ *
>+ * $FreeBSD$
>+ */
>+
>+SECTIONS
>+{
>+	. = . + SIZEOF_HEADERS;
>+
>+	.hash		: { *(.hash) }			:text
>+	.gnu.hash	: { *(.gnu.hash) }
>+	.dynsym		: { *(.dynsym) }
>+	.dynstr		: { *(.dynstr) }
>+	.gnu.version	: { *(.gnu.version) }
>+	.gnu.version_d	: { *(.gnu.version_d) }
>+	.gnu.version_r	: { *(.gnu.version_r) }
>+
>+	.note		: { *(.note.*) }		:text	:note
>+
>+	.eh_frame_hdr	: { *(.eh_frame_hdr) }		:text	:eh_frame_hdr
>+	.eh_frame	: { KEEP (*(.eh_frame)) }	:text
>+
>+	.dynamic	: { *(.dynamic) }		:text	:dynamic
>+
>+	.rodata		: { *(.rodata*) }		:text
>+	.data		: {
>+	      *(.data*)
>+	      *(.sdata*)
>+	      *(.got.plt) *(.got)
>+	      *(.gnu.linkonce.d.*)
>+	      *(.bss*)
>+	      *(.dynbss*)
>+	      *(.gnu.linkonce.b.*)
>+	}
>+
>+	.altinstructions	: { *(.altinstructions) }
>+	.altinstr_replacement	: { *(.altinstr_replacement) }
>+
>+	. = ALIGN(0x100);
>+	.text		: { *(.test .text*) }			:text	=0x90909090
>+}
>+
>+PHDRS
>+{
>+	text		PT_LOAD		FLAGS(5) FILEHDR PHDRS; /* PF_R|PF_X */
>+	dynamic		PT_DYNAMIC	FLAGS(4);		/* PF_R */
>+	note		PT_NOTE		FLAGS(4);		/* PF_R */
>+	eh_frame_hdr	PT_GNU_EH_FRAME;
>+}
>+
>+VERSION
>+{
>+	LINUX_2.6 {
>+	global:
>+		time;
>+		__vdso_time;
>+		gettimeofday;
>+		__vdso_gettimeofday;
>+		getcpu;
>+		__vdso_getcpu;
>+		clock_gettime;
>+		__vdso_clock_gettime;
>+		linux_rt_sigcode;
>+		linux_platform;
>+	local: *;
>+	};
>+}
>Index: sys/amd64/linux/syscalls.conf
>===================================================================
>--- sys/amd64/linux/syscalls.conf	(revision 0)
>+++ sys/amd64/linux/syscalls.conf	(working copy)
>@@ -0,0 +1,11 @@
>+# $FreeBSD$
>+sysnames="linux_syscalls.c"
>+sysproto="linux_proto.h"
>+sysproto_h=_LINUX_SYSPROTO_H_
>+syshdr="linux_syscall.h"
>+syssw="linux_sysent.c"
>+sysmk="/dev/null"
>+syscallprefix="LINUX_SYS_"
>+switchname="linux_sysent"
>+namesname="linux_syscallnames"
>+systrace="linux_systrace_args.c"
>Index: sys/amd64/linux/syscalls.master
>===================================================================
>--- sys/amd64/linux/syscalls.master	(revision 0)
>+++ sys/amd64/linux/syscalls.master	(working copy)
>@@ -0,0 +1,515 @@
>+ $FreeBSD$
>+
>+;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93
>+; System call name/number master file (or rather, slave, from LINUX).
>+; Processed to create linux_sysent.c, linux_proto.h and linux_syscall.h.
>+
>+; Columns: number audit type nargs name alt{name,tag,rtyp}/comments
>+;	number	system call number, must be in order
>+;	audit	the audit event associated with the system call
>+;		A value of AUE_NULL means no auditing, but it also means that
>+;		there is no audit event for the call at this time. For the
>+;		case where the event exists, but we don't want auditing, the
>+;		event should be #defined to AUE_NULL in audit_kevents.h.
>+;	type	one of STD, OBSOL, UNIMPL
>+;	name	psuedo-prototype of syscall routine
>+;		If one of the following alts is different, then all appear:
>+;	altname	name of system call if different
>+;	alttag	name of args struct tag if different from [o]`name'"_args"
>+;	altrtyp	return type if not int (bogus - syscalls always return int)
>+;		for UNIMPL/OBSOL, name continues with comments
>+
>+; types:
>+;	STD	always included
>+;	OBSOL	obsolete, not included in system, only specifies name
>+;	UNIMPL	not implemented, placeholder only
>+
>+#include <sys/param.h>
>+#include <sys/sysent.h>
>+#include <sys/sysproto.h>
>+#include <compat/linux/linux_sysproto.h>
>+#include <amd64/linux/linux.h>
>+#include <amd64/linux/linux_proto.h>
>+
>+; Isn't pretty, but there seems to be no other way to trap nosys
>+#define	nosys	linux_nosys
>+
>+; #ifdef's, etc. may be included, and are copied to the output files.
>+
>+0	AUE_NULL	NOPROTO	{ int read(int fd, char *buf, \
>+				    u_int nbyte); }
>+1	AUE_NULL	NOPROTO	{ int write(int fd, char *buf, \
>+				    u_int nbyte); }
>+2	AUE_OPEN_RWTC	STD	{ int linux_open(char *path, l_int flags, \
>+				    l_int mode); }
>+3	AUE_CLOSE	NOPROTO	{ int close(int fd); }
>+4	AUE_STAT	STD	{ int linux_newstat(char *path, \
>+				    struct l_newstat *buf); }
>+5	AUE_FSTAT	STD	{ int linux_newfstat(l_uint fd, \
>+				    struct l_newstat *buf); }
>+6	AUE_LSTAT	STD	{ int linux_newlstat(char *path, \
>+				    struct l_newstat *buf); }
>+7	AUE_POLL	NOPROTO	{ int poll(struct pollfd*, \
>+				    unsigned int nfds, int timeout); }
>+8	AUE_LSEEK	STD	{ int linux_lseek(l_uint fdes, l_off_t off, \
>+				    l_int whence); }
>+9	AUE_MMAP	STD	{ int linux_mmap2(l_ulong addr, l_ulong len, \
>+				    l_ulong prot, l_ulong flags, l_ulong fd, \
>+				    l_ulong pgoff); }
>+10	AUE_MPROTECT	STD	{ int linux_mprotect(caddr_t addr, int len, \
>+				    int prot); }
>+11	AUE_MUNMAP	NOPROTO	{ int munmap(caddr_t addr, int len); }
>+12	AUE_NULL	STD	{ int linux_brk(l_ulong dsend); }
>+13	AUE_NULL	STD	{ int linux_rt_sigaction(l_int sig, \
>+				    l_sigaction_t *act, l_sigaction_t *oact, \
>+				    l_size_t sigsetsize); }
>+14	AUE_NULL	STD	{ int linux_rt_sigprocmask(l_int how, \
>+				    l_sigset_t *mask, l_sigset_t *omask, \
>+				    l_size_t sigsetsize); }
>+15	AUE_NULL	STD	{ int linux_rt_sigreturn( \
>+				    struct l_ucontext *ucp); }
>+16	AUE_IOCTL	STD	{ int linux_ioctl(l_uint fd, l_uint cmd, \
>+				    uintptr_t arg); }
>+17	AUE_PREAD	STD	{ int linux_pread(l_uint fd, char *buf, \
>+				    l_size_t nbyte, l_loff_t offset); }
>+18	AUE_PWRITE	STD	{ int linux_pwrite(l_uint fd, char *buf, \
>+				    l_size_t nbyte, l_loff_t offset); }
>+19	AUE_READV	NOPROTO { int readv(int fd, struct iovec *iovp, \
>+				    u_int iovcnt); }
>+20	AUE_WRITEV	NOPROTO	{ int writev(int fd, struct iovec *iovp, \
>+				    u_int iovcnt); }
>+21	AUE_ACCESS	STD	{ int linux_access(char *path, l_int amode); }
>+22	AUE_PIPE	STD	{ int linux_pipe(l_ulong *pipefds); }
>+23	AUE_SELECT	STD	{ int linux_select(l_int nfds, \
>+				    l_fd_set *readfds, l_fd_set *writefds, \
>+				    l_fd_set *exceptfds, \
>+				    struct l_timeval *timeout); }
>+24	AUE_NULL	NOPROTO	{ int sched_yield(void); }
>+25	AUE_NULL	STD	{ int linux_mremap(l_ulong addr, \
>+				    l_ulong old_len, l_ulong new_len, \
>+				    l_ulong flags, l_ulong new_addr); }
>+26	AUE_MSYNC	STD	{ int linux_msync(l_ulong addr, \
>+				    l_size_t len, l_int fl); }
>+27	AUE_MINCORE	STD	{ int linux_mincore(l_ulong start, \
>+				    l_size_t len, u_char *vec); }
>+28	AUE_MADVISE	NOPROTO	{ int madvise(void *addr, size_t len, \
>+				    int behav); }
>+29	AUE_NULL	STD	{ int linux_shmget(l_key_t key, l_size_t size, \
>+				    l_int shmflg); }
>+30	AUE_NULL	STD	{ int linux_shmat(l_int shmid, char *shmaddr, \
>+				    l_int shmflg); }
>+31	AUE_NULL	STD	{ int linux_shmctl(l_int shmid, l_int cmd, \
>+				    struct l_shmid_ds *buf); }
>+32	AUE_DUP		NOPROTO	{ int dup(u_int fd); }
>+33	AUE_DUP2	NOPROTO	{ int dup2(u_int from, u_int to); }
>+34	AUE_NULL	STD	{ int linux_pause(void); }
>+35	AUE_NULL	STD	{ int linux_nanosleep( \
>+				    const struct l_timespec *rqtp, \
>+				    struct l_timespec *rmtp); }
>+36	AUE_GETITIMER	STD	{ int linux_getitimer(l_int which, \
>+				    struct l_itimerval *itv); }
>+37	AUE_NULL	STD	{ int linux_alarm(l_uint secs); }
>+38	AUE_SETITIMER	STD	{ int linux_setitimer(l_int which, \
>+				    struct l_itimerval *itv, \
>+				    struct l_itimerval *oitv); }
>+39	AUE_GETPID	STD	{ int linux_getpid(void); }
>+40	AUE_SENDFILE	STD	{ int linux_sendfile(int out, int in, \
>+				    l_long *offset, l_size_t count); }
>+41	AUE_SOCKET	STD	{ int linux_socket(l_int domain, l_int type, \
>+				    l_int protocol); }
>+42	AUE_CONNECT	STD	{ int linux_connect(l_int s, l_uintptr_t name, \
>+				    l_int namelen); }
>+43	AUE_ACCEPT	STD	{ int linux_accept(l_int s, l_uintptr_t addr, \
>+				    l_uintptr_t namelen); }
>+44	AUE_SENDTO	STD	{ int linux_sendto(l_int s, l_uintptr_t msg, \
>+				    l_int len, l_int flags, l_uintptr_t to, \
>+				    l_int tolen); }
>+45	AUE_RECVFROM	STD	{ int linux_recvfrom(l_int s, l_uintptr_t buf, \
>+				    l_size_t len, l_int flags, l_uintptr_t from, \
>+				    l_uintptr_t fromlen); }
>+46	AUE_SENDMSG	STD	{ int linux_sendmsg(l_int s, l_uintptr_t msg, \
>+				    l_int flags); }
>+47	AUE_RECVMSG	STD	{ int linux_recvmsg(l_int s, l_uintptr_t msg, \
>+				    l_int flags); }
>+48	AUE_NULL	STD	{ int linux_shutdown(l_int s, l_int how); }
>+49	AUE_BIND	STD	{ int linux_bind(l_int s, l_uintptr_t name, \
>+				    l_int namelen); }
>+50	AUE_LISTEN	STD	{ int linux_listen(l_int s, l_int backlog); }
>+51	AUE_GETSOCKNAME	STD	{ int linux_getsockname(l_int s, \
>+				    l_uintptr_t addr, l_uintptr_t namelen); }
>+52	AUE_GETPEERNAME	STD	{ int linux_getpeername(l_int s, \
>+				    l_uintptr_t addr, l_uintptr_t namelen); }
>+53	AUE_SOCKETPAIR	STD	{ int linux_socketpair(l_int domain, \
>+				    l_int type, l_int protocol, l_uintptr_t rsv); }
>+54	AUE_SETSOCKOPT	STD	{ int linux_setsockopt(l_int s, l_int level, \
>+				    l_int optname, l_uintptr_t optval, \
>+				    l_int optlen); }
>+55	AUE_GETSOCKOPT	STD	{ int linux_getsockopt(l_int s, l_int level, \
>+				    l_int optname, l_uintptr_t optval, \
>+				    l_uintptr_t optlen); }
>+56	AUE_RFORK	STD	{ int linux_clone(l_int flags, void *stack, \
>+				    void *parent_tidptr, void * child_tidptr, void *tls ); }
>+57	AUE_FORK	STD	{ int linux_fork(void); }
>+58	AUE_VFORK	STD	{ int linux_vfork(void); }
>+59	AUE_EXECVE	STD	{ int linux_execve(char *path, char **argp, \
>+				    char **envp); }
>+60	AUE_EXIT	STD	{ void linux_exit(int rval); }
>+61	AUE_WAIT4	STD	{ int linux_wait4(l_pid_t pid, \
>+				    l_int *status, l_int options, \
>+				    struct l_rusage *rusage); }
>+62	AUE_KILL	STD	{ int linux_kill(l_int pid, l_int signum); }
>+63	AUE_NULL	STD	{ int linux_newuname( \
>+				    struct l_new_utsname *buf); }
>+64	AUE_NULL	STD	{ int linux_semget(l_key_t key, \
>+				    l_int nsems, l_int semflg); }
>+65	AUE_NULL	STD	{ int linux_semop(l_int semid, \
>+				    struct l_sembuf *tsops, l_uint nsops); }
>+66	AUE_NULL	STD	{ int linux_semctl(l_int semid, \
>+				    l_int semnum, l_int cmd, union l_semun arg); }
>+67	AUE_NULL	STD	{ int linux_shmdt(char *shmaddr); }
>+68	AUE_NULL	STD	{ int linux_msgget(l_key_t key, l_int msgflg); }
>+69	AUE_NULL	STD	{ int linux_msgsnd(l_int msqid, \
>+				    struct l_msgbuf *msgp, l_size_t msgsz, \
>+				    l_int msgflg); }
>+70	AUE_NULL	STD	{ int linux_msgrcv(l_int msqid, \
>+				    struct l_msgbuf *msgp, l_size_t msgsz, \
>+				    l_long msgtyp, l_int msgflg); }
>+71	AUE_NULL	STD	{ int linux_msgctl(l_int msqid, l_int cmd, \
>+				    struct l_msqid_ds *buf); }
>+72	AUE_FCNTL	STD	{ int linux_fcntl(l_uint fd, l_uint cmd, \
>+				    l_ulong arg); }
>+73	AUE_FLOCK	NOPROTO	{ int flock(int fd, int how); }
>+74	AUE_FSYNC	NOPROTO	{ int fsync(int fd); }
>+75	AUE_NULL	STD	{ int linux_fdatasync(l_uint fd); }
>+76	AUE_TRUNCATE	STD	{ int linux_truncate(char *path, \
>+				    l_ulong length); }
>+77	AUE_FTRUNCATE	STD	{ int linux_ftruncate(l_int fd, l_long length); }
>+78	AUE_GETDIRENTRIES	STD { int linux_getdents(l_uint fd, void *dent, \
>+				    l_uint count); }
>+79	AUE_GETCWD	STD	{ int linux_getcwd(char *buf, \
>+				    l_ulong bufsize); }
>+80	AUE_CHDIR	STD	{ int linux_chdir(char *path); }
>+81	AUE_FCHDIR	NOPROTO	{ int fchdir(int fd); }
>+82	AUE_RENAME	STD	{ int linux_rename(char *from, char *to); }
>+83	AUE_MKDIR	STD	{ int linux_mkdir(char *path, l_int mode); }
>+84	AUE_RMDIR	STD	{ int linux_rmdir(char *path); }
>+85	AUE_CREAT	STD	{ int linux_creat(char *path, \
>+				    l_int mode); }
>+86	AUE_LINK	STD	{ int linux_link(char *path, char *to); }
>+87	AUE_UNLINK	STD	{ int linux_unlink(char *path); }
>+88	AUE_SYMLINK	STD	{ int linux_symlink(char *path, char *to); }
>+89	AUE_READLINK	STD	{ int linux_readlink(char *name, char *buf, \
>+				    l_int count); }
>+90	AUE_CHMOD	STD	{ int linux_chmod(char *path, \
>+				    l_mode_t mode); }
>+91	AUE_FCHMOD	NOPROTO	{ int fchmod(int fd, int mode); }
>+92	AUE_LCHOWN	STD	{ int linux_chown(char *path, \
>+				    l_uid_t uid, l_gid_t gid); }
>+93	AUE_FCHOWN	NOPROTO	{ int fchown(int fd, int uid, int gid); }
>+94	AUE_LCHOWN	STD	{ int linux_lchown(char *path, l_uid_t uid, \
>+				    l_gid_t gid); }
>+95	AUE_UMASK	NOPROTO	{ int umask(int newmask); }
>+96	AUE_NULL	NOPROTO	{ int gettimeofday(struct l_timeval *tp, \
>+				    struct timezone *tzp); }
>+97	AUE_GETRLIMIT	STD	{ int linux_getrlimit(l_uint resource, \
>+				    struct l_rlimit *rlim); }
>+98	AUE_GETRUSAGE	NOPROTO	{ int getrusage(int who, struct rusage *rusage); }
>+99	AUE_NULL	STD	{ int linux_sysinfo(struct l_sysinfo *info); }
>+100	AUE_NULL	STD	{ int linux_times(struct l_times_argv *buf); }
>+101	AUE_PTRACE	STD	{ int linux_ptrace(l_long req, l_long pid, \
>+				    l_long addr, l_long data); }
>+102	AUE_GETUID	STD	{ int linux_getuid(void); }
>+103	AUE_NULL	STD	{ int linux_syslog(l_int type, char *buf, \
>+				    l_int len); }
>+104	AUE_GETGID	STD	{ int linux_getgid(void); }
>+105	AUE_SETUID	NOPROTO	{ int setuid(uid_t uid); }
>+106	AUE_SETGID	NOPROTO	{ int setgid(gid_t gid); }
>+107	AUE_GETEUID	NOPROTO	{ int geteuid(void); }
>+108	AUE_GETEGID	NOPROTO	{ int getegid(void); }
>+109	AUE_SETPGRP	NOPROTO	{ int setpgid(int pid, int pgid); }
>+110	AUE_GETPPID	STD	{ int linux_getppid(void); }
>+111	AUE_GETPGRP	NOPROTO	{ int getpgrp(void); }
>+112	AUE_SETSID	NOPROTO	{ int setsid(void); }
>+113	AUE_SETREUID	NOPROTO	{ int setreuid(uid_t ruid, uid_t euid); }
>+114	AUE_SETREGID	NOPROTO	{ int setregid(gid_t rgid, gid_t egid); }
>+115	AUE_GETGROUPS	STD	{ int linux_getgroups(l_int gidsetsize, \
>+				    l_gid_t *grouplist); }
>+116	AUE_SETGROUPS	STD	{ int linux_setgroups(l_int gidsetsize, \
>+				    l_gid_t *grouplist); }
>+117	AUE_SETRESUID	NOPROTO	{ int setresuid(uid_t ruid, uid_t euid, \
>+				    uid_t suid); }
>+118	AUE_GETRESUID	NOPROTO	{ int getresuid(uid_t *ruid, uid_t *euid, \
>+				    uid_t *suid); }
>+119	AUE_SETRESGID	NOPROTO	{ int setresgid(gid_t rgid, gid_t egid, \
>+				    gid_t sgid); }
>+120	AUE_GETRESGID	NOPROTO	{ int getresgid(gid_t *rgid, gid_t *egid, \
>+				    gid_t *sgid); }
>+121	AUE_GETPGID	NOPROTO	{ int getpgid(int pid); }
>+122	AUE_SETFSUID	STD	{ int linux_setfsuid(l_uid_t uid); }
>+123	AUE_SETFSGID	STD	{ int linux_setfsgid(l_gid_t gid); }
>+124	AUE_GETSID	STD	{ int linux_getsid(l_pid_t pid); }
>+125	AUE_CAPGET	STD	{ int linux_capget(struct l_user_cap_header *hdrp, \
>+				    struct l_user_cap_data *datap); }
>+126	AUE_CAPSET	STD	{ int linux_capset(struct l_user_cap_header *hdrp, \
>+				    struct l_user_cap_data *datap); }
>+127	AUE_NULL	STD	{ int linux_rt_sigpending(l_sigset_t *set, \
>+				    l_size_t sigsetsize); }
>+128	AUE_NULL	STD	{ int linux_rt_sigtimedwait(l_sigset_t *mask, \
>+				    l_siginfo_t *ptr, \
>+				    struct l_timeval *timeout, \
>+				    l_size_t sigsetsize); }
>+129	AUE_NULL	STD	{ int linux_rt_sigqueueinfo(l_pid_t pid, l_int sig, \
>+				    l_siginfo_t *info); }
>+130	AUE_NULL	STD	{ int linux_rt_sigsuspend( \
>+				    l_sigset_t *newset, \
>+				    l_size_t sigsetsize); }
>+131	AUE_NULL	STD	{ int linux_sigaltstack(l_stack_t *uss, \
>+				    l_stack_t *uoss); }
>+132	AUE_UTIME	STD	{ int linux_utime(char *fname, \
>+				    struct l_utimbuf *times); }
>+133	AUE_MKNOD	STD	{ int linux_mknod(char *path, l_int mode, \
>+				    l_dev_t dev); }
>+134	AUE_USELIB	UNIMPL	uselib
>+135	AUE_PERSONALITY	STD	{ int linux_personality(l_ulong per); }
>+136	AUE_NULL	STD	{ int linux_ustat(l_dev_t dev, \
>+				    struct l_ustat *ubuf); }
>+137	AUE_STATFS	STD	{ int linux_statfs(char *path, \
>+				    struct l_statfs_buf *buf); }
>+138	AUE_FSTATFS	STD	{ int linux_fstatfs(l_uint fd, \
>+				    struct l_statfs_buf *buf); }
>+139	AUE_NULL	STD	{ int linux_sysfs(l_int option, \
>+				    l_ulong arg1, l_ulong arg2); }
>+140	AUE_GETPRIORITY	STD	{ int linux_getpriority(int which, int who); }
>+141	AUE_SETPRIORITY	NOPROTO	{ int setpriority(int which, int who, \
>+				    int prio); }
>+142	AUE_SCHED_SETPARAM	STD	{ int linux_sched_setparam(l_pid_t pid, \
>+				    struct l_sched_param *param); }
>+143	AUE_SCHED_GETPARAM	STD	{ int linux_sched_getparam(l_pid_t pid, \
>+				    struct l_sched_param *param); }
>+144	AUE_SCHED_SETSCHEDULER	STD { int linux_sched_setscheduler( \
>+				    l_pid_t pid, l_int policy, \
>+				    struct l_sched_param *param); }
>+145	AUE_SCHED_GETSCHEDULER	STD { int linux_sched_getscheduler( \
>+				    l_pid_t pid); }
>+146	AUE_SCHED_GET_PRIORITY_MAX	STD { int linux_sched_get_priority_max( \
>+				    l_int policy); }
>+147	AUE_SCHED_GET_PRIORITY_MIN	STD { int linux_sched_get_priority_min( \
>+				    l_int policy); }
>+148	AUE_SCHED_RR_GET_INTERVAL	STD { int linux_sched_rr_get_interval(l_pid_t pid, \
>+				    struct l_timespec *interval); }
>+149	AUE_MLOCK	NOPROTO	{ int mlock(const void *addr, size_t len); }
>+150	AUE_MUNLOCK	NOPROTO	{ int munlock(const void *addr, size_t len); }
>+151	AUE_MLOCKALL	NOPROTO	{ int mlockall(int how); }
>+152	AUE_MUNLOCKALL	NOPROTO	{ int munlockall(void); }
>+153	AUE_NULL	STD	{ int linux_vhangup(void); }
>+154	AUE_NULL	UNIMPL	modify_ldt
>+155	AUE_PIVOT_ROOT	STD	{ int linux_pivot_root(void); }
>+156	AUE_SYSCTL	STD	{ int linux_sysctl( \
>+				    struct l___sysctl_args *args); }
>+157	AUE_PRCTL	STD	{ int linux_prctl(l_int option, l_uintptr_t arg2, \
>+				    l_uintptr_t arg3, l_uintptr_t arg4, \
>+				    l_uintptr_t arg5); }
>+158	AUE_PRCTL	STD	{ int linux_arch_prctl(l_int code, l_ulong addr); }
>+159	AUE_ADJTIME	STD	{ int linux_adjtimex(void); }
>+160	AUE_SETRLIMIT	STD	{ int linux_setrlimit(l_uint resource, \
>+				    struct l_rlimit *rlim); }
>+161	AUE_CHROOT	NOPROTO	{ int chroot(char *path); }
>+162	AUE_SYNC	NOPROTO	{ int sync(void); }
>+163	AUE_ACCT	NOPROTO	{ int acct(char *path); }
>+164	AUE_SETTIMEOFDAY	NOPROTO	{ int settimeofday(struct l_timeval *tp, struct timezone *tzp); }
>+165	AUE_MOUNT	STD	{ int linux_mount(char *specialfile, \
>+				    char *dir, char *filesystemtype, \
>+				    l_ulong rwflag, void *data); }
>+166	AUE_UMOUNT	STD	{ int linux_umount(char *path, l_int flags); }
>+167	AUE_SWAPON	NOPROTO	{ int swapon(char *name); }
>+168	AUE_SWAPOFF	STD	{ int linux_swapoff(void); }
>+169	AUE_REBOOT	STD	{ int linux_reboot(l_int magic1, \
>+				    l_int magic2, l_uint cmd, void *arg); }
>+170	AUE_SYSCTL	STD	{ int linux_sethostname(char *hostname, \
>+				    l_uint len); }
>+171	AUE_SYSCTL	STD	{ int linux_setdomainname(char *name, \
>+				    l_int len); }
>+172	AUE_NULL	STD	{ int linux_iopl(l_uint level); }
>+173	AUE_NULL	UNIMPL	ioperm
>+174	AUE_NULL	STD	{ int linux_create_module(void); }
>+175	AUE_NULL	STD	{ int linux_init_module(void); }
>+176	AUE_NULL	STD	{ int linux_delete_module(void); }
>+177	AUE_NULL	STD	{ int linux_get_kernel_syms(void); }
>+178	AUE_NULL	STD	{ int linux_query_module(void); }
>+179	AUE_QUOTACTL	STD	{ int linux_quotactl(void); }
>+180	AUE_NULL	STD	{ int linux_nfsservctl(void); }
>+181	AUE_GETPMSG	STD	{ int linux_getpmsg(void); }
>+182	AUE_PUTPMSG	STD	{ int linux_putpmsg(void); }
>+183	AUE_NULL	STD	{ int linux_afs_syscall(void); }
>+184	AUE_NULL	STD	{ int linux_tuxcall(void); }
>+185	AUE_NULL	STD	{ int linux_security(void); }
>+186	AUE_NULL	STD	{ int linux_gettid(void); }
>+187	AUE_NULL	UNIMPL	linux_readahead
>+188	AUE_NULL	STD	{ int linux_setxattr(void); }
>+189	AUE_NULL	STD	{ int linux_lsetxattr(void); }
>+190	AUE_NULL	STD	{ int linux_fsetxattr(void); }
>+191	AUE_NULL	STD	{ int linux_getxattr(void); }
>+192	AUE_NULL	STD	{ int linux_lgetxattr(void); }
>+193	AUE_NULL	STD	{ int linux_fgetxattr(void); }
>+194	AUE_NULL	STD	{ int linux_listxattr(void); }
>+195	AUE_NULL	STD	{ int linux_llistxattr(void); }
>+196	AUE_NULL	STD	{ int linux_flistxattr(void); }
>+197	AUE_NULL	STD	{ int linux_removexattr(void); }
>+198	AUE_NULL	STD	{ int linux_lremovexattr(void); }
>+199	AUE_NULL	STD	{ int linux_fremovexattr(void); }
>+200	AUE_NULL	STD	{ int linux_tkill(int tid, int sig); }
>+201	AUE_NULL	STD	{ int linux_time(l_time_t *tm); }
>+202	AUE_NULL	STD	{ int linux_sys_futex(void *uaddr, int op, int val, \
>+				    struct l_timespec *timeout, void *uaddr2, int val3); }
>+203	AUE_NULL	STD	{ int linux_sched_setaffinity(l_pid_t pid, l_uint len, \
>+				    l_ulong *user_mask_ptr); }
>+204	AUE_NULL	STD	{ int linux_sched_getaffinity(l_pid_t pid, l_uint len, \
>+				    l_ulong *user_mask_ptr); }
>+205	AUE_NULL	STD	{ int linux_set_thread_area(void); }
>+206	AUE_NULL	UNIMPL	linux_io_setup
>+207	AUE_NULL	UNIMPL	linux_io_destroy
>+208	AUE_NULL	UNIMPL	linux_io_getevents
>+209	AUE_NULL	UNIMPL	inux_io_submit
>+210	AUE_NULL	UNIMPL	linux_io_cancel
>+211	AUE_NULL	UNIMPL	linux_get_thread_area
>+212	AUE_NULL	STD	{ int linux_lookup_dcookie(void); }
>+213	AUE_NULL	STD	{ int linux_epoll_create(l_int size); }
>+214	AUE_NULL	STD	{ int linux_epoll_ctl_old(void); }
>+215	AUE_NULL	STD	{ int linux_epoll_wait_old(void); }
>+216	AUE_NULL	STD	{ int linux_remap_file_pages(void); }
>+217	AUE_GETDIRENTRIES	STD { int linux_getdents64(l_uint fd, \
>+				    void *dirent, l_uint count); }
>+218	AUE_NULL	STD	{ int linux_set_tid_address(int *tidptr); }
>+219	AUE_NULL	UNIMPL	restart_syscall
>+220	AUE_NULL	STD	{ int linux_semtimedop(void); }
>+221	AUE_NULL	STD	{ int linux_fadvise64(int fd, l_loff_t offset, \
>+				    l_size_t len, int advice); }
>+222	AUE_NULL	STD	{ int linux_timer_create(clockid_t clock_id, \
>+				    struct sigevent *evp, l_timer_t *timerid); }
>+223	AUE_NULL	STD	{ int linux_timer_settime(l_timer_t timerid, l_int flags, \
>+				    const struct itimerspec *new, struct itimerspec *old); }
>+224	AUE_NULL	STD	{ int linux_timer_gettime(l_timer_t timerid, struct itimerspec *setting); }
>+225	AUE_NULL	STD	{ int linux_timer_getoverrun(l_timer_t timerid); }
>+226	AUE_NULL	STD	{ int linux_timer_delete(l_timer_t timerid); }
>+227	AUE_CLOCK_SETTIME	STD	{ int linux_clock_settime(clockid_t which, struct l_timespec *tp); }
>+228	AUE_NULL	STD	{ int linux_clock_gettime(clockid_t which, struct l_timespec *tp); }
>+229	AUE_NULL	STD	{ int linux_clock_getres(clockid_t which, struct l_timespec *tp); }
>+230	AUE_NULL	STD	{ int linux_clock_nanosleep(clockid_t which, int flags, \
>+				    struct l_timespec *rqtp, struct l_timespec *rmtp); }
>+231	AUE_EXIT	STD	{ int linux_exit_group(int error_code); }
>+232	AUE_NULL	STD	{ int linux_epoll_wait(l_int epfd, struct epoll_event *events, \
>+					l_int maxevents, l_int timeout); }
>+233	AUE_NULL	STD	{ int linux_epoll_ctl(l_int epfd, l_int op, l_int fd, \
>+					struct epoll_event *event); }
>+234	AUE_NULL	STD	{ int linux_tgkill(int tgid, int pid, int sig); }
>+235	AUE_UTIMES	STD	{ int linux_utimes(char *fname, \
>+				    struct l_timeval *tptr); }
>+236	AUE_NULL	UNIMPL	vserver
>+237	AUE_NULL	STD	{ int linux_mbind(void); }
>+238	AUE_NULL	STD	{ int linux_set_mempolicy(void); }
>+239	AUE_NULL	STD	{ int linux_get_mempolicy(void); }
>+240	AUE_NULL	STD	{ int linux_mq_open(void); }
>+241	AUE_NULL	STD	{ int linux_mq_unlink(void); }
>+242	AUE_NULL	STD	{ int linux_mq_timedsend(void); }
>+243	AUE_NULL	STD	{ int linux_mq_timedreceive(void); }
>+244	AUE_NULL	STD	{ int linux_mq_notify(void); }
>+245	AUE_NULL	STD	{ int linux_mq_getsetattr(void); }
>+246	AUE_NULL	STD	{ int linux_kexec_load(void); }
>+247	AUE_WAIT6	STD	{ int linux_waitid(int idtype, l_pid_t id, l_siginfo_t *info, \
>+				    int options, struct l_rusage *rusage); }
>+248	AUE_NULL	STD	{ int linux_add_key(void); }
>+249	AUE_NULL	STD	{ int linux_request_key(void); }
>+250	AUE_NULL	STD	{ int linux_keyctl(void); }
>+251	AUE_NULL	STD	{ int linux_ioprio_set(void); }
>+252	AUE_NULL	STD	{ int linux_ioprio_get(void); }
>+253	AUE_NULL	STD	{ int linux_inotify_init(void); }
>+254	AUE_NULL	STD	{ int linux_inotify_add_watch(void); }
>+255	AUE_NULL	STD	{ int linux_inotify_rm_watch(void); }
>+256	AUE_NULL	STD	{ int linux_migrate_pages(void); }
>+257	AUE_OPEN_RWTC	STD	{ int linux_openat(l_int dfd, const char *filename, \
>+				    l_int flags, l_int mode); }
>+258	AUE_MKDIRAT	STD	{ int linux_mkdirat(l_int dfd, const char *pathname, \
>+				    l_int mode); }
>+259	AUE_MKNODAT	STD	{ int linux_mknodat(l_int dfd, const char *filename, \
>+				    l_int mode, l_uint dev); }
>+260	AUE_FCHOWNAT	STD	{ int linux_fchownat(l_int dfd, const char *filename, \
>+				    l_uid_t uid, l_gid_t gid, l_int flag); }
>+261	AUE_FUTIMESAT	STD	{ int linux_futimesat(l_int dfd, char *filename, \
>+				    struct l_timeval *utimes); }
>+262	AUE_FSTATAT	STD	{ int linux_newfstatat(l_int dfd, char *pathname, \
>+				    struct l_stat64 *statbuf, l_int flag); }
>+263	AUE_UNLINKAT	STD	{ int linux_unlinkat(l_int dfd, const char *pathname, \
>+				    l_int flag); }
>+264	AUE_RENAMEAT	STD	{ int linux_renameat(l_int olddfd, const char *oldname, \
>+				    l_int newdfd, const char *newname); }
>+265	AUE_LINKAT	STD	{ int linux_linkat(l_int olddfd, const char *oldname, \
>+				    l_int newdfd, const char *newname, l_int flag); }
>+266	AUE_SYMLINKAT	STD	{ int linux_symlinkat(const char *oldname, l_int newdfd, \
>+				    const char *newname); }
>+267	AUE_READLINKAT	STD	{ int linux_readlinkat(l_int dfd, const char *path, \
>+				    char *buf, l_int bufsiz); }
>+268	AUE_FCHMODAT	STD	{ int linux_fchmodat(l_int dfd, const char *filename, \
>+				    l_mode_t mode); }
>+269	AUE_FACCESSAT	STD	{ int linux_faccessat(l_int dfd, const char *filename, \
>+				    l_int amode); }
>+270	AUE_SELECT	STD	{ int linux_pselect6(l_int nfds,			\
>+				    l_fd_set *readfds, l_fd_set *writefds, l_fd_set *exceptfds,	\
>+				    struct l_timespec *tsp, l_uintptr_t *sig); }
>+271	AUE_POLL	STD	{ int linux_ppoll(struct pollfd *fds, uint32_t nfds,	\
>+				    struct l_timespec *tsp, l_sigset_t *sset, l_size_t ssize); }
>+272	AUE_NULL	STD	{ int linux_unshare(void); }
>+273	AUE_NULL	STD	{ int linux_set_robust_list(struct linux_robust_list_head *head, \
>+				    l_size_t len); }
>+274	AUE_NULL	STD	{ int linux_get_robust_list(l_int pid, struct linux_robust_list_head *head, \
>+				    l_size_t *len); }
>+275	AUE_NULL	STD	{ int linux_splice(void); }
>+276	AUE_NULL	STD	{ int linux_tee(void); }
>+277	AUE_NULL	STD	{ int linux_sync_file_range(void); }
>+278	AUE_NULL	STD	{ int linux_vmsplice(void); }
>+279	AUE_NULL	STD	{ int linux_move_pages(void); }
>+280	AUE_FUTIMESAT	STD	{ int linux_utimensat(l_int dfd, const char *pathname, \
>+					const struct l_timespec *times, l_int flags); }
>+281     AUE_NULL        STD     { int linux_epoll_pwait(l_int epfd, struct epoll_event *events, \
>+                                        l_int maxevents, l_int timeout, l_sigset_t *mask); }
>+282	AUE_NULL	STD	{ int linux_signalfd(void); }
>+283	AUE_NULL	STD	{ int linux_timerfd(void); }
>+284	AUE_NULL	STD	{ int linux_eventfd(l_uint initval); }
>+285	AUE_NULL	STD	{ int linux_fallocate(l_int fd, l_int mode, \
>+				    l_loff_t offset, l_loff_t len); }
>+286	AUE_NULL	STD	{ int linux_timerfd_settime(void); }
>+287	AUE_NULL	STD	{ int linux_timerfd_gettime(void); }
>+288	AUE_ACCEPT	STD	{ int linux_accept4(l_int s, l_uintptr_t addr, \
>+				    l_uintptr_t namelen, int flags); }
>+289	AUE_NULL	STD	{ int linux_signalfd4(void); }
>+290	AUE_NULL	STD	{ int linux_eventfd2(l_uint initval, l_int flags); }
>+291	AUE_NULL	STD	{ int linux_epoll_create1(l_int flags); }
>+292	AUE_NULL	STD	{ int linux_dup3(l_int oldfd,		\
>+				    l_int newfd, l_int flags); }
>+293	AUE_NULL	STD	{ int linux_pipe2(l_int *pipefds, l_int flags); }
>+294	AUE_NULL	STD	{ int linux_inotify_init1(void); }
>+295	AUE_NULL	STD	{ int linux_preadv(void); }
>+296	AUE_NULL	STD	{ int linux_pwritev(void); }
>+297	AUE_NULL	STD	{ int linux_rt_tsigqueueinfo(void); }
>+298	AUE_NULL	STD	{ int linux_perf_event_open(void); }
>+299	AUE_NULL	STD	{ int linux_recvmmsg(l_int s,			\
>+				    struct l_mmsghdr *msg, l_uint vlen,		\
>+				    l_uint flags, struct l_timespec *timeout); }
>+300	AUE_NULL	STD	{ int linux_fanotify_init(void); }
>+301	AUE_NULL	STD	{ int linux_fanotify_mark(void); }
>+302	AUE_NULL	STD	{ int linux_prlimit64(l_pid_t pid,	\
>+				    l_uint resource, struct rlimit *new,\
>+				    struct rlimit *old); }
>+303	AUE_NULL	STD	{ int linux_name_to_handle_at(void); }
>+304	AUE_NULL	STD	{ int linux_open_by_handle_at(void); }
>+305	AUE_NULL	STD	{ int linux_clock_adjtime(void); }
>+306	AUE_SYNC	STD	{ int linux_syncfs(l_int fd); }
>+307	AUE_NULL	STD	{ int linux_sendmmsg(l_int s,			\
>+				    struct l_mmsghdr *msg, l_uint vlen,		\
>+				    l_uint flags); }
>+308	AUE_NULL	STD	{ int linux_setns(void); }
>+309	AUE_NULL	STD	{ int linux_process_vm_readv(void); }
>+310	AUE_NULL	STD	{ int linux_process_vm_writev(void); }
>+311	AUE_NULL	STD	{ int linux_kcmp(void); }
>+312	AUE_NULL	STD	{ int linux_finit_module(void); }
>+; please, keep this line at the end.
>+313	AUE_NULL	UNIMPL	nosys
>Index: sys/amd64/linux32/linux.h
>===================================================================
>--- sys/amd64/linux32/linux.h	(revision 285633)
>+++ sys/amd64/linux32/linux.h	(working copy)
>@@ -33,6 +33,7 @@
> #ifndef _AMD64_LINUX_H_
> #define	_AMD64_LINUX_H_
> 
>+#include <compat/linux/linux.h>
> #include <amd64/linux32/linux32_syscall.h>
> 
> /*
>@@ -40,14 +41,12 @@
>  */
> extern u_char linux_debug_map[];
> #define	ldebug(name)	isclr(linux_debug_map, LINUX_SYS_linux_ ## name)
>-#define	ARGS(nm, fmt)	"linux(%ld): "#nm"("fmt")\n", (long)td->td_proc->p_pid
>-#define	LMSG(fmt)	"linux(%ld): "fmt"\n", (long)td->td_proc->p_pid
>+#define	ARGS(nm, fmt)	"linux(%ld/%ld): "#nm"("fmt")\n",			\
>+			(long)td->td_proc->p_pid, (long)td->td_tid
>+#define	LMSG(fmt)	"linux(%ld/%ld): "fmt"\n",				\
>+			(long)td->td_proc->p_pid, (long)td->td_tid
> #define	LINUX_DTRACE	linuxulator32
> 
>-#ifdef MALLOC_DECLARE
>-MALLOC_DECLARE(M_LINUX);
>-#endif
>-
> #define	LINUX32_MAXUSER		((1ul << 32) - PAGE_SIZE)
> #define	LINUX32_SHAREDPAGE	(LINUX32_MAXUSER - PAGE_SIZE)
> #define	LINUX32_USRSTACK	LINUX32_SHAREDPAGE
>@@ -97,6 +96,7 @@
> typedef l_ushort	l_uid16_t;
> typedef l_int		l_timer_t;
> typedef l_int		l_mqd_t;
>+typedef	l_ulong		l_fd_mask;
> 
> typedef struct {
> 	l_int		val[2];
>@@ -112,7 +112,7 @@
> /*
>  * Miscellaneous
>  */
>-#define	LINUX_AT_COUNT		16	/* Count of used aux entry types.
>+#define	LINUX_AT_COUNT		20	/* Count of used aux entry types.
> 					 * Keep this synchronized with
> 					 * elf_linux_fixup() code.
> 					 */
>@@ -260,49 +260,6 @@
>         l_int           f_spare[6];
> } __packed;
> 
>-/*
>- * Signalling
>- */
>-#define	LINUX_SIGHUP		1
>-#define	LINUX_SIGINT		2
>-#define	LINUX_SIGQUIT		3
>-#define	LINUX_SIGILL		4
>-#define	LINUX_SIGTRAP		5
>-#define	LINUX_SIGABRT		6
>-#define	LINUX_SIGIOT		LINUX_SIGABRT
>-#define	LINUX_SIGBUS		7
>-#define	LINUX_SIGFPE		8
>-#define	LINUX_SIGKILL		9
>-#define	LINUX_SIGUSR1		10
>-#define	LINUX_SIGSEGV		11
>-#define	LINUX_SIGUSR2		12
>-#define	LINUX_SIGPIPE		13
>-#define	LINUX_SIGALRM		14
>-#define	LINUX_SIGTERM		15
>-#define	LINUX_SIGSTKFLT		16
>-#define	LINUX_SIGCHLD		17
>-#define	LINUX_SIGCONT		18
>-#define	LINUX_SIGSTOP		19
>-#define	LINUX_SIGTSTP		20
>-#define	LINUX_SIGTTIN		21
>-#define	LINUX_SIGTTOU		22
>-#define	LINUX_SIGURG		23
>-#define	LINUX_SIGXCPU		24
>-#define	LINUX_SIGXFSZ		25
>-#define	LINUX_SIGVTALRM		26
>-#define	LINUX_SIGPROF		27
>-#define	LINUX_SIGWINCH		28
>-#define	LINUX_SIGIO		29
>-#define	LINUX_SIGPOLL		LINUX_SIGIO
>-#define	LINUX_SIGPWR		30
>-#define	LINUX_SIGSYS		31
>-#define	LINUX_SIGRTMIN		32
>-
>-#define	LINUX_SIGTBLSZ		31
>-#define	LINUX_NSIG_WORDS	2
>-#define	LINUX_NBPW		32
>-#define	LINUX_NSIG		(LINUX_NBPW * LINUX_NSIG_WORDS)
>-
> /* sigaction flags */
> #define	LINUX_SA_NOCLDSTOP	0x00000001
> #define	LINUX_SA_NOCLDWAIT	0x00000002
>@@ -319,27 +276,13 @@
> #define	LINUX_SIG_UNBLOCK	1
> #define	LINUX_SIG_SETMASK	2
> 
>-/* sigset_t macros */
>-#define	LINUX_SIGEMPTYSET(set)		(set).__bits[0] = (set).__bits[1] = 0
>-#define	LINUX_SIGISMEMBER(set, sig)	SIGISMEMBER(set, sig)
>-#define	LINUX_SIGADDSET(set, sig)	SIGADDSET(set, sig)
>-
> /* sigaltstack */
> #define	LINUX_MINSIGSTKSZ	2048
>-#define	LINUX_SS_ONSTACK	1
>-#define	LINUX_SS_DISABLE	2
> 
>-int linux_to_bsd_sigaltstack(int lsa);
>-int bsd_to_linux_sigaltstack(int bsa);
>-
> typedef l_uintptr_t l_handler_t;
> typedef l_ulong	l_osigset_t;
> 
> typedef struct {
>-	l_uint	__bits[LINUX_NSIG_WORDS];
>-} __packed l_sigset_t;
>-
>-typedef struct {
> 	l_handler_t	lsa_handler;
> 	l_osigset_t	lsa_mask;
> 	l_ulong		lsa_flags;
>@@ -508,7 +451,7 @@
> 	l_int			sf_sig;
> 	struct l_sigcontext	sf_sc;
> 	struct l_fpstate	sf_fpstate;
>-	l_uint			sf_extramask[LINUX_NSIG_WORDS-1];
>+	l_uint			sf_extramask[1];
> 	l_handler_t		sf_handler;
> } __packed;
> 
>@@ -521,50 +464,13 @@
> 	l_handler_t 		sf_handler;
> } __packed;
> 
>-extern struct sysentvec elf_linux_sysvec;
>-
> /*
>- * open/fcntl flags
>+ * arch specific open/fcntl flags
>  */
>-#define	LINUX_O_RDONLY		00000000
>-#define	LINUX_O_WRONLY		00000001
>-#define	LINUX_O_RDWR		00000002
>-#define	LINUX_O_ACCMODE		00000003
>-#define	LINUX_O_CREAT		00000100
>-#define	LINUX_O_EXCL		00000200
>-#define	LINUX_O_NOCTTY		00000400
>-#define	LINUX_O_TRUNC		00001000
>-#define	LINUX_O_APPEND		00002000
>-#define	LINUX_O_NONBLOCK	00004000
>-#define	LINUX_O_NDELAY		LINUX_O_NONBLOCK
>-#define	LINUX_O_SYNC		00010000
>-#define	LINUX_FASYNC		00020000
>-#define	LINUX_O_DIRECT		00040000	/* Direct disk access hint */
>-#define	LINUX_O_LARGEFILE	00100000
>-#define	LINUX_O_DIRECTORY	00200000	/* Must be a directory */
>-#define	LINUX_O_NOFOLLOW	00400000	/* Do not follow links */
>-#define	LINUX_O_NOATIME		01000000
>-#define	LINUX_O_CLOEXEC		02000000
>-
>-#define	LINUX_F_DUPFD		0
>-#define	LINUX_F_GETFD		1
>-#define	LINUX_F_SETFD		2
>-#define	LINUX_F_GETFL		3
>-#define	LINUX_F_SETFL		4
>-#define	LINUX_F_GETLK		5
>-#define	LINUX_F_SETLK		6
>-#define	LINUX_F_SETLKW		7
>-#define	LINUX_F_SETOWN		8
>-#define	LINUX_F_GETOWN		9
>-
> #define	LINUX_F_GETLK64		12
> #define	LINUX_F_SETLK64		13
> #define	LINUX_F_SETLKW64	14
> 
>-#define	LINUX_F_RDLCK		0
>-#define	LINUX_F_WRLCK		1
>-#define	LINUX_F_UNLCK		2
>-
> union l_semun {
> 	l_int		val;
> 	l_uintptr_t	buf;
>@@ -573,6 +479,16 @@
> 	l_uintptr_t	__pad;
> } __packed;
> 
>+struct l_ipc_perm {
>+	l_key_t		key;
>+	l_uid16_t	uid;
>+	l_gid16_t	gid;
>+	l_uid16_t	cuid;
>+	l_gid16_t	cgid;
>+	l_ushort	mode;
>+	l_ushort	seq;
>+};
>+
> /*
>  * Socket defines
>  */
>@@ -609,22 +525,6 @@
> 	char		sa_data[14];
> } __packed;
> 
>-struct l_msghdr {
>-	l_uintptr_t	msg_name;
>-	l_int		msg_namelen;
>-	l_uintptr_t	msg_iov;
>-	l_size_t	msg_iovlen;
>-	l_uintptr_t	msg_control;
>-	l_size_t	msg_controllen;
>-	l_uint		msg_flags;
>-};
>-
>-struct l_cmsghdr {
>-	l_size_t	cmsg_len;
>-	l_int		cmsg_level;
>-	l_int		cmsg_type;
>-};
>-
> struct l_ifmap {
> 	l_ulong		mem_start;
> 	l_ulong		mem_end;
>Index: sys/amd64/linux32/linux32_dummy.c
>===================================================================
>--- sys/amd64/linux32/linux32_dummy.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_dummy.c	(working copy)
>@@ -62,7 +62,6 @@
> DUMMY(sysfs);
> DUMMY(query_module);
> DUMMY(nfsservctl);
>-DUMMY(rt_sigqueueinfo);
> DUMMY(sendfile);
> DUMMY(setfsuid);
> DUMMY(setfsgid);
>@@ -70,9 +69,6 @@
> DUMMY(mincore);
> DUMMY(ptrace);
> DUMMY(lookup_dcookie);
>-DUMMY(epoll_create);
>-DUMMY(epoll_ctl);
>-DUMMY(epoll_wait);
> DUMMY(remap_file_pages);
> DUMMY(fstatfs64);
> DUMMY(mbind);
>@@ -85,7 +81,6 @@
> DUMMY(mq_notify);
> DUMMY(mq_getsetattr);
> DUMMY(kexec_load);
>-DUMMY(waitid);
> /* linux 2.6.11: */
> DUMMY(add_key);
> DUMMY(request_key);
>@@ -98,8 +93,6 @@
> DUMMY(inotify_rm_watch);
> /* linux 2.6.16: */
> DUMMY(migrate_pages);
>-DUMMY(pselect6);
>-DUMMY(ppoll);
> DUMMY(unshare);
> /* linux 2.6.17: */
> DUMMY(splice);
>@@ -110,22 +103,14 @@
> DUMMY(move_pages);
> /* linux 2.6.19: */
> DUMMY(getcpu);
>-DUMMY(epoll_pwait);
> /* linux 2.6.22: */
>-DUMMY(utimensat);
> DUMMY(signalfd);
> DUMMY(timerfd_create);
>-DUMMY(eventfd);
>-/* linux 2.6.23: */
>-DUMMY(fallocate);
> /* linux 2.6.25: */
> DUMMY(timerfd_settime);
> DUMMY(timerfd_gettime);
> /* linux 2.6.27: */
> DUMMY(signalfd4);
>-DUMMY(eventfd2);
>-DUMMY(epoll_create1);
>-DUMMY(dup3);
> DUMMY(inotify_init1);
> /* linux 2.6.30: */
> DUMMY(preadv);
>@@ -134,17 +119,12 @@
> DUMMY(rt_tsigqueueinfo);
> DUMMY(perf_event_open);
> /* linux 2.6.33: */
>-DUMMY(recvmmsg);
> DUMMY(fanotify_init);
> DUMMY(fanotify_mark);
>-/* linux 2.6.36: */
>-DUMMY(prlimit64);
> /* later: */
> DUMMY(name_to_handle_at);
> DUMMY(open_by_handle_at);
> DUMMY(clock_adjtime);
>-DUMMY(syncfs);
>-DUMMY(sendmmsg);
> DUMMY(setns);
> DUMMY(process_vm_readv);
> DUMMY(process_vm_writev);
>Index: sys/amd64/linux32/linux32_genassym.c
>===================================================================
>--- sys/amd64/linux32/linux32_genassym.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_genassym.c	(working copy)
>@@ -6,6 +6,7 @@
> #include <sys/systm.h>
> 
> #include <amd64/linux32/linux.h>
>+#include <compat/linux/linux_mib.h>
> 
> ASSYM(LINUX_SIGF_HANDLER, offsetof(struct l_sigframe, sf_handler));
> ASSYM(LINUX_SIGF_SC, offsetof(struct l_sigframe, sf_sc));
>@@ -12,3 +13,5 @@
> ASSYM(LINUX_RT_SIGF_HANDLER, offsetof(struct l_rt_sigframe, sf_handler));
> ASSYM(LINUX_RT_SIGF_UC, offsetof(struct l_rt_sigframe, sf_sc));
> ASSYM(LINUX_RT_SIGF_SC, offsetof(struct l_ucontext, uc_mcontext));
>+ASSYM(LINUX_VERSION_CODE, LINUX_VERSION_CODE);
>+ASSYM(LINUX_SC_ESP, offsetof(struct l_sigcontext, sc_esp));
>Index: sys/amd64/linux32/linux32_locore.s
>===================================================================
>--- sys/amd64/linux32/linux32_locore.s	(revision 285633)
>+++ sys/amd64/linux32/linux32_locore.s	(working copy)
>@@ -5,34 +5,152 @@
> 
> #include <amd64/linux32/linux32_syscall.h>	/* system call numbers */
> 
>+.data
>+
>+	.globl linux_platform
>+linux_platform:
>+	.asciz "i686"
>+
> .text
> .code32
> 
>-NON_GPROF_ENTRY(linux_sigcode)
>-	call	*LINUX_SIGF_HANDLER(%esp)
>-	leal	LINUX_SIGF_SC(%esp),%ebx	/* linux scp */
>-	movl	%esp, %ebx			/* pass sigframe */
>-	push	%eax				/* fake ret addr */
>+/*
>+ * To avoid excess stack frame the signal trampoline code emulates
>+ * the 'call' instruction.
>+ */
>+NON_GPROF_ENTRY(linux32_sigcode)
>+	movl	%esp, %ebx			/* preserve sigframe */
>+	call .getip0
>+.getip0:
>+	popl	%eax
>+	add	$.startsigcode-.getip0, %eax	/* ret address */
>+	push	%eax
>+	jmp	*LINUX_SIGF_HANDLER(%ebx)
>+.startsigcode:
>+	popl	%eax
> 	movl	$LINUX_SYS_linux_sigreturn,%eax	/* linux_sigreturn() */
> 	int	$0x80				/* enter kernel with args */
>+.endsigcode:
> 0:	jmp	0b
>-	ALIGN_TEXT
>-/* XXXXX */
>-linux_rt_sigcode:
>-	call	*LINUX_RT_SIGF_HANDLER(%esp)
>+
>+NON_GPROF_ENTRY(linux32_rt_sigcode)
> 	leal	LINUX_RT_SIGF_UC(%esp),%ebx	/* linux ucp */
> 	leal	LINUX_RT_SIGF_SC(%ebx),%ecx	/* linux sigcontext */
>-	push	%eax				/* fake ret addr */
>+	movl	%esp, %edi
>+	call	.getip1
>+.getip1:
>+	popl	%eax
>+	add	$.startrtsigcode-.getip1, %eax	/* ret address */
>+	push	%eax
>+	jmp	*LINUX_RT_SIGF_HANDLER(%edi)
>+.startrtsigcode:
> 	movl	$LINUX_SYS_linux_rt_sigreturn,%eax   /* linux_rt_sigreturn() */
> 	int	$0x80				/* enter kernel with args */
>+.endrtsigcode:
> 0:	jmp	0b
>-	ALIGN_TEXT
>-/* XXXXX */
>-linux_esigcode:
> 
>-	.data
>-	.globl	linux_szsigcode, linux_sznonrtsigcode
>-linux_szsigcode:
>-	.long	linux_esigcode-linux_sigcode
>-linux_sznonrtsigcode:
>-	.long	linux_rt_sigcode-linux_sigcode
>+NON_GPROF_ENTRY(linux32_vsyscall)
>+.startvsyscall:
>+	int $0x80
>+	ret
>+.endvsyscall:
>+
>+#if 0
>+	.section .note.Linux, "a",@note
>+	.long 2f - 1f		/* namesz */
>+	.balign 4
>+	.long 4f - 3f		/* descsz */
>+	.long 0
>+1:
>+	.asciz "Linux"
>+2:
>+	.balign 4
>+3:
>+	.long LINUX_VERSION_CODE
>+4:
>+	.balign 4
>+	.previous
>+#endif
>+
>+#define do_cfa_expr(offset)                                             \
>+	.byte 0x0f;			/* DW_CFA_def_cfa_expression */ \
>+	.uleb128 11f-10f;		/*   length */                  \
>+10:	.byte 0x74;			/*     DW_OP_breg4 */           \
>+	.sleb128 offset;		/*      offset */               \
>+	.byte 0x06;			/*     DW_OP_deref */           \
>+11:
>+
>+
>+	/* CIE */
>+	.section .eh_frame,"a",@progbits
>+.LSTARTFRAMEDLSI1:
>+	.long .LENDCIEDLSI1-.LSTARTCIEDLSI1
>+.LSTARTCIEDLSI1:
>+	.long 0					/* CIE ID */
>+	.byte 1					/* Version number */
>+	.string "zRS"				/* NULL-terminated
>+						 * augmentation string
>+						 */
>+	.uleb128 1				/* Code alignment factor */
>+	.sleb128 -4				/* Data alignment factor */
>+	.byte 8					/* Return address
>+						 * register column
>+						 */
>+	.uleb128 1				/* Augmentation value length */
>+	.byte 0x1b				/* DW_EH_PE_pcrel|DW_EH_PE_sdata4. */
>+	.byte 0					/* DW_CFA_nop */
>+	.align 4
>+.LENDCIEDLSI1:
>+
>+	/* FDE */
>+	.long .LENDFDEDLSI1-.LSTARTFDEDLSI1	/* Length FDE */
>+.LSTARTFDEDLSI1:
>+	.long .LSTARTFDEDLSI1-.LSTARTFRAMEDLSI1 /* CIE pointer */
>+	.long .startsigcode-.			/* PC-relative start address */
>+	.long .endsigcode-.startsigcode
>+	.uleb128 0				/* Augmentation */
>+	do_cfa_expr(LINUX_SIGF_SC-8)
>+	.align 4
>+.LENDFDEDLSI1:
>+
>+	.long .LENDFDEDLSI2-.LSTARTFDEDLSI2	/* Length FDE */
>+.LSTARTFDEDLSI2:
>+	.long .LSTARTFDEDLSI2-.LSTARTFRAMEDLSI1	/* CIE pointer */
>+	.long .startrtsigcode-.			/* PC-relative start address */
>+	.long .endrtsigcode-.startrtsigcode
>+	.uleb128 0				/* Augmentation */
>+	do_cfa_expr(LINUX_RT_SIGF_SC-4+LINUX_SC_ESP)
>+	.align 4
>+.LENDFDEDLSI2:
>+	.previous
>+
>+	.section .eh_frame,"a",@progbits
>+.LSTARTFRAMEDLSI2:
>+	.long .LENDCIEDLSI2-.LSTARTCIEDLSI2
>+.LSTARTCIEDLSI2:
>+	.long 0					/* CIE ID */
>+	.byte 1					/* Version number */
>+	.string "zR"				/* NULL-terminated
>+						 * augmentation string
>+						 */
>+	.uleb128 1				/* Code alignment factor */
>+	.sleb128 -4				/* Data alignment factor */
>+	.byte 8					/* Return address register column */
>+	.uleb128 1				/* Augmentation value length */
>+	.byte 0x1b				/* DW_EH_PE_pcrel|DW_EH_PE_sdata4. */
>+	.byte 0x0c				/* DW_CFA_def_cfa */
>+	.uleb128 4
>+	.uleb128 4
>+	.byte 0x88				/* DW_CFA_offset, column 0x8 */
>+	.uleb128 1
>+	.align 4
>+.LENDCIEDLSI2:
>+	.long .LENDFDEDLSI3-.LSTARTFDEDLSI3 /* Length FDE */
>+.LSTARTFDEDLSI3:
>+	.long .LSTARTFDEDLSI3-.LSTARTFRAMEDLSI2 /* CIE pointer */
>+	.long .startvsyscall-.			/* PC-relative start address */
>+	.long .endvsyscall-.startvsyscall
>+	.uleb128 0
>+	.align 4
>+.LENDFDEDLSI3:
>+	.previous
>Index: sys/amd64/linux32/linux32_machdep.c
>===================================================================
>--- sys/amd64/linux32/linux32_machdep.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_machdep.c	(working copy)
>@@ -31,6 +31,8 @@
> #include <sys/cdefs.h>
> __FBSDID("$FreeBSD$");
> 
>+#include "opt_compat.h"
>+
> #include <sys/param.h>
> #include <sys/kernel.h>
> #include <sys/systm.h>
>@@ -48,7 +50,6 @@
> #include <sys/proc.h>
> #include <sys/resource.h>
> #include <sys/resourcevar.h>
>-#include <sys/sched.h>
> #include <sys/syscallsubr.h>
> #include <sys/sysproto.h>
> #include <sys/unistd.h>
>@@ -81,34 +82,10 @@
> 	l_uintptr_t	timeout;
> } __packed;
> 
>-int
>-linux_to_bsd_sigaltstack(int lsa)
>-{
>-	int bsa = 0;
>-
>-	if (lsa & LINUX_SS_DISABLE)
>-		bsa |= SS_DISABLE;
>-	if (lsa & LINUX_SS_ONSTACK)
>-		bsa |= SS_ONSTACK;
>-	return (bsa);
>-}
>-
> static int	linux_mmap_common(struct thread *td, l_uintptr_t addr,
> 		    l_size_t len, l_int prot, l_int flags, l_int fd,
> 		    l_loff_t pos);
> 
>-int
>-bsd_to_linux_sigaltstack(int bsa)
>-{
>-	int lsa = 0;
>-
>-	if (bsa & SS_DISABLE)
>-		lsa |= LINUX_SS_DISABLE;
>-	if (bsa & SS_ONSTACK)
>-		lsa |= LINUX_SS_ONSTACK;
>-	return (lsa);
>-}
>-
> static void
> bsd_to_linux_rusage(struct rusage *ru, struct l_rusage *lru)
> {
>@@ -137,7 +114,6 @@
> linux_execve(struct thread *td, struct linux_execve_args *args)
> {
> 	struct image_args eargs;
>-	struct vmspace *oldvmspace;
> 	char *path;
> 	int error;
> 
>@@ -148,26 +124,11 @@
> 		printf(ARGS(execve, "%s"), path);
> #endif
> 
>-	error = pre_execve(td, &oldvmspace);
>-	if (error != 0) {
>-		free(path, M_TEMP);
>-		return (error);
>-	}
> 	error = freebsd32_exec_copyin_args(&eargs, path, UIO_SYSSPACE,
> 	    args->argp, args->envp);
> 	free(path, M_TEMP);
> 	if (error == 0)
>-		error = kern_execve(td, &eargs, NULL);
>-	if (error == 0) {
>-		/* Linux process can execute FreeBSD one, do not attempt
>-		 * to create emuldata for such process using
>-		 * linux_proc_init, this leads to a panic on KASSERT
>-		 * because such process has p->p_emuldata == NULL.
>-		 */
>-		if (SV_PROC_ABI(td->td_proc) == SV_ABI_LINUX)
>-			error = linux_proc_init(td, 0, 0);
>-	}
>-	post_execve(td, error, oldvmspace);
>+		error = linux_common_execve(td, &eargs);
> 	return (error);
> }
> 
>@@ -465,8 +426,14 @@
> linux_set_upcall_kse(struct thread *td, register_t stack)
> {
> 
>-	td->td_frame->tf_rsp = stack;
>+	if (stack)
>+		td->td_frame->tf_rsp = stack;
> 
>+	/*
>+	 * The newly created Linux thread returns
>+	 * to the user space by the same path that a parent do.
>+	 */
>+	td->td_frame->tf_rax = 0;
> 	return (0);
> }
> 
>@@ -729,7 +696,7 @@
> 		act.lsa_flags = osa.lsa_flags;
> 		act.lsa_restorer = osa.lsa_restorer;
> 		LINUX_SIGEMPTYSET(act.lsa_mask);
>-		act.lsa_mask.__bits[0] = osa.lsa_mask;
>+		act.lsa_mask.__mask = osa.lsa_mask;
> 	}
> 
> 	error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL,
>@@ -739,7 +706,7 @@
> 		osa.lsa_handler = oact.lsa_handler;
> 		osa.lsa_flags = oact.lsa_flags;
> 		osa.lsa_restorer = oact.lsa_restorer;
>-		osa.lsa_mask = oact.lsa_mask.__bits[0];
>+		osa.lsa_mask = oact.lsa_mask.__mask;
> 		error = copyout(&osa, args->osa, sizeof(l_osigaction_t));
> 	}
> 
>@@ -763,7 +730,7 @@
> #endif
> 
> 	LINUX_SIGEMPTYSET(mask);
>-	mask.__bits[0] = args->mask;
>+	mask.__mask = args->mask;
> 	linux_to_bsd_sigset(&mask, &sigmask);
> 	return (kern_sigsuspend(td, sigmask));
> }
>@@ -925,22 +892,6 @@
> }
> 
> int
>-linux_sched_rr_get_interval(struct thread *td,
>-    struct linux_sched_rr_get_interval_args *uap)
>-{
>-	struct timespec ts;
>-	struct l_timespec ts32;
>-	int error;
>-
>-	error = kern_sched_rr_get_interval(td, uap->pid, &ts);
>-	if (error != 0)
>-		return (error);
>-	ts32.tv_sec = ts.tv_sec;
>-	ts32.tv_nsec = ts.tv_nsec;
>-	return (copyout(&ts32, uap->interval, sizeof(ts32)));
>-}
>-
>-int
> linux_set_thread_area(struct thread *td,
>     struct linux_set_thread_area_args *args)
> {
>@@ -1056,11 +1007,12 @@
> 		    args->pid, (void *)args->status, args->options,
> 		    (void *)args->rusage);
> #endif
>+	if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |
>+	    LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))
>+		return (EINVAL);
> 
>-	options = (args->options & (WNOHANG | WUNTRACED));
>-	/* WLINUXCLONE should be equal to __WCLONE, but we make sure */
>-	if (args->options & __WCLONE)
>-		options |= WLINUXCLONE;
>+	options = WEXITED;
>+	linux_to_bsd_waitopts(args->options, &options);
> 
> 	if (args->rusage != NULL)
> 		rup = &ru;
>@@ -1076,3 +1028,66 @@
> 
> 	return (error);
> }
>+
>+int
>+linux_waitid(struct thread *td, struct linux_waitid_args *args)
>+{
>+	int status, options, sig;
>+	struct __wrusage wru;
>+	struct l_rusage lru;
>+	siginfo_t siginfo;
>+	l_siginfo_t lsi;
>+	idtype_t idtype;
>+	struct proc *p;
>+	int error;
>+
>+	options = 0;
>+	linux_to_bsd_waitopts(args->options, &options);
>+
>+	if (options & ~(WNOHANG | WNOWAIT | WEXITED | WUNTRACED | WCONTINUED))
>+		return (EINVAL);
>+	if (!(options & (WEXITED | WUNTRACED | WCONTINUED)))
>+		return (EINVAL);
>+
>+	switch (args->idtype) {
>+	case LINUX_P_ALL:
>+		idtype = P_ALL;
>+		break;
>+	case LINUX_P_PID:
>+		if (args->id <= 0)
>+			return (EINVAL);
>+		idtype = P_PID;
>+		break;
>+	case LINUX_P_PGID:
>+		if (args->id <= 0)
>+			return (EINVAL);
>+		idtype = P_PGID;
>+		break;
>+	default:
>+		return (EINVAL);
>+	}
>+
>+	error = kern_wait6(td, idtype, args->id, &status, options,
>+	    &wru, &siginfo);
>+	if (error)
>+		return (error);
>+	if (args->rusage != NULL) {
>+		bsd_to_linux_rusage(&wru.wru_children, &lru);
>+		error = copyout(&lru, args->rusage, sizeof(lru));
>+		if (error)
>+			return (error);
>+	}
>+	if (args->info != NULL) {
>+		p = td->td_proc;
>+		if (td->td_retval[0] == 0)
>+			bzero(&lsi, sizeof(lsi));
>+		else {
>+			sig = bsd_to_linux_signal(siginfo.si_signo);
>+			siginfo_to_lsiginfo(&siginfo, &lsi, sig);
>+		}
>+		error = copyout(&lsi, args->info, sizeof(lsi));
>+	}
>+	td->td_retval[0] = 0;
>+
>+	return (error);
>+}
>Index: sys/amd64/linux32/linux32_proto.h
>===================================================================
>--- sys/amd64/linux32/linux32_proto.h	(revision 285633)
>+++ sys/amd64/linux32/linux32_proto.h	(working copy)
>@@ -35,6 +35,9 @@
> #endif
> 
> #define	nosys	linux_nosys
>+struct linux_exit_args {
>+	char rval_l_[PADL_(int)]; int rval; char rval_r_[PADR_(int)];
>+};
> struct linux_fork_args {
> 	register_t dummy;
> };
>@@ -475,6 +478,14 @@
> struct linux_sysctl_args {
> 	char args_l_[PADL_(struct l___sysctl_args *)]; struct l___sysctl_args * args; char args_r_[PADR_(struct l___sysctl_args *)];
> };
>+struct linux_sched_setparam_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
>+struct linux_sched_getparam_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
> struct linux_sched_setscheduler_args {
> 	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
> 	char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)];
>@@ -563,7 +574,9 @@
> 	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
> };
> struct linux_rt_sigqueueinfo_args {
>-	register_t dummy;
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)];
>+	char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)];
> };
> struct linux_rt_sigsuspend_args {
> 	char newset_l_[PADL_(l_sigset_t *)]; l_sigset_t * newset; char newset_r_[PADR_(l_sigset_t *)];
>@@ -766,13 +779,19 @@
> 	register_t dummy;
> };
> struct linux_epoll_create_args {
>-	register_t dummy;
>+	char size_l_[PADL_(l_int)]; l_int size; char size_r_[PADR_(l_int)];
> };
> struct linux_epoll_ctl_args {
>-	register_t dummy;
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char op_l_[PADL_(l_int)]; l_int op; char op_r_[PADR_(l_int)];
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char event_l_[PADL_(struct epoll_event *)]; struct epoll_event * event; char event_r_[PADR_(struct epoll_event *)];
> };
> struct linux_epoll_wait_args {
>-	register_t dummy;
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)];
>+	char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)];
>+	char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)];
> };
> struct linux_remap_file_pages_args {
> 	register_t dummy;
>@@ -873,7 +892,11 @@
> 	register_t dummy;
> };
> struct linux_waitid_args {
>-	register_t dummy;
>+	char idtype_l_[PADL_(int)]; int idtype; char idtype_r_[PADR_(int)];
>+	char id_l_[PADL_(l_pid_t)]; l_pid_t id; char id_r_[PADR_(l_pid_t)];
>+	char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)];
>+	char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)];
>+	char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)];
> };
> struct linux_add_key_args {
> 	register_t dummy;
>@@ -975,13 +998,21 @@
> 	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
> 	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
> 	char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)];
>-	char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)];
> };
> struct linux_pselect6_args {
>-	register_t dummy;
>+	char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)];
>+	char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)];
>+	char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)];
>+	char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)];
>+	char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)];
>+	char sig_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * sig; char sig_r_[PADR_(l_uintptr_t *)];
> };
> struct linux_ppoll_args {
>-	register_t dummy;
>+	char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)];
>+	char nfds_l_[PADL_(uint32_t)]; uint32_t nfds; char nfds_r_[PADR_(uint32_t)];
>+	char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)];
>+	char sset_l_[PADL_(l_sigset_t *)]; l_sigset_t * sset; char sset_r_[PADR_(l_sigset_t *)];
>+	char ssize_l_[PADL_(l_size_t)]; l_size_t ssize; char ssize_r_[PADR_(l_size_t)];
> };
> struct linux_unshare_args {
> 	register_t dummy;
>@@ -1014,10 +1045,17 @@
> 	register_t dummy;
> };
> struct linux_epoll_pwait_args {
>-	register_t dummy;
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)];
>+	char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)];
>+	char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)];
>+	char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)];
> };
> struct linux_utimensat_args {
>-	register_t dummy;
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)];
>+	char times_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * times; char times_r_[PADR_(const struct l_timespec *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_signalfd_args {
> 	register_t dummy;
>@@ -1026,10 +1064,13 @@
> 	register_t dummy;
> };
> struct linux_eventfd_args {
>-	register_t dummy;
>+	char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)];
> };
> struct linux_fallocate_args {
>-	register_t dummy;
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];
>+	char len_l_[PADL_(l_loff_t)]; l_loff_t len; char len_r_[PADR_(l_loff_t)];
> };
> struct linux_timerfd_settime_args {
> 	register_t dummy;
>@@ -1041,13 +1082,16 @@
> 	register_t dummy;
> };
> struct linux_eventfd2_args {
>-	register_t dummy;
>+	char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_epoll_create1_args {
>-	register_t dummy;
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_dup3_args {
>-	register_t dummy;
>+	char oldfd_l_[PADL_(l_int)]; l_int oldfd; char oldfd_r_[PADR_(l_int)];
>+	char newfd_l_[PADL_(l_int)]; l_int newfd; char newfd_r_[PADR_(l_int)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_pipe2_args {
> 	char pipefds_l_[PADL_(l_int *)]; l_int * pipefds; char pipefds_r_[PADR_(l_int *)];
>@@ -1069,7 +1113,11 @@
> 	register_t dummy;
> };
> struct linux_recvmmsg_args {
>-	register_t dummy;
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)];
>+	char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)];
>+	char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)];
> };
> struct linux_fanotify_init_args {
> 	register_t dummy;
>@@ -1078,7 +1126,10 @@
> 	register_t dummy;
> };
> struct linux_prlimit64_args {
>-	register_t dummy;
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)];
>+	char new_l_[PADL_(struct rlimit *)]; struct rlimit * new; char new_r_[PADR_(struct rlimit *)];
>+	char old_l_[PADL_(struct rlimit *)]; struct rlimit * old; char old_r_[PADR_(struct rlimit *)];
> };
> struct linux_name_to_handle_at_args {
> 	register_t dummy;
>@@ -1090,10 +1141,13 @@
> 	register_t dummy;
> };
> struct linux_syncfs_args {
>-	register_t dummy;
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
> };
> struct linux_sendmmsg_args {
>-	register_t dummy;
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)];
>+	char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)];
> };
> struct linux_setns_args {
> 	register_t dummy;
>@@ -1105,6 +1159,7 @@
> 	register_t dummy;
> };
> #define	nosys	linux_nosys
>+int	linux_exit(struct thread *, struct linux_exit_args *);
> int	linux_fork(struct thread *, struct linux_fork_args *);
> int	linux_open(struct thread *, struct linux_open_args *);
> int	linux_waitpid(struct thread *, struct linux_waitpid_args *);
>@@ -1216,6 +1271,8 @@
> int	linux_getsid(struct thread *, struct linux_getsid_args *);
> int	linux_fdatasync(struct thread *, struct linux_fdatasync_args *);
> int	linux_sysctl(struct thread *, struct linux_sysctl_args *);
>+int	linux_sched_setparam(struct thread *, struct linux_sched_setparam_args *);
>+int	linux_sched_getparam(struct thread *, struct linux_sched_getparam_args *);
> int	linux_sched_setscheduler(struct thread *, struct linux_sched_setscheduler_args *);
> int	linux_sched_getscheduler(struct thread *, struct linux_sched_getscheduler_args *);
> int	linux_sched_get_priority_max(struct thread *, struct linux_sched_get_priority_max_args *);
>@@ -1407,6 +1464,7 @@
> 
> #endif /* COMPAT_FREEBSD7 */
> 
>+#define	LINUX_SYS_AUE_linux_exit	AUE_EXIT
> #define	LINUX_SYS_AUE_linux_fork	AUE_FORK
> #define	LINUX_SYS_AUE_linux_open	AUE_OPEN_RWTC
> #define	LINUX_SYS_AUE_linux_waitpid	AUE_WAIT4
>@@ -1518,6 +1576,8 @@
> #define	LINUX_SYS_AUE_linux_getsid	AUE_GETSID
> #define	LINUX_SYS_AUE_linux_fdatasync	AUE_NULL
> #define	LINUX_SYS_AUE_linux_sysctl	AUE_SYSCTL
>+#define	LINUX_SYS_AUE_linux_sched_setparam	AUE_SCHED_SETPARAM
>+#define	LINUX_SYS_AUE_linux_sched_getparam	AUE_SCHED_GETPARAM
> #define	LINUX_SYS_AUE_linux_sched_setscheduler	AUE_SCHED_SETSCHEDULER
> #define	LINUX_SYS_AUE_linux_sched_getscheduler	AUE_SCHED_GETSCHEDULER
> #define	LINUX_SYS_AUE_linux_sched_get_priority_max	AUE_SCHED_GET_PRIORITY_MAX
>@@ -1617,7 +1677,7 @@
> #define	LINUX_SYS_AUE_linux_mq_notify	AUE_NULL
> #define	LINUX_SYS_AUE_linux_mq_getsetattr	AUE_NULL
> #define	LINUX_SYS_AUE_linux_kexec_load	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_waitid	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_waitid	AUE_WAIT6
> #define	LINUX_SYS_AUE_linux_add_key	AUE_NULL
> #define	LINUX_SYS_AUE_linux_request_key	AUE_NULL
> #define	LINUX_SYS_AUE_linux_keyctl	AUE_NULL
>@@ -1640,8 +1700,8 @@
> #define	LINUX_SYS_AUE_linux_readlinkat	AUE_READLINKAT
> #define	LINUX_SYS_AUE_linux_fchmodat	AUE_FCHMODAT
> #define	LINUX_SYS_AUE_linux_faccessat	AUE_FACCESSAT
>-#define	LINUX_SYS_AUE_linux_pselect6	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_ppoll	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_pselect6	AUE_SELECT
>+#define	LINUX_SYS_AUE_linux_ppoll	AUE_POLL
> #define	LINUX_SYS_AUE_linux_unshare	AUE_NULL
> #define	LINUX_SYS_AUE_linux_set_robust_list	AUE_NULL
> #define	LINUX_SYS_AUE_linux_get_robust_list	AUE_NULL
>@@ -1652,7 +1712,7 @@
> #define	LINUX_SYS_AUE_linux_move_pages	AUE_NULL
> #define	LINUX_SYS_AUE_linux_getcpu	AUE_NULL
> #define	LINUX_SYS_AUE_linux_epoll_pwait	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_utimensat	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_utimensat	AUE_FUTIMESAT
> #define	LINUX_SYS_AUE_linux_signalfd	AUE_NULL
> #define	LINUX_SYS_AUE_linux_timerfd_create	AUE_NULL
> #define	LINUX_SYS_AUE_linux_eventfd	AUE_NULL
>@@ -1676,7 +1736,7 @@
> #define	LINUX_SYS_AUE_linux_name_to_handle_at	AUE_NULL
> #define	LINUX_SYS_AUE_linux_open_by_handle_at	AUE_NULL
> #define	LINUX_SYS_AUE_linux_clock_adjtime	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_syncfs	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_syncfs	AUE_SYNC
> #define	LINUX_SYS_AUE_linux_sendmmsg	AUE_NULL
> #define	LINUX_SYS_AUE_linux_setns	AUE_NULL
> #define	LINUX_SYS_AUE_linux_process_vm_readv	AUE_NULL
>Index: sys/amd64/linux32/linux32_syscall.h
>===================================================================
>--- sys/amd64/linux32/linux32_syscall.h	(revision 285633)
>+++ sys/amd64/linux32/linux32_syscall.h	(working copy)
>@@ -6,7 +6,7 @@
>  * created from FreeBSD: stable/10/sys/amd64/linux32/syscalls.master 276810 2015-01-08 06:23:11Z dchagin 
>  */
> 
>-#define	LINUX_SYS_exit	1
>+#define	LINUX_SYS_linux_exit	1
> #define	LINUX_SYS_linux_fork	2
> #define	LINUX_SYS_read	3
> #define	LINUX_SYS_write	4
>@@ -143,8 +143,8 @@
> #define	LINUX_SYS_munlock	151
> #define	LINUX_SYS_mlockall	152
> #define	LINUX_SYS_munlockall	153
>-#define	LINUX_SYS_sched_setparam	154
>-#define	LINUX_SYS_sched_getparam	155
>+#define	LINUX_SYS_linux_sched_setparam	154
>+#define	LINUX_SYS_linux_sched_getparam	155
> #define	LINUX_SYS_linux_sched_setscheduler	156
> #define	LINUX_SYS_linux_sched_getscheduler	157
> #define	LINUX_SYS_sched_yield	158
>@@ -321,4 +321,4 @@
> #define	LINUX_SYS_linux_setns	346
> #define	LINUX_SYS_linux_process_vm_readv	347
> #define	LINUX_SYS_linux_process_vm_writev	348
>-#define	LINUX_SYS_MAXSYSCALL	349
>+#define	LINUX_SYS_MAXSYSCALL	350
>Index: sys/amd64/linux32/linux32_syscalls.c
>===================================================================
>--- sys/amd64/linux32/linux32_syscalls.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_syscalls.c	(working copy)
>@@ -9,7 +9,7 @@
> const char *linux_syscallnames[] = {
> #define	nosys	linux_nosys
> 	"#0",			/* 0 = setup */
>-	"exit",			/* 1 = exit */
>+	"linux_exit",			/* 1 = exit */
> 	"linux_fork",			/* 2 = linux_fork */
> 	"read",			/* 3 = read */
> 	"write",			/* 4 = write */
>@@ -162,8 +162,8 @@
> 	"munlock",			/* 151 = munlock */
> 	"mlockall",			/* 152 = mlockall */
> 	"munlockall",			/* 153 = munlockall */
>-	"sched_setparam",			/* 154 = sched_setparam */
>-	"sched_getparam",			/* 155 = sched_getparam */
>+	"linux_sched_setparam",			/* 154 = linux_sched_setparam */
>+	"linux_sched_getparam",			/* 155 = linux_sched_getparam */
> 	"linux_sched_setscheduler",			/* 156 = linux_sched_setscheduler */
> 	"linux_sched_getscheduler",			/* 157 = linux_sched_getscheduler */
> 	"sched_yield",			/* 158 = sched_yield */
>@@ -357,4 +357,5 @@
> 	"linux_setns",			/* 346 = linux_setns */
> 	"linux_process_vm_readv",			/* 347 = linux_process_vm_readv */
> 	"linux_process_vm_writev",			/* 348 = linux_process_vm_writev */
>+	"#349",			/* 349 = nosys */
> };
>Index: sys/amd64/linux32/linux32_sysent.c
>===================================================================
>--- sys/amd64/linux32/linux32_sysent.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_sysent.c	(working copy)
>@@ -20,7 +20,7 @@
> struct sysent linux_sysent[] = {
> #define	nosys	linux_nosys
> 	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 0 = setup */
>-	{ AS(sys_exit_args), (sy_call_t *)sys_sys_exit, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 1 = exit */
>+	{ AS(linux_exit_args), (sy_call_t *)linux_exit, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 1 = linux_exit */
> 	{ 0, (sy_call_t *)linux_fork, AUE_FORK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 2 = linux_fork */
> 	{ AS(read_args), (sy_call_t *)sys_read, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 3 = read */
> 	{ AS(write_args), (sy_call_t *)sys_write, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 4 = write */
>@@ -173,8 +173,8 @@
> 	{ AS(munlock_args), (sy_call_t *)sys_munlock, AUE_MUNLOCK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 151 = munlock */
> 	{ AS(mlockall_args), (sy_call_t *)sys_mlockall, AUE_MLOCKALL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 152 = mlockall */
> 	{ 0, (sy_call_t *)sys_munlockall, AUE_MUNLOCKALL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 153 = munlockall */
>-	{ AS(sched_setparam_args), (sy_call_t *)sys_sched_setparam, AUE_SCHED_SETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 154 = sched_setparam */
>-	{ AS(sched_getparam_args), (sy_call_t *)sys_sched_getparam, AUE_SCHED_GETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 155 = sched_getparam */
>+	{ AS(linux_sched_setparam_args), (sy_call_t *)linux_sched_setparam, AUE_SCHED_SETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 154 = linux_sched_setparam */
>+	{ AS(linux_sched_getparam_args), (sy_call_t *)linux_sched_getparam, AUE_SCHED_GETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 155 = linux_sched_getparam */
> 	{ AS(linux_sched_setscheduler_args), (sy_call_t *)linux_sched_setscheduler, AUE_SCHED_SETSCHEDULER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 156 = linux_sched_setscheduler */
> 	{ AS(linux_sched_getscheduler_args), (sy_call_t *)linux_sched_getscheduler, AUE_SCHED_GETSCHEDULER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 157 = linux_sched_getscheduler */
> 	{ 0, (sy_call_t *)sys_sched_yield, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 158 = sched_yield */
>@@ -197,7 +197,7 @@
> 	{ AS(linux_rt_sigprocmask_args), (sy_call_t *)linux_rt_sigprocmask, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 175 = linux_rt_sigprocmask */
> 	{ AS(linux_rt_sigpending_args), (sy_call_t *)linux_rt_sigpending, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 176 = linux_rt_sigpending */
> 	{ AS(linux_rt_sigtimedwait_args), (sy_call_t *)linux_rt_sigtimedwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 177 = linux_rt_sigtimedwait */
>-	{ 0, (sy_call_t *)linux_rt_sigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 178 = linux_rt_sigqueueinfo */
>+	{ AS(linux_rt_sigqueueinfo_args), (sy_call_t *)linux_rt_sigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 178 = linux_rt_sigqueueinfo */
> 	{ AS(linux_rt_sigsuspend_args), (sy_call_t *)linux_rt_sigsuspend, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 179 = linux_rt_sigsuspend */
> 	{ AS(linux_pread_args), (sy_call_t *)linux_pread, AUE_PREAD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 180 = linux_pread */
> 	{ AS(linux_pwrite_args), (sy_call_t *)linux_pwrite, AUE_PWRITE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 181 = linux_pwrite */
>@@ -273,9 +273,9 @@
> 	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 251 =  */
> 	{ AS(linux_exit_group_args), (sy_call_t *)linux_exit_group, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 252 = linux_exit_group */
> 	{ 0, (sy_call_t *)linux_lookup_dcookie, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 253 = linux_lookup_dcookie */
>-	{ 0, (sy_call_t *)linux_epoll_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 254 = linux_epoll_create */
>-	{ 0, (sy_call_t *)linux_epoll_ctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 255 = linux_epoll_ctl */
>-	{ 0, (sy_call_t *)linux_epoll_wait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 256 = linux_epoll_wait */
>+	{ AS(linux_epoll_create_args), (sy_call_t *)linux_epoll_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 254 = linux_epoll_create */
>+	{ AS(linux_epoll_ctl_args), (sy_call_t *)linux_epoll_ctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 255 = linux_epoll_ctl */
>+	{ AS(linux_epoll_wait_args), (sy_call_t *)linux_epoll_wait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 256 = linux_epoll_wait */
> 	{ 0, (sy_call_t *)linux_remap_file_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 257 = linux_remap_file_pages */
> 	{ AS(linux_set_tid_address_args), (sy_call_t *)linux_set_tid_address, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 258 = linux_set_tid_address */
> 	{ AS(linux_timer_create_args), (sy_call_t *)linux_timer_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 259 = linux_timer_create */
>@@ -303,7 +303,7 @@
> 	{ 0, (sy_call_t *)linux_mq_notify, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 281 = linux_mq_notify */
> 	{ 0, (sy_call_t *)linux_mq_getsetattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 282 = linux_mq_getsetattr */
> 	{ 0, (sy_call_t *)linux_kexec_load, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 283 = linux_kexec_load */
>-	{ 0, (sy_call_t *)linux_waitid, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 284 = linux_waitid */
>+	{ AS(linux_waitid_args), (sy_call_t *)linux_waitid, AUE_WAIT6, NULL, 0, 0, 0, SY_THR_STATIC },	/* 284 = linux_waitid */
> 	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 285 =  */
> 	{ 0, (sy_call_t *)linux_add_key, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 286 = linux_add_key */
> 	{ 0, (sy_call_t *)linux_request_key, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 287 = linux_request_key */
>@@ -327,8 +327,8 @@
> 	{ AS(linux_readlinkat_args), (sy_call_t *)linux_readlinkat, AUE_READLINKAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 305 = linux_readlinkat */
> 	{ AS(linux_fchmodat_args), (sy_call_t *)linux_fchmodat, AUE_FCHMODAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 306 = linux_fchmodat */
> 	{ AS(linux_faccessat_args), (sy_call_t *)linux_faccessat, AUE_FACCESSAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 307 = linux_faccessat */
>-	{ 0, (sy_call_t *)linux_pselect6, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 308 = linux_pselect6 */
>-	{ 0, (sy_call_t *)linux_ppoll, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 309 = linux_ppoll */
>+	{ AS(linux_pselect6_args), (sy_call_t *)linux_pselect6, AUE_SELECT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 308 = linux_pselect6 */
>+	{ AS(linux_ppoll_args), (sy_call_t *)linux_ppoll, AUE_POLL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 309 = linux_ppoll */
> 	{ 0, (sy_call_t *)linux_unshare, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 310 = linux_unshare */
> 	{ AS(linux_set_robust_list_args), (sy_call_t *)linux_set_robust_list, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 311 = linux_set_robust_list */
> 	{ AS(linux_get_robust_list_args), (sy_call_t *)linux_get_robust_list, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 312 = linux_get_robust_list */
>@@ -338,18 +338,18 @@
> 	{ 0, (sy_call_t *)linux_vmsplice, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 316 = linux_vmsplice */
> 	{ 0, (sy_call_t *)linux_move_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 317 = linux_move_pages */
> 	{ 0, (sy_call_t *)linux_getcpu, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 318 = linux_getcpu */
>-	{ 0, (sy_call_t *)linux_epoll_pwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 319 = linux_epoll_pwait */
>-	{ 0, (sy_call_t *)linux_utimensat, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 320 = linux_utimensat */
>+	{ AS(linux_epoll_pwait_args), (sy_call_t *)linux_epoll_pwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 319 = linux_epoll_pwait */
>+	{ AS(linux_utimensat_args), (sy_call_t *)linux_utimensat, AUE_FUTIMESAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 320 = linux_utimensat */
> 	{ 0, (sy_call_t *)linux_signalfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 321 = linux_signalfd */
> 	{ 0, (sy_call_t *)linux_timerfd_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 322 = linux_timerfd_create */
>-	{ 0, (sy_call_t *)linux_eventfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 323 = linux_eventfd */
>-	{ 0, (sy_call_t *)linux_fallocate, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 324 = linux_fallocate */
>+	{ AS(linux_eventfd_args), (sy_call_t *)linux_eventfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 323 = linux_eventfd */
>+	{ AS(linux_fallocate_args), (sy_call_t *)linux_fallocate, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 324 = linux_fallocate */
> 	{ 0, (sy_call_t *)linux_timerfd_settime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 325 = linux_timerfd_settime */
> 	{ 0, (sy_call_t *)linux_timerfd_gettime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 326 = linux_timerfd_gettime */
> 	{ 0, (sy_call_t *)linux_signalfd4, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 327 = linux_signalfd4 */
>-	{ 0, (sy_call_t *)linux_eventfd2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 328 = linux_eventfd2 */
>-	{ 0, (sy_call_t *)linux_epoll_create1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 329 = linux_epoll_create1 */
>-	{ 0, (sy_call_t *)linux_dup3, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 330 = linux_dup3 */
>+	{ AS(linux_eventfd2_args), (sy_call_t *)linux_eventfd2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 328 = linux_eventfd2 */
>+	{ AS(linux_epoll_create1_args), (sy_call_t *)linux_epoll_create1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 329 = linux_epoll_create1 */
>+	{ AS(linux_dup3_args), (sy_call_t *)linux_dup3, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 330 = linux_dup3 */
> 	{ AS(linux_pipe2_args), (sy_call_t *)linux_pipe2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 331 = linux_pipe2 */
> 	{ 0, (sy_call_t *)linux_inotify_init1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 332 = linux_inotify_init1 */
> 	{ 0, (sy_call_t *)linux_preadv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 333 = linux_preadv */
>@@ -356,16 +356,17 @@
> 	{ 0, (sy_call_t *)linux_pwritev, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 334 = linux_pwritev */
> 	{ 0, (sy_call_t *)linux_rt_tsigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 335 = linux_rt_tsigqueueinfo */
> 	{ 0, (sy_call_t *)linux_perf_event_open, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 336 = linux_perf_event_open */
>-	{ 0, (sy_call_t *)linux_recvmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 337 = linux_recvmmsg */
>+	{ AS(linux_recvmmsg_args), (sy_call_t *)linux_recvmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 337 = linux_recvmmsg */
> 	{ 0, (sy_call_t *)linux_fanotify_init, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 338 = linux_fanotify_init */
> 	{ 0, (sy_call_t *)linux_fanotify_mark, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 339 = linux_fanotify_mark */
>-	{ 0, (sy_call_t *)linux_prlimit64, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 340 = linux_prlimit64 */
>+	{ AS(linux_prlimit64_args), (sy_call_t *)linux_prlimit64, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 340 = linux_prlimit64 */
> 	{ 0, (sy_call_t *)linux_name_to_handle_at, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 341 = linux_name_to_handle_at */
> 	{ 0, (sy_call_t *)linux_open_by_handle_at, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 342 = linux_open_by_handle_at */
> 	{ 0, (sy_call_t *)linux_clock_adjtime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 343 = linux_clock_adjtime */
>-	{ 0, (sy_call_t *)linux_syncfs, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 344 = linux_syncfs */
>-	{ 0, (sy_call_t *)linux_sendmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 345 = linux_sendmmsg */
>+	{ AS(linux_syncfs_args), (sy_call_t *)linux_syncfs, AUE_SYNC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 344 = linux_syncfs */
>+	{ AS(linux_sendmmsg_args), (sy_call_t *)linux_sendmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 345 = linux_sendmmsg */
> 	{ 0, (sy_call_t *)linux_setns, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 346 = linux_setns */
> 	{ 0, (sy_call_t *)linux_process_vm_readv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 347 = linux_process_vm_readv */
> 	{ 0, (sy_call_t *)linux_process_vm_writev, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 348 = linux_process_vm_writev */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 349 = nosys */
> };
>Index: sys/amd64/linux32/linux32_systrace_args.c
>===================================================================
>--- sys/amd64/linux32/linux32_systrace_args.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_systrace_args.c	(working copy)
>@@ -12,9 +12,9 @@
> 	int64_t *iarg  = (int64_t *) uarg;
> 	switch (sysnum) {
> #define	nosys	linux_nosys
>-	/* sys_exit */
>+	/* linux_exit */
> 	case 1: {
>-		struct sys_exit_args *p = params;
>+		struct linux_exit_args *p = params;
> 		iarg[0] = p->rval; /* int */
> 		*n_args = 1;
> 		break;
>@@ -1043,19 +1043,19 @@
> 		*n_args = 0;
> 		break;
> 	}
>-	/* sched_setparam */
>+	/* linux_sched_setparam */
> 	case 154: {
>-		struct sched_setparam_args *p = params;
>-		iarg[0] = p->pid; /* pid_t */
>-		uarg[1] = (intptr_t) p->param; /* const struct sched_param * */
>+		struct linux_sched_setparam_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->param; /* struct l_sched_param * */
> 		*n_args = 2;
> 		break;
> 	}
>-	/* sched_getparam */
>+	/* linux_sched_getparam */
> 	case 155: {
>-		struct sched_getparam_args *p = params;
>-		iarg[0] = p->pid; /* pid_t */
>-		uarg[1] = (intptr_t) p->param; /* struct sched_param * */
>+		struct linux_sched_getparam_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->param; /* struct l_sched_param * */
> 		*n_args = 2;
> 		break;
> 	}
>@@ -1234,7 +1234,11 @@
> 	}
> 	/* linux_rt_sigqueueinfo */
> 	case 178: {
>-		*n_args = 0;
>+		struct linux_rt_sigqueueinfo_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->sig; /* l_int */
>+		uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */
>+		*n_args = 3;
> 		break;
> 	}
> 	/* linux_rt_sigsuspend */
>@@ -1693,17 +1697,29 @@
> 	}
> 	/* linux_epoll_create */
> 	case 254: {
>-		*n_args = 0;
>+		struct linux_epoll_create_args *p = params;
>+		iarg[0] = p->size; /* l_int */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_epoll_ctl */
> 	case 255: {
>-		*n_args = 0;
>+		struct linux_epoll_ctl_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		iarg[1] = p->op; /* l_int */
>+		iarg[2] = p->fd; /* l_int */
>+		uarg[3] = (intptr_t) p->event; /* struct epoll_event * */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_epoll_wait */
> 	case 256: {
>-		*n_args = 0;
>+		struct linux_epoll_wait_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		uarg[1] = (intptr_t) p->events; /* struct epoll_event * */
>+		iarg[2] = p->maxevents; /* l_int */
>+		iarg[3] = p->timeout; /* l_int */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_remap_file_pages */
>@@ -1886,7 +1902,13 @@
> 	}
> 	/* linux_waitid */
> 	case 284: {
>-		*n_args = 0;
>+		struct linux_waitid_args *p = params;
>+		iarg[0] = p->idtype; /* int */
>+		iarg[1] = p->id; /* l_pid_t */
>+		uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */
>+		iarg[3] = p->options; /* int */
>+		uarg[4] = (intptr_t) p->rusage; /* struct l_rusage * */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_add_key */
>@@ -2057,18 +2079,30 @@
> 		iarg[0] = p->dfd; /* l_int */
> 		uarg[1] = (intptr_t) p->filename; /* const char * */
> 		iarg[2] = p->amode; /* l_int */
>-		iarg[3] = p->flag; /* int */
>-		*n_args = 4;
>+		*n_args = 3;
> 		break;
> 	}
> 	/* linux_pselect6 */
> 	case 308: {
>-		*n_args = 0;
>+		struct linux_pselect6_args *p = params;
>+		iarg[0] = p->nfds; /* l_int */
>+		uarg[1] = (intptr_t) p->readfds; /* l_fd_set * */
>+		uarg[2] = (intptr_t) p->writefds; /* l_fd_set * */
>+		uarg[3] = (intptr_t) p->exceptfds; /* l_fd_set * */
>+		uarg[4] = (intptr_t) p->tsp; /* struct l_timespec * */
>+		uarg[5] = (intptr_t) p->sig; /* l_uintptr_t * */
>+		*n_args = 6;
> 		break;
> 	}
> 	/* linux_ppoll */
> 	case 309: {
>-		*n_args = 0;
>+		struct linux_ppoll_args *p = params;
>+		uarg[0] = (intptr_t) p->fds; /* struct pollfd * */
>+		uarg[1] = p->nfds; /* uint32_t */
>+		uarg[2] = (intptr_t) p->tsp; /* struct l_timespec * */
>+		uarg[3] = (intptr_t) p->sset; /* l_sigset_t * */
>+		iarg[4] = p->ssize; /* l_size_t */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_unshare */
>@@ -2125,12 +2159,23 @@
> 	}
> 	/* linux_epoll_pwait */
> 	case 319: {
>-		*n_args = 0;
>+		struct linux_epoll_pwait_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		uarg[1] = (intptr_t) p->events; /* struct epoll_event * */
>+		iarg[2] = p->maxevents; /* l_int */
>+		iarg[3] = p->timeout; /* l_int */
>+		uarg[4] = (intptr_t) p->mask; /* l_sigset_t * */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_utimensat */
> 	case 320: {
>-		*n_args = 0;
>+		struct linux_utimensat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->pathname; /* const char * */
>+		uarg[2] = (intptr_t) p->times; /* const struct l_timespec * */
>+		iarg[3] = p->flags; /* l_int */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_signalfd */
>@@ -2145,12 +2190,19 @@
> 	}
> 	/* linux_eventfd */
> 	case 323: {
>-		*n_args = 0;
>+		struct linux_eventfd_args *p = params;
>+		iarg[0] = p->initval; /* l_uint */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_fallocate */
> 	case 324: {
>-		*n_args = 0;
>+		struct linux_fallocate_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		iarg[1] = p->mode; /* l_int */
>+		iarg[2] = p->offset; /* l_loff_t */
>+		iarg[3] = p->len; /* l_loff_t */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_timerfd_settime */
>@@ -2170,17 +2222,26 @@
> 	}
> 	/* linux_eventfd2 */
> 	case 328: {
>-		*n_args = 0;
>+		struct linux_eventfd2_args *p = params;
>+		iarg[0] = p->initval; /* l_uint */
>+		iarg[1] = p->flags; /* l_int */
>+		*n_args = 2;
> 		break;
> 	}
> 	/* linux_epoll_create1 */
> 	case 329: {
>-		*n_args = 0;
>+		struct linux_epoll_create1_args *p = params;
>+		iarg[0] = p->flags; /* l_int */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_dup3 */
> 	case 330: {
>-		*n_args = 0;
>+		struct linux_dup3_args *p = params;
>+		iarg[0] = p->oldfd; /* l_int */
>+		iarg[1] = p->newfd; /* l_int */
>+		iarg[2] = p->flags; /* l_int */
>+		*n_args = 3;
> 		break;
> 	}
> 	/* linux_pipe2 */
>@@ -2218,7 +2279,13 @@
> 	}
> 	/* linux_recvmmsg */
> 	case 337: {
>-		*n_args = 0;
>+		struct linux_recvmmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */
>+		iarg[2] = p->vlen; /* l_uint */
>+		iarg[3] = p->flags; /* l_uint */
>+		uarg[4] = (intptr_t) p->timeout; /* struct l_timespec * */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_fanotify_init */
>@@ -2233,7 +2300,12 @@
> 	}
> 	/* linux_prlimit64 */
> 	case 340: {
>-		*n_args = 0;
>+		struct linux_prlimit64_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->resource; /* l_uint */
>+		uarg[2] = (intptr_t) p->new; /* struct rlimit * */
>+		uarg[3] = (intptr_t) p->old; /* struct rlimit * */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_name_to_handle_at */
>@@ -2253,12 +2325,19 @@
> 	}
> 	/* linux_syncfs */
> 	case 344: {
>-		*n_args = 0;
>+		struct linux_syncfs_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_sendmmsg */
> 	case 345: {
>-		*n_args = 0;
>+		struct linux_sendmmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */
>+		iarg[2] = p->vlen; /* l_uint */
>+		iarg[3] = p->flags; /* l_uint */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_setns */
>@@ -2287,7 +2366,7 @@
> 	const char *p = NULL;
> 	switch (sysnum) {
> #define	nosys	linux_nosys
>-	/* sys_exit */
>+	/* linux_exit */
> 	case 1:
> 		switch(ndx) {
> 		case 0:
>@@ -3848,27 +3927,27 @@
> 	/* munlockall */
> 	case 153:
> 		break;
>-	/* sched_setparam */
>+	/* linux_sched_setparam */
> 	case 154:
> 		switch(ndx) {
> 		case 0:
>-			p = "pid_t";
>+			p = "l_pid_t";
> 			break;
> 		case 1:
>-			p = "const struct sched_param *";
>+			p = "struct l_sched_param *";
> 			break;
> 		default:
> 			break;
> 		};
> 		break;
>-	/* sched_getparam */
>+	/* linux_sched_getparam */
> 	case 155:
> 		switch(ndx) {
> 		case 0:
>-			p = "pid_t";
>+			p = "l_pid_t";
> 			break;
> 		case 1:
>-			p = "struct sched_param *";
>+			p = "struct l_sched_param *";
> 			break;
> 		default:
> 			break;
>@@ -4161,6 +4240,19 @@
> 		break;
> 	/* linux_rt_sigqueueinfo */
> 	case 178:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_siginfo_t *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_rt_sigsuspend */
> 	case 179:
>@@ -4823,12 +4915,51 @@
> 		break;
> 	/* linux_epoll_create */
> 	case 254:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_epoll_ctl */
> 	case 255:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "struct epoll_event *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_epoll_wait */
> 	case 256:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct epoll_event *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_remap_file_pages */
> 	case 257:
>@@ -5068,6 +5199,25 @@
> 		break;
> 	/* linux_waitid */
> 	case 284:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "l_pid_t";
>+			break;
>+		case 2:
>+			p = "l_siginfo_t *";
>+			break;
>+		case 3:
>+			p = "int";
>+			break;
>+		case 4:
>+			p = "struct l_rusage *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_add_key */
> 	case 286:
>@@ -5327,9 +5477,6 @@
> 		case 2:
> 			p = "l_int";
> 			break;
>-		case 3:
>-			p = "int";
>-			break;
> 		default:
> 			break;
> 		};
>@@ -5336,9 +5483,50 @@
> 		break;
> 	/* linux_pselect6 */
> 	case 308:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_fd_set *";
>+			break;
>+		case 2:
>+			p = "l_fd_set *";
>+			break;
>+		case 3:
>+			p = "l_fd_set *";
>+			break;
>+		case 4:
>+			p = "struct l_timespec *";
>+			break;
>+		case 5:
>+			p = "l_uintptr_t *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_ppoll */
> 	case 309:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct pollfd *";
>+			break;
>+		case 1:
>+			p = "uint32_t";
>+			break;
>+		case 2:
>+			p = "struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "l_sigset_t *";
>+			break;
>+		case 4:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_unshare */
> 	case 310:
>@@ -5392,9 +5580,44 @@
> 		break;
> 	/* linux_epoll_pwait */
> 	case 319:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct epoll_event *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		case 4:
>+			p = "l_sigset_t *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_utimensat */
> 	case 320:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "const struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_signalfd */
> 	case 321:
>@@ -5404,9 +5627,32 @@
> 		break;
> 	/* linux_eventfd */
> 	case 323:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_fallocate */
> 	case 324:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_loff_t";
>+			break;
>+		case 3:
>+			p = "l_loff_t";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_timerfd_settime */
> 	case 325:
>@@ -5419,12 +5665,42 @@
> 		break;
> 	/* linux_eventfd2 */
> 	case 328:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_epoll_create1 */
> 	case 329:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_dup3 */
> 	case 330:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_pipe2 */
> 	case 331:
>@@ -5456,6 +5732,25 @@
> 		break;
> 	/* linux_recvmmsg */
> 	case 337:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_mmsghdr *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		case 4:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_fanotify_init */
> 	case 338:
>@@ -5465,6 +5760,22 @@
> 		break;
> 	/* linux_prlimit64 */
> 	case 340:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "struct rlimit *";
>+			break;
>+		case 3:
>+			p = "struct rlimit *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_name_to_handle_at */
> 	case 341:
>@@ -5477,9 +5788,32 @@
> 		break;
> 	/* linux_syncfs */
> 	case 344:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_sendmmsg */
> 	case 345:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_mmsghdr *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_setns */
> 	case 346:
>@@ -5502,7 +5836,7 @@
> 	const char *p = NULL;
> 	switch (sysnum) {
> #define	nosys	linux_nosys
>-	/* sys_exit */
>+	/* linux_exit */
> 	case 1:
> 		if (ndx == 0 || ndx == 1)
> 			p = "void";
>@@ -6112,12 +6446,12 @@
> 		break;
> 	/* munlockall */
> 	case 153:
>-	/* sched_setparam */
>+	/* linux_sched_setparam */
> 	case 154:
> 		if (ndx == 0 || ndx == 1)
> 			p = "int";
> 		break;
>-	/* sched_getparam */
>+	/* linux_sched_getparam */
> 	case 155:
> 		if (ndx == 0 || ndx == 1)
> 			p = "int";
>@@ -6220,6 +6554,9 @@
> 		break;
> 	/* linux_rt_sigqueueinfo */
> 	case 178:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_rt_sigsuspend */
> 	case 179:
> 		if (ndx == 0 || ndx == 1)
>@@ -6469,10 +6806,19 @@
> 	case 253:
> 	/* linux_epoll_create */
> 	case 254:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_epoll_ctl */
> 	case 255:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_epoll_wait */
> 	case 256:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_remap_file_pages */
> 	case 257:
> 	/* linux_set_tid_address */
>@@ -6569,6 +6915,9 @@
> 	case 283:
> 	/* linux_waitid */
> 	case 284:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_add_key */
> 	case 286:
> 	/* linux_request_key */
>@@ -6654,8 +7003,14 @@
> 		break;
> 	/* linux_pselect6 */
> 	case 308:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_ppoll */
> 	case 309:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_unshare */
> 	case 310:
> 	/* linux_set_robust_list */
>@@ -6682,8 +7037,14 @@
> 	case 318:
> 	/* linux_epoll_pwait */
> 	case 319:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_utimensat */
> 	case 320:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_signalfd */
> 	case 321:
> 	/* linux_timerfd_create */
>@@ -6690,8 +7051,14 @@
> 	case 322:
> 	/* linux_eventfd */
> 	case 323:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_fallocate */
> 	case 324:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_timerfd_settime */
> 	case 325:
> 	/* linux_timerfd_gettime */
>@@ -6700,10 +7067,19 @@
> 	case 327:
> 	/* linux_eventfd2 */
> 	case 328:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_epoll_create1 */
> 	case 329:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_dup3 */
> 	case 330:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_pipe2 */
> 	case 331:
> 		if (ndx == 0 || ndx == 1)
>@@ -6721,6 +7097,9 @@
> 	case 336:
> 	/* linux_recvmmsg */
> 	case 337:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_fanotify_init */
> 	case 338:
> 	/* linux_fanotify_mark */
>@@ -6727,6 +7106,9 @@
> 	case 339:
> 	/* linux_prlimit64 */
> 	case 340:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_name_to_handle_at */
> 	case 341:
> 	/* linux_open_by_handle_at */
>@@ -6735,8 +7117,14 @@
> 	case 343:
> 	/* linux_syncfs */
> 	case 344:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_sendmmsg */
> 	case 345:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_setns */
> 	case 346:
> 	/* linux_process_vm_readv */
>Index: sys/amd64/linux32/linux32_sysvec.c
>===================================================================
>--- sys/amd64/linux32/linux32_sysvec.c	(revision 285633)
>+++ sys/amd64/linux32/linux32_sysvec.c	(working copy)
>@@ -83,11 +83,10 @@
> #include <compat/linux/linux_misc.h>
> #include <compat/linux/linux_signal.h>
> #include <compat/linux/linux_util.h>
>+#include <compat/linux/linux_vdso.h>
> 
> MODULE_VERSION(linux, 1);
> 
>-MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
>-
> #define	AUXARGS_ENTRY_32(pos, id, val)	\
> 	do {				\
> 		suword32(pos++, id);	\
>@@ -109,15 +108,16 @@
> #define	LINUX_SYS_linux_rt_sendsig	0
> #define	LINUX_SYS_linux_sendsig		0
> 
>-const char *linux_platform = "i686";
>-static int linux_szplatform;
>-extern char linux_sigcode[];
>-extern int linux_szsigcode;
>+const char *linux_kplatform;
>+static int linux_szsigcode;
>+static vm_object_t linux_shared_page_obj;
>+static char *linux_shared_page_mapping;
>+extern char _binary_linux32_locore_o_start;
>+extern char _binary_linux32_locore_o_end;
> 
> extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
> 
> SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
>-SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
> 
> static int	elf_linux_fixup(register_t **stack_base,
> 		    struct image_params *iparams);
>@@ -127,10 +127,9 @@
> 				   struct image_params *imgp, u_long stack);
> static void	linux32_fixlimit(struct rlimit *rl, int which);
> static boolean_t linux32_trans_osrel(const Elf_Note *note, int32_t *osrel);
>+static void	linux_vdso_install(void *param);
>+static void	linux_vdso_deinstall(void *param);
> 
>-static eventhandler_tag linux_exit_tag;
>-static eventhandler_tag linux_exec_tag;
>-
> /*
>  * Linux syscalls return negative errno's, we do positive and map them
>  * Reference:
>@@ -151,28 +150,6 @@
> 	 -72, -67, -71
> };
> 
>-int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
>-	LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
>-	LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
>-	LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
>-	LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
>-	LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
>-	LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
>-	LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
>-	0, LINUX_SIGUSR1, LINUX_SIGUSR2
>-};
>-
>-int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
>-	SIGHUP, SIGINT, SIGQUIT, SIGILL,
>-	SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
>-	SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
>-	SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
>-	SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
>-	SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
>-	SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
>-	SIGIO, SIGURG, SIGSYS
>-};
>-
> #define LINUX_T_UNKNOWN  255
> static int _bsd_to_linux_trapcode[] = {
> 	LINUX_T_UNKNOWN,	/* 0 */
>@@ -219,6 +196,11 @@
> 	u_int ps_nenvstr;	/* the number of environment strings */
> };
> 
>+LINUX_VDSO_SYM_INTPTR(linux32_sigcode);
>+LINUX_VDSO_SYM_INTPTR(linux32_rt_sigcode);
>+LINUX_VDSO_SYM_INTPTR(linux32_vsyscall);
>+LINUX_VDSO_SYM_CHAR(linux_platform);
>+
> /*
>  * If FreeBSD & Linux have a difference of opinion about what a trap
>  * means, deal with it here.
>@@ -246,11 +228,10 @@
> {
> 	Elf32_Auxargs *args;
> 	Elf32_Addr *base;
>-	Elf32_Addr *pos, *uplatform;
>+	Elf32_Addr *pos;
> 	struct linux32_ps_strings *arginfo;
> 
> 	arginfo = (struct linux32_ps_strings *)LINUX32_PS_STRINGS;
>-	uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szplatform);
> 
> 	KASSERT(curthread->td_proc == imgp->proc,
> 	    ("unsafe elf_linux_fixup(), should be curproc"));
>@@ -258,6 +239,9 @@
> 	args = (Elf32_Auxargs *)imgp->auxargs;
> 	pos = base + (imgp->args->argc + imgp->args->envc + 2);
> 
>+	AUXARGS_ENTRY_32(pos, LINUX_AT_SYSINFO_EHDR,
>+	    imgp->proc->p_sysent->sv_shared_page_base);
>+	AUXARGS_ENTRY_32(pos, LINUX_AT_SYSINFO, linux32_vsyscall);
> 	AUXARGS_ENTRY_32(pos, LINUX_AT_HWCAP, cpu_feature);
> 
> 	/*
>@@ -282,7 +266,10 @@
> 	AUXARGS_ENTRY_32(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
> 	AUXARGS_ENTRY_32(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
> 	AUXARGS_ENTRY_32(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
>-	AUXARGS_ENTRY_32(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
>+	AUXARGS_ENTRY_32(pos, LINUX_AT_PLATFORM, PTROUT(linux_platform));
>+	AUXARGS_ENTRY(pos, LINUX_AT_RANDOM, PTROUT(imgp->canary));
>+	if (imgp->execpathp != 0)
>+		AUXARGS_ENTRY(pos, LINUX_AT_EXECFN, PTROUT(imgp->execpathp));
> 	if (args->execfd != -1)
> 		AUXARGS_ENTRY_32(pos, AT_EXECFD, args->execfd);
> 	AUXARGS_ENTRY_32(pos, AT_NULL, 0);
>@@ -293,11 +280,9 @@
> 	base--;
> 	suword32(base, (uint32_t)imgp->args->argc);
> 	*stack_base = (register_t *)base;
>-	return 0;
>+	return (0);
> }
> 
>-extern unsigned long linux_sznonrtsigcode;
>-
> static void
> linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
> {
>@@ -337,9 +322,7 @@
> 	/*
> 	 * Build the argument list for the signal handler.
> 	 */
>-	if (p->p_sysent->sv_sigtbl)
>-		if (sig <= p->p_sysent->sv_sigsize)
>-			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>+	sig = bsd_to_linux_signal(sig);
> 
> 	bzero(&frame, sizeof(frame));
> 
>@@ -352,7 +335,8 @@
> 	ksiginfo_to_lsiginfo(ksi, &frame.sf_si, sig);
> 
> 	/*
>-	 * Build the signal context to be used by sigreturn.
>+	 * Build the signal context to be used by sigreturn
>+	 * and libgcc unwind.
> 	 */
> 	frame.sf_sc.uc_flags = 0;		/* XXX ??? */
> 	frame.sf_sc.uc_link = 0;		/* XXX ??? */
>@@ -365,11 +349,12 @@
> 
> 	bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
> 
>-	frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
>+	frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__mask;
> 	frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_rdi;
> 	frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_rsi;
> 	frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_rbp;
> 	frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_rbx;
>+	frame.sf_sc.uc_mcontext.sc_esp    = regs->tf_rsp;
> 	frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_rdx;
> 	frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_rcx;
> 	frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_rax;
>@@ -411,7 +396,7 @@
> 	 * Build context to run handler in.
> 	 */
> 	regs->tf_rsp = PTROUT(fp);
>-	regs->tf_rip = p->p_sysent->sv_sigcode_base + linux_sznonrtsigcode;
>+	regs->tf_rip = linux32_rt_sigcode;
> 	regs->tf_rflags &= ~(PSL_T | PSL_D);
> 	regs->tf_cs = _ucode32sel;
> 	regs->tf_ss = _udatasel;
>@@ -445,7 +430,7 @@
> 	struct trapframe *regs;
> 	struct l_sigframe *fp, frame;
> 	l_sigset_t lmask;
>-	int oonstack, i;
>+	int oonstack;
> 	int sig, code;
> 
> 	sig = ksi->ksi_signo;
>@@ -483,9 +468,7 @@
> 	/*
> 	 * Build the argument list for the signal handler.
> 	 */
>-	if (p->p_sysent->sv_sigtbl)
>-		if (sig <= p->p_sysent->sv_sigsize)
>-			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>+	sig = bsd_to_linux_signal(sig);
> 
> 	bzero(&frame, sizeof(frame));
> 
>@@ -497,7 +480,7 @@
> 	/*
> 	 * Build the signal context to be used by sigreturn.
> 	 */
>-	frame.sf_sc.sc_mask   = lmask.__bits[0];
>+	frame.sf_sc.sc_mask   = lmask.__mask;
> 	frame.sf_sc.sc_gs     = regs->tf_gs;
> 	frame.sf_sc.sc_fs     = regs->tf_fs;
> 	frame.sf_sc.sc_es     = regs->tf_es;
>@@ -506,6 +489,7 @@
> 	frame.sf_sc.sc_esi    = regs->tf_rsi;
> 	frame.sf_sc.sc_ebp    = regs->tf_rbp;
> 	frame.sf_sc.sc_ebx    = regs->tf_rbx;
>+	frame.sf_sc.sc_esp    = regs->tf_rsp;
> 	frame.sf_sc.sc_edx    = regs->tf_rdx;
> 	frame.sf_sc.sc_ecx    = regs->tf_rcx;
> 	frame.sf_sc.sc_eax    = regs->tf_rax;
>@@ -518,8 +502,7 @@
> 	frame.sf_sc.sc_cr2    = (u_int32_t)(uintptr_t)ksi->ksi_addr;
> 	frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
> 
>-	for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
>-		frame.sf_extramask[i] = lmask.__bits[i+1];
>+	frame.sf_extramask[0] = lmask.__mask;
> 
> 	if (copyout(&frame, fp, sizeof(frame)) != 0) {
> 		/*
>@@ -534,7 +517,7 @@
> 	 * Build context to run handler in.
> 	 */
> 	regs->tf_rsp = PTROUT(fp);
>-	regs->tf_rip = p->p_sysent->sv_sigcode_base;
>+	regs->tf_rip = linux32_sigcode;
> 	regs->tf_rflags &= ~(PSL_T | PSL_D);
> 	regs->tf_cs = _ucode32sel;
> 	regs->tf_ss = _udatasel;
>@@ -565,7 +548,7 @@
> 	struct trapframe *regs;
> 	sigset_t bmask;
> 	l_sigset_t lmask;
>-	int eflags, i;
>+	int eflags;
> 	ksiginfo_t ksi;
> 
> 	regs = td->td_frame;
>@@ -606,9 +589,8 @@
> 		return(EINVAL);
> 	}
> 
>-	lmask.__bits[0] = frame.sf_sc.sc_mask;
>-	for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
>-		lmask.__bits[i+1] = frame.sf_extramask[i];
>+	lmask.__mask = frame.sf_sc.sc_mask;
>+	lmask.__mask = frame.sf_extramask[0];
> 	linux_to_bsd_sigset(&lmask, &bmask);
> 	kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
> 
>@@ -758,7 +740,8 @@
> 	sa->code = frame->tf_rax;
> 
> 	if (sa->code >= p->p_sysent->sv_size)
>-		sa->callp = &p->p_sysent->sv_table[0];
>+		/* nosys */
>+		sa->callp = &p->p_sysent->sv_table[LINUX_SYS_MAXSYSCALL];
> 	else
> 		sa->callp = &p->p_sysent->sv_table[sa->code];
> 	sa->narg = sa->callp->sy_narg;
>@@ -862,21 +845,36 @@
> 	char *stringp, *destp;
> 	u_int32_t *stack_base;
> 	struct linux32_ps_strings *arginfo;
>+	char canary[LINUX_AT_RANDOM_LEN];
>+	size_t execpath_len;
> 
> 	/*
> 	 * Calculate string base and vector table pointers.
>-	 * Also deal with signal trampoline code for this exec type.
> 	 */
>+	if (imgp->execpath != NULL && imgp->auxargs != NULL)
>+		execpath_len = strlen(imgp->execpath) + 1;
>+	else
>+		execpath_len = 0;
>+
> 	arginfo = (struct linux32_ps_strings *)LINUX32_PS_STRINGS;
>-	destp =	(caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
>-	    roundup((ARG_MAX - imgp->args->stringspace),
>-	    sizeof(char *));
>+	destp =	(caddr_t)arginfo - SPARE_USRSPACE -
>+	    roundup(sizeof(canary), sizeof(char *)) -
>+	    roundup(execpath_len, sizeof(char *)) -
>+	    roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
> 
>+	if (execpath_len != 0) {
>+		imgp->execpathp = (uintptr_t)arginfo - execpath_len;
>+		copyout(imgp->execpath, (void *)imgp->execpathp, execpath_len);
>+	}
>+
> 	/*
>-	 * Install LINUX_PLATFORM
>+	 * Prepare the canary for SSP.
> 	 */
>-	copyout(linux_platform, ((caddr_t)arginfo - linux_szplatform),
>-	    linux_szplatform);
>+	arc4rand(canary, sizeof(canary), 0);
>+	imgp->canary = (uintptr_t)arginfo -
>+	    roundup(execpath_len, sizeof(char *)) -
>+	    roundup(sizeof(canary), sizeof(char *));
>+	copyout(canary, (void *)imgp->canary, sizeof(canary));
> 
> 	/*
> 	 * If we have a valid auxargs ptr, prepare some room
>@@ -970,6 +968,13 @@
> SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxvmem, CTLFLAG_RW,
>     &linux32_maxvmem, 0, "");
> 
>+#if defined(DEBUG)
>+SYSCTL_PROC(_compat_linux32, OID_AUTO, debug,
>+            CTLTYPE_STRING | CTLFLAG_RW,
>+            0, 0, linux_sysctl_debug, "A",
>+            "Linux debugging control");
>+#endif
>+
> static void
> linux32_fixlimit(struct rlimit *rl, int which)
> {
>@@ -1006,14 +1011,14 @@
> 	.sv_size	= LINUX_SYS_MAXSYSCALL,
> 	.sv_table	= linux_sysent,
> 	.sv_mask	= 0,
>-	.sv_sigsize	= LINUX_SIGTBLSZ,
>-	.sv_sigtbl	= bsd_to_linux_signal,
>+	.sv_sigsize	= 0,
>+	.sv_sigtbl	= NULL,
> 	.sv_errsize	= ELAST + 1,
> 	.sv_errtbl	= bsd_to_linux_errno,
> 	.sv_transtrap	= translate_traps,
> 	.sv_fixup	= elf_linux_fixup,
> 	.sv_sendsig	= linux_sendsig,
>-	.sv_sigcode	= linux_sigcode,
>+	.sv_sigcode	= &_binary_linux32_locore_o_start,
> 	.sv_szsigcode	= &linux_szsigcode,
> 	.sv_prepsyscall	= NULL,
> 	.sv_name	= "Linux ELF32",
>@@ -1037,9 +1042,46 @@
> 	.sv_shared_page_base = LINUX32_SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= linux_schedtail,
>+	.sv_thread_detach = linux_thread_detach,
>+	.sv_trap	= NULL,
> };
>-INIT_SYSENTVEC(elf_sysvec, &elf_linux_sysvec);
> 
>+static void
>+linux_vdso_install(void *param)
>+{
>+
>+	linux_szsigcode = (&_binary_linux32_locore_o_end - 
>+	    &_binary_linux32_locore_o_start);
>+
>+	if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
>+		panic("Linux invalid vdso size\n");
>+
>+	__elfN(linux_vdso_fixup)(&elf_linux_sysvec);
>+
>+	linux_shared_page_obj = __elfN(linux_shared_page_init)
>+	    (&linux_shared_page_mapping);
>+
>+	__elfN(linux_vdso_reloc)(&elf_linux_sysvec, LINUX32_SHAREDPAGE);
>+
>+	bcopy(elf_linux_sysvec.sv_sigcode, linux_shared_page_mapping,
>+	    linux_szsigcode);
>+	elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
>+
>+	linux_kplatform = linux_shared_page_mapping +
>+	    (linux_platform - (caddr_t)LINUX32_SHAREDPAGE);
>+}
>+SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
>+    (sysinit_cfunc_t)linux_vdso_install, NULL);
>+
>+static void
>+linux_vdso_deinstall(void *param)
>+{
>+
>+	__elfN(linux_shared_page_fini)(linux_shared_page_obj);
>+};
>+SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
>+    (sysinit_cfunc_t)linux_vdso_deinstall, NULL);
>+
> static char GNU_ABI_VENDOR[] = "GNU";
> static int GNULINUX_ABI_DESC = 0;
> 
>@@ -1110,7 +1152,6 @@
> 	Elf32_Brandinfo **brandinfo;
> 	int error;
> 	struct linux_ioctl_handler **lihp;
>-	struct linux_device_handler **ldhp;
> 
> 	error = 0;
> 
>@@ -1123,19 +1164,8 @@
> 		if (error == 0) {
> 			SET_FOREACH(lihp, linux_ioctl_handler_set)
> 				linux_ioctl_register_handler(*lihp);
>-			SET_FOREACH(ldhp, linux_device_handler_set)
>-				linux_device_register_handler(*ldhp);
>-			mtx_init(&emul_lock, "emuldata lock", NULL, MTX_DEF);
>-			sx_init(&emul_shared_lock, "emuldata->shared lock");
> 			LIST_INIT(&futex_list);
> 			mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF);
>-			linux_exit_tag = EVENTHANDLER_REGISTER(process_exit,
>-			    linux_proc_exit, NULL, 1000);
>-			linux_exec_tag = EVENTHANDLER_REGISTER(process_exec,
>-			    linux_proc_exec, NULL, 1000);
>-			linux_szplatform = roundup(strlen(linux_platform) + 1,
>-			    sizeof(char *));
>-			linux_osd_jail_register();
> 			stclohz = (stathz ? stathz : hz);
> 			if (bootverbose)
> 				printf("Linux ELF exec handler installed\n");
>@@ -1156,14 +1186,7 @@
> 		if (error == 0) {
> 			SET_FOREACH(lihp, linux_ioctl_handler_set)
> 				linux_ioctl_unregister_handler(*lihp);
>-			SET_FOREACH(ldhp, linux_device_handler_set)
>-				linux_device_unregister_handler(*ldhp);
>-			mtx_destroy(&emul_lock);
>-			sx_destroy(&emul_shared_lock);
> 			mtx_destroy(&futex_mtx);
>-			EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
>-			EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
>-			linux_osd_jail_deregister();
> 			if (bootverbose)
> 				printf("Linux ELF exec handler removed\n");
> 		} else
>@@ -1170,9 +1193,9 @@
> 			printf("Could not deinstall ELF interpreter entry\n");
> 		break;
> 	default:
>-		return EOPNOTSUPP;
>+		return (EOPNOTSUPP);
> 	}
>-	return error;
>+	return (error);
> }
> 
> static moduledata_t linux_elf_mod = {
>@@ -1182,3 +1205,4 @@
> };
> 
> DECLARE_MODULE_TIED(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);
>+MODULE_DEPEND(linuxelf, linux_common, 1, 1, 1);
>Index: sys/amd64/linux32/linux32_vdso.lds.s
>===================================================================
>--- sys/amd64/linux32/linux32_vdso.lds.s	(revision 0)
>+++ sys/amd64/linux32/linux32_vdso.lds.s	(working copy)
>@@ -0,0 +1,66 @@
>+/*
>+ * Linker script for 32-bit vDSO.
>+ * Copied from Linux kernel arch/x86/vdso/vdso-layout.lds.S
>+ * and arch/x86/vdso/vdso32/vdso32.lds.S
>+ *
>+ * $FreeBSD$
>+ */
>+
>+SECTIONS
>+{
>+	. = . + SIZEOF_HEADERS;
>+
>+	.hash		: { *(.hash) }			:text
>+	.gnu.hash	: { *(.gnu.hash) }
>+	.dynsym		: { *(.dynsym) }
>+	.dynstr		: { *(.dynstr) }
>+	.gnu.version	: { *(.gnu.version) }
>+	.gnu.version_d	: { *(.gnu.version_d) }
>+	.gnu.version_r	: { *(.gnu.version_r) }
>+
>+	.note		: { *(.note.*) }		:text	:note
>+
>+	.eh_frame_hdr	: { *(.eh_frame_hdr) }		:text	:eh_frame_hdr
>+	.eh_frame	: { KEEP (*(.eh_frame)) }	:text
>+
>+	.dynamic	: { *(.dynamic) }		:text	:dynamic
>+
>+	.rodata		: { *(.rodata*) }		:text
>+	.data		: {
>+	      *(.data*)
>+	      *(.sdata*)
>+	      *(.got.plt) *(.got)
>+	      *(.gnu.linkonce.d.*)
>+	      *(.bss*)
>+	      *(.dynbss*)
>+	      *(.gnu.linkonce.b.*)
>+	}
>+
>+	.altinstructions	: { *(.altinstructions) }
>+	.altinstr_replacement	: { *(.altinstr_replacement) }
>+
>+	. = ALIGN(0x100);
>+	.text		: { *(.text*) }			:text	=0x90909090
>+}
>+
>+PHDRS
>+{
>+	text		PT_LOAD		FLAGS(5) FILEHDR PHDRS; /* PF_R|PF_X */
>+	dynamic		PT_DYNAMIC	FLAGS(4);		/* PF_R */
>+	note		PT_NOTE		FLAGS(4);		/* PF_R */
>+	eh_frame_hdr	PT_GNU_EH_FRAME;
>+}
>+
>+ENTRY(linux32_vsyscall);
>+
>+VERSION
>+{
>+	LINUX_2.5 {
>+	global:
>+		linux32_vsyscall;
>+		linux32_sigcode;
>+		linux32_rt_sigcode;
>+		linux_platform;
>+	local: *;
>+	};
>+}
>Index: sys/amd64/linux32/syscalls.master
>===================================================================
>--- sys/amd64/linux32/syscalls.master	(revision 285633)
>+++ sys/amd64/linux32/syscalls.master	(working copy)
>@@ -38,8 +38,7 @@
> ; #ifdef's, etc. may be included, and are copied to the output files.
> 
> 0	AUE_NULL	UNIMPL	setup
>-1	AUE_EXIT	NOPROTO	{ void sys_exit(int rval); } exit \
>-				    sys_exit_args void
>+1	AUE_EXIT	STD	{ void linux_exit(int rval); }
> 2	AUE_FORK	STD	{ int linux_fork(void); }
> 3	AUE_NULL	NOPROTO	{ int read(int fd, char *buf, \
> 				    u_int nbyte); }
>@@ -268,10 +267,10 @@
> 151	AUE_MUNLOCK	NOPROTO	{ int munlock(const void *addr, size_t len); }
> 152	AUE_MLOCKALL	NOPROTO	{ int mlockall(int how); }
> 153	AUE_MUNLOCKALL	NOPROTO	{ int munlockall(void); }
>-154	AUE_SCHED_SETPARAM	NOPROTO	{ int sched_setparam(pid_t pid, \
>-				    const struct sched_param *param); }
>-155	AUE_SCHED_GETPARAM	NOPROTO	{ int sched_getparam(pid_t pid, \
>-				    struct sched_param *param); }
>+154	AUE_SCHED_SETPARAM	STD	{ int linux_sched_setparam(l_pid_t pid, \
>+				    struct l_sched_param *param); }
>+155	AUE_SCHED_GETPARAM	STD	{ int linux_sched_getparam(l_pid_t pid, \
>+				    struct l_sched_param *param); }
> 156	AUE_SCHED_SETSCHEDULER	STD { int linux_sched_setscheduler( \
> 				    l_pid_t pid, l_int policy, \
> 				    struct l_sched_param *param); }
>@@ -319,7 +318,8 @@
> 				    l_siginfo_t *ptr, \
> 				    struct l_timeval *timeout, \
> 				    l_size_t sigsetsize); }
>-178	AUE_NULL	STD	{ int linux_rt_sigqueueinfo(void); }
>+178	AUE_NULL	STD	{ int linux_rt_sigqueueinfo(l_pid_t pid, l_int sig, \
>+				    l_siginfo_t *info); }
> 179	AUE_NULL	STD	{ int linux_rt_sigsuspend( \
> 				    l_sigset_t *newset, \
> 				    l_size_t sigsetsize); }
>@@ -430,9 +430,11 @@
> 251	AUE_NULL	UNIMPL
> 252	AUE_EXIT	STD	{ int linux_exit_group(int error_code); }
> 253	AUE_NULL	STD	{ int linux_lookup_dcookie(void); }
>-254	AUE_NULL	STD	{ int linux_epoll_create(void); }
>-255	AUE_NULL	STD	{ int linux_epoll_ctl(void); }
>-256	AUE_NULL	STD	{ int linux_epoll_wait(void); }
>+254	AUE_NULL	STD	{ int linux_epoll_create(l_int size); }
>+255	AUE_NULL	STD	{ int linux_epoll_ctl(l_int epfd, l_int op, l_int fd, \
>+					struct epoll_event *event); }
>+256	AUE_NULL	STD	{ int linux_epoll_wait(l_int epfd, struct epoll_event *events, \
>+					l_int maxevents, l_int timeout); }
> 257	AUE_NULL	STD	{ int linux_remap_file_pages(void); }
> 258	AUE_NULL	STD	{ int linux_set_tid_address(int *tidptr); }
> 259	AUE_NULL	STD	{ int linux_timer_create(clockid_t clock_id, \
>@@ -467,7 +469,8 @@
> 281	AUE_NULL	STD	{ int linux_mq_notify(void); }
> 282	AUE_NULL	STD	{ int linux_mq_getsetattr(void); }
> 283	AUE_NULL	STD	{ int linux_kexec_load(void); }
>-284	AUE_NULL	STD	{ int linux_waitid(void); }
>+284	AUE_WAIT6	STD	{ int linux_waitid(int idtype, l_pid_t id, l_siginfo_t *info, \
>+					int options, struct l_rusage *rusage); }
> 285	AUE_NULL	UNIMPL
> ; linux 2.6.11:
> 286	AUE_NULL	STD	{ int linux_add_key(void); }
>@@ -505,9 +508,12 @@
> 					char *buf, l_int bufsiz); }
> 306	AUE_FCHMODAT	STD	{ int linux_fchmodat(l_int dfd, const char *filename, \
> 					l_mode_t mode); }
>-307	AUE_FACCESSAT	STD	{ int linux_faccessat(l_int dfd, const char *filename, l_int amode, int flag); }
>-308	AUE_NULL	STD	{ int linux_pselect6(void); }
>-309	AUE_NULL	STD	{ int linux_ppoll(void); }
>+307	AUE_FACCESSAT	STD	{ int linux_faccessat(l_int dfd, const char *filename, l_int amode); }
>+308	AUE_SELECT	STD	{ int linux_pselect6(l_int nfds, l_fd_set *readfds,	\
>+					l_fd_set *writefds, l_fd_set *exceptfds,	\
>+					struct l_timespec *tsp, l_uintptr_t *sig); }
>+309	AUE_POLL	STD	{ int linux_ppoll(struct pollfd *fds, uint32_t nfds,	\
>+				    struct l_timespec *tsp, l_sigset_t *sset, l_size_t ssize); }
> 310	AUE_NULL	STD	{ int linux_unshare(void); }
> ; linux 2.6.17:
> 311	AUE_NULL	STD	{ int linux_set_robust_list(struct linux_robust_list_head *head, \
>@@ -522,22 +528,26 @@
> 317	AUE_NULL	STD	{ int linux_move_pages(void); }
> ; linux 2.6.19:
> 318	AUE_NULL	STD	{ int linux_getcpu(void); }
>-319	AUE_NULL	STD	{ int linux_epoll_pwait(void); }
>+319     AUE_NULL        STD     { int linux_epoll_pwait(l_int epfd, struct epoll_event *events, \
>+                                        l_int maxevents, l_int timeout, l_sigset_t *mask); }
> ; linux 2.6.22:
>-320	AUE_NULL	STD	{ int linux_utimensat(void); }
>+320	AUE_FUTIMESAT	STD	{ int linux_utimensat(l_int dfd, const char *pathname, \
>+					const struct l_timespec *times, l_int flags); }
> 321	AUE_NULL	STD	{ int linux_signalfd(void); }
> 322	AUE_NULL	STD	{ int linux_timerfd_create(void); }
>-323	AUE_NULL	STD	{ int linux_eventfd(void); }
>+323	AUE_NULL	STD	{ int linux_eventfd(l_uint initval); }
> ; linux 2.6.23:
>-324	AUE_NULL	STD	{ int linux_fallocate(void); }
>+324	AUE_NULL	STD	{ int linux_fallocate(l_int fd, l_int mode, \
>+				    l_loff_t offset, l_loff_t len); }
> ; linux 2.6.25:
> 325	AUE_NULL	STD	{ int linux_timerfd_settime(void); }
> 326	AUE_NULL	STD	{ int linux_timerfd_gettime(void); }
> ; linux 2.6.27:
> 327	AUE_NULL	STD	{ int linux_signalfd4(void); }
>-328	AUE_NULL	STD	{ int linux_eventfd2(void); }
>-329	AUE_NULL	STD	{ int linux_epoll_create1(void); }
>-330	AUE_NULL	STD	{ int linux_dup3(void); }
>+328	AUE_NULL	STD	{ int linux_eventfd2(l_uint initval, l_int flags); }
>+329	AUE_NULL	STD	{ int linux_epoll_create1(l_int flags); }
>+330	AUE_NULL	STD	{ int linux_dup3(l_int oldfd,		\
>+					l_int newfd, l_int flags); }
> 331	AUE_NULL	STD	{ int linux_pipe2(l_int *pipefds, l_int flags); }
> 332	AUE_NULL	STD	{ int linux_inotify_init1(void); }
> ; linux 2.6.30:
>@@ -547,17 +557,26 @@
> 335	AUE_NULL	STD	{ int linux_rt_tsigqueueinfo(void); }
> 336	AUE_NULL	STD	{ int linux_perf_event_open(void); }
> ; linux 2.6.33:
>-337	AUE_NULL	STD	{ int linux_recvmmsg(void); }
>+337	AUE_NULL	STD	{ int linux_recvmmsg(l_int s,			\
>+				    struct l_mmsghdr *msg, l_uint vlen,		\
>+				    l_uint flags, struct l_timespec *timeout); }
> 338	AUE_NULL	STD	{ int linux_fanotify_init(void); }
> 339	AUE_NULL	STD	{ int linux_fanotify_mark(void); }
> ; linux 2.6.36:
>-340	AUE_NULL	STD	{ int linux_prlimit64(void); }
>+340	AUE_NULL	STD	{ int linux_prlimit64(l_pid_t pid,	\
>+					l_uint resource,		\
>+					struct rlimit *new,		\
>+					struct rlimit *old); }
> ; later:
> 341	AUE_NULL	STD	{ int linux_name_to_handle_at(void); }
> 342	AUE_NULL	STD	{ int linux_open_by_handle_at(void); }
> 343	AUE_NULL	STD	{ int linux_clock_adjtime(void); }
>-344	AUE_NULL	STD	{ int linux_syncfs(void); }
>-345	AUE_NULL	STD	{ int linux_sendmmsg(void); }
>+344	AUE_SYNC	STD	{ int linux_syncfs(l_int fd); }
>+345	AUE_NULL	STD	{ int linux_sendmmsg(l_int s,			\
>+				    struct l_mmsghdr *msg, l_uint vlen,		\
>+				    l_uint flags); }
> 346	AUE_NULL	STD	{ int linux_setns(void); }
> 347	AUE_NULL	STD	{ int linux_process_vm_readv(void); }
> 348	AUE_NULL	STD	{ int linux_process_vm_writev(void); }
>+; please, keep this line at the end.
>+349	AUE_NULL	UNIMPL	nosys
>Index: sys/arm/arm/elf_machdep.c
>===================================================================
>--- sys/arm/arm/elf_machdep.c	(revision 285633)
>+++ sys/arm/arm/elf_machdep.c	(working copy)
>@@ -79,6 +79,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = syscallnames,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> static Elf32_Brandinfo freebsd_brand_info = {
>Index: sys/arm/arm/machdep.c
>===================================================================
>--- sys/arm/arm/machdep.c	(revision 285633)
>+++ sys/arm/arm/machdep.c	(working copy)
>@@ -259,10 +259,6 @@
> 		sigexit(td, SIGILL);
> 	}
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/*
> 	 * Build context to run handler in.  We invoke the handler
> 	 * directly, only returning via the trampoline.  Note the
>Index: sys/compat/ia32/ia32_sysvec.c
>===================================================================
>--- sys/compat/ia32/ia32_sysvec.c	(revision 285633)
>+++ sys/compat/ia32/ia32_sysvec.c	(working copy)
>@@ -139,6 +139,7 @@
> 	.sv_shared_page_base = FREEBSD32_SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(elf_ia32_sysvec, &ia32_freebsd_sysvec);
> 
>Index: sys/compat/linprocfs/linprocfs.c
>===================================================================
>--- sys/compat/linprocfs/linprocfs.c	(revision 285633)
>+++ sys/compat/linprocfs/linprocfs.c	(working copy)
>@@ -39,8 +39,6 @@
>  *	@(#)procfs_status.c	8.4 (Berkeley) 6/15/94
>  */
> 
>-#include "opt_compat.h"
>-
> #include <sys/cdefs.h>
> __FBSDID("$FreeBSD$");
> 
>@@ -53,6 +51,7 @@
> #include <sys/filedesc.h>
> #include <sys/jail.h>
> #include <sys/kernel.h>
>+#include <sys/limits.h>
> #include <sys/linker.h>
> #include <sys/lock.h>
> #include <sys/malloc.h>
>@@ -68,6 +67,7 @@
> #include <sys/smp.h>
> #include <sys/socket.h>
> #include <sys/sysctl.h>
>+#include <sys/sysent.h>
> #include <sys/systm.h>
> #include <sys/time.h>
> #include <sys/tty.h>
>@@ -78,7 +78,7 @@
> #include <sys/bus.h>
> 
> #include <net/if.h>
>-#include <net/vnet.h>
>+#include <net/if_types.h>
> 
> #include <vm/vm.h>
> #include <vm/vm_extern.h>
>@@ -98,11 +98,7 @@
> #include <machine/md_var.h>
> #endif /* __i386__ || __amd64__ */
> 
>-#ifdef COMPAT_FREEBSD32
>-#include <compat/freebsd32/freebsd32_util.h>
>-#endif
>-
>-#include <compat/linux/linux_ioctl.h>
>+#include <compat/linux/linux.h>
> #include <compat/linux/linux_mib.h>
> #include <compat/linux/linux_misc.h>
> #include <compat/linux/linux_util.h>
>@@ -754,6 +750,7 @@
> 	segsz_t lsize;
> 	struct thread *td2;
> 	struct sigacts *ps;
>+	l_sigset_t siglist, sigignore, sigcatch;
> 	int i;
> 
> 	PROC_LOCK(p);
>@@ -842,30 +839,26 @@
> 
> 	/*
> 	 * Signal masks
>-	 *
>-	 * We support up to 128 signals, while Linux supports 32,
>-	 * but we only define 32 (the same 32 as Linux, to boot), so
>-	 * just show the lower 32 bits of each mask. XXX hack.
>-	 *
>-	 * NB: on certain platforms (Sparc at least) Linux actually
>-	 * supports 64 signals, but this code is a long way from
>-	 * running on anything but i386, so ignore that for now.
> 	 */
> 	PROC_LOCK(p);
>-	sbuf_printf(sb, "SigPnd:\t%08x\n",	p->p_siglist.__bits[0]);
>-	/*
>-	 * I can't seem to find out where the signal mask is in
>-	 * relation to struct proc, so SigBlk is left unimplemented.
>-	 */
>-	sbuf_printf(sb, "SigBlk:\t%08x\n",	0); /* XXX */
>+	bsd_to_linux_sigset(&p->p_siglist, &siglist);
> 	ps = p->p_sigacts;
> 	mtx_lock(&ps->ps_mtx);
>-	sbuf_printf(sb, "SigIgn:\t%08x\n",	ps->ps_sigignore.__bits[0]);
>-	sbuf_printf(sb, "SigCgt:\t%08x\n",	ps->ps_sigcatch.__bits[0]);
>+	bsd_to_linux_sigset(&ps->ps_sigignore, &sigignore);
>+	bsd_to_linux_sigset(&ps->ps_sigcatch, &sigcatch);
> 	mtx_unlock(&ps->ps_mtx);
> 	PROC_UNLOCK(p);
> 
>+	sbuf_printf(sb, "SigPnd:\t%016jx\n",	siglist.__mask);
> 	/*
>+	 * XXX. SigBlk - target thread's signal mask, td_sigmask.
>+	 * To implement SigBlk pseudofs should support proc/tid dir entries.
>+	 */
>+	sbuf_printf(sb, "SigBlk:\t%016x\n",	0);
>+	sbuf_printf(sb, "SigIgn:\t%016jx\n",	sigignore.__mask);
>+	sbuf_printf(sb, "SigCgt:\t%016jx\n",	sigcatch.__mask);
>+
>+	/*
> 	 * Linux also prints the capability masks, but we don't have
> 	 * capabilities yet, and when we do get them they're likely to
> 	 * be meaningless to Linux programs, so we lie. XXX
>@@ -957,34 +950,22 @@
> static int
> linprocfs_doprocenviron(PFS_FILL_ARGS)
> {
>-	int ret;
> 
>-	PROC_LOCK(p);
>-	if ((ret = p_candebug(td, p)) != 0) {
>-		PROC_UNLOCK(p);
>-		return (ret);
>-	}
>-
> 	/*
> 	 * Mimic linux behavior and pass only processes with usermode
> 	 * address space as valid.  Return zero silently otherwize.
> 	 */
>-	if (p->p_vmspace == &vmspace0) {
>-		PROC_UNLOCK(p);
>+	if (p->p_vmspace == &vmspace0)
> 		return (0);
>-	}
> 
>-	if ((p->p_flag & P_SYSTEM) != 0) {
>-		PROC_UNLOCK(p);
>-		return (0);
>-	}
>+	return (proc_getenvv(td, p, sb));
>+}
> 
>-	PROC_UNLOCK(p);
>+static char l32_map_str[] = "%08lx-%08lx %s%s%s%s %08lx %02x:%02x %lu%s%s\n";
>+static char l64_map_str[] = "%016lx-%016lx %s%s%s%s %08lx %02x:%02x %lu%s%s\n";
>+static char vdso_str[] = "      [vdso]";
>+static char stack_str[] = "      [stack]";
> 
>-	ret = proc_getenvv(td, p, sb);
>-	return (ret);
>-}
>-
> /*
>  * Filler function for proc/pid/maps
>  */
>@@ -1000,6 +981,7 @@
> 	vm_prot_t e_prot;
> 	unsigned int last_timestamp;
> 	char *name = "", *freename = NULL;
>+	const char *l_map_str;
> 	ino_t ino;
> 	int ref_count, shadow_count, flags;
> 	int error;
>@@ -1019,6 +1001,11 @@
> 	vm = vmspace_acquire_ref(p);
> 	if (vm == NULL)
> 		return (ESRCH);
>+
>+	if (SV_CURPROC_FLAG(SV_LP64))
>+		l_map_str = l64_map_str;
>+	else
>+		l_map_str = l32_map_str;
> 	map = &vm->vm_map;
> 	vm_map_lock_read(map);
> 	for (entry = map->header.next; entry != &map->header;
>@@ -1061,6 +1048,11 @@
> 				VOP_GETATTR(vp, &vat, td->td_ucred);
> 				ino = vat.va_fileid;
> 				vput(vp);
>+			} else if (SV_PROC_ABI(p) == SV_ABI_LINUX) {
>+				if (e_start == p->p_sysent->sv_shared_page_base)
>+					name = vdso_str;
>+				if (e_end == p->p_sysent->sv_usrstack)
>+					name = stack_str;
> 			}
> 		} else {
> 			flags = 0;
>@@ -1072,8 +1064,7 @@
> 		 * format:
> 		 *  start, end, access, offset, major, minor, inode, name.
> 		 */
>-		error = sbuf_printf(sb,
>-		    "%08lx-%08lx %s%s%s%s %08lx %02x:%02x %lu%s%s\n",
>+		error = sbuf_printf(sb, l_map_str,
> 		    (u_long)e_start, (u_long)e_end,
> 		    (e_prot & VM_PROT_READ)?"r":"-",
> 		    (e_prot & VM_PROT_WRITE)?"w":"-",
>@@ -1110,6 +1101,35 @@
> }
> 
> /*
>+ * Criteria for interface name translation
>+ */
>+#define IFP_IS_ETH(ifp) (ifp->if_type == IFT_ETHER)
>+
>+static int
>+linux_ifname(struct ifnet *ifp, char *buffer, size_t buflen)
>+{
>+	struct ifnet *ifscan;
>+	int ethno;
>+
>+	IFNET_RLOCK_ASSERT();
>+
>+	/* Short-circuit non ethernet interfaces */
>+	if (!IFP_IS_ETH(ifp))
>+		return (strlcpy(buffer, ifp->if_xname, buflen));
>+
>+	/* Determine the (relative) unit number for ethernet interfaces */
>+	ethno = 0;
>+	TAILQ_FOREACH(ifscan, &V_ifnet, if_link) {
>+		if (ifscan == ifp)
>+			return (snprintf(buffer, buflen, "eth%d", ethno));
>+		if (IFP_IS_ETH(ifscan))
>+			ethno++;
>+	}
>+
>+	return (0);
>+}
>+
>+/*
>  * Filler function for proc/net/dev
>  */
> static int
>@@ -1256,8 +1276,6 @@
> 	return (0);
> }
> 
>-extern struct cdevsw *cdevsw[];
>-
> /*
>  * Filler function for proc/devices
>  */
>@@ -1352,7 +1370,53 @@
> 	return(0);
> }
> 
>+/*
>+ * Filler function for proc/pid/auxv
>+ */
>+static int
>+linprocfs_doauxv(PFS_FILL_ARGS)
>+{
>+	struct sbuf *asb;
>+	off_t buflen, resid;
>+	int error;
> 
>+	/*
>+	 * Mimic linux behavior and pass only processes with usermode
>+	 * address space as valid.  Return zero silently otherwize.
>+	 */
>+	if (p->p_vmspace == &vmspace0)
>+		return (0);
>+
>+	if (uio->uio_resid == 0)
>+		return (0);
>+	if (uio->uio_offset < 0 || uio->uio_resid < 0)
>+		return (EINVAL);
>+
>+	asb = sbuf_new_auto();
>+	if (asb == NULL)
>+		return (ENOMEM);
>+	error = proc_getauxv(td, p, asb);
>+	if (error == 0)
>+		error = sbuf_finish(asb);
>+
>+	resid = sbuf_len(asb) - uio->uio_offset;
>+	if (resid > uio->uio_resid)
>+		buflen = uio->uio_resid;
>+	else
>+		buflen = resid;
>+	if (buflen > IOSIZE_MAX)
>+		return (EINVAL);
>+	if (buflen > MAXPHYS)
>+		buflen = MAXPHYS;
>+	if (resid <= 0)
>+		return (0);
>+
>+	if (error == 0)
>+		error = uiomove(sbuf_data(asb) + uio->uio_offset, buflen, uio);
>+	sbuf_delete(asb);
>+	return (error);
>+}
>+
> /*
>  * Constructor
>  */
>@@ -1410,7 +1474,7 @@
> 	pfs_create_link(dir, "cwd", &linprocfs_doproccwd,
> 	    NULL, NULL, NULL, 0);
> 	pfs_create_file(dir, "environ", &linprocfs_doprocenviron,
>-	    NULL, NULL, NULL, PFS_RD);
>+	    NULL, &procfs_candebug, NULL, PFS_RD);
> 	pfs_create_link(dir, "exe", &procfs_doprocfile,
> 	    NULL, &procfs_notsystem, NULL, 0);
> 	pfs_create_file(dir, "maps", &linprocfs_doprocmaps,
>@@ -1427,6 +1491,8 @@
> 	    NULL, NULL, NULL, PFS_RD);
> 	pfs_create_link(dir, "fd", &linprocfs_dofdescfs,
> 	    NULL, NULL, NULL, 0);
>+	pfs_create_file(dir, "auxv", &linprocfs_doauxv,
>+	    NULL, &procfs_candebug, NULL, PFS_RD|PFS_RAWRD);
> 
> 	/* /proc/scsi/... */
> 	dir = pfs_create_dir(root, "scsi", NULL, NULL, NULL, 0);
>@@ -1472,7 +1538,11 @@
> }
> 
> PSEUDOFS(linprocfs, 1, 0);
>+#if defined(__amd64__)
>+MODULE_DEPEND(linprocfs, linux_common, 1, 1, 1);
>+#else
> MODULE_DEPEND(linprocfs, linux, 1, 1, 1);
>+#endif
> MODULE_DEPEND(linprocfs, procfs, 1, 1, 1);
> MODULE_DEPEND(linprocfs, sysvmsg, 1, 1, 1);
> MODULE_DEPEND(linprocfs, sysvsem, 1, 1, 1);
>Index: sys/compat/linsysfs/linsysfs.c
>===================================================================
>--- sys/compat/linsysfs/linsysfs.c	(revision 285633)
>+++ sys/compat/linsysfs/linsysfs.c	(working copy)
>@@ -61,12 +61,6 @@
> 
> #include <machine/bus.h>
> 
>-#include "opt_compat.h"
>-#ifdef COMPAT_LINUX32				/* XXX */
>-#include <machine/../linux32/linux.h>
>-#else
>-#include <machine/../linux/linux.h>
>-#endif
> #include <compat/linux/linux_ioctl.h>
> #include <compat/linux/linux_mib.h>
> #include <compat/linux/linux_util.h>
>@@ -281,4 +275,8 @@
> }
> 
> PSEUDOFS(linsysfs, 1, 0);
>+#if defined(__amd64__)
>+MODULE_DEPEND(linsysfs, linux_common, 1, 1, 1);
>+#else
> MODULE_DEPEND(linsysfs, linux, 1, 1, 1);
>+#endif
>Index: sys/compat/linux/check_error.d
>===================================================================
>--- sys/compat/linux/check_error.d	(revision 285633)
>+++ sys/compat/linux/check_error.d	(working copy)
>@@ -36,8 +36,8 @@
>  */
> 
> linuxulator*:dummy::not_implemented,
>-linuxulator*:emul:proc_exit:child_clear_tid_error,
>-linuxulator*:emul:proc_exit:futex_failed,
>+linuxulator*:emul:linux_thread_detach:child_clear_tid_error,
>+linuxulator*:emul:linux_thread_detach:futex_failed,
> linuxulator*:emul:linux_schedtail:copyout_error,
> linuxulator*:futex:futex_get:error,
> linuxulator*:futex:futex_sleep:requeue_error,
>Index: sys/compat/linux/check_internal_locks.d
>===================================================================
>--- sys/compat/linux/check_internal_locks.d	(revision 285633)
>+++ sys/compat/linux/check_internal_locks.d	(working copy)
>@@ -41,14 +41,9 @@
> 
> BEGIN
> {
>-	check["emul_lock"] = 0;
>-	check["emul_shared_rlock"] = 0;
>-	check["emul_shared_wlock"] = 0;
> 	check["futex_mtx"] = 0;
> }
> 
>-linuxulator*:locks:emul_lock:locked,
>-linuxulator*:locks:emul_shared_wlock:locked,
> linuxulator*:locks:futex_mtx:locked
> /check[probefunc] > 0/
> {
>@@ -57,9 +52,6 @@
> 	stack();
> }
> 
>-linuxulator*:locks:emul_lock:locked,
>-linuxulator*:locks:emul_shared_rlock:locked,
>-linuxulator*:locks:emul_shared_wlock:locked,
> linuxulator*:locks:futex_mtx:locked
> {
> 	++check[probefunc];
>@@ -69,9 +61,6 @@
> 	spec[probefunc] = speculation();
> }
> 
>-linuxulator*:locks:emul_lock:unlock,
>-linuxulator*:locks:emul_shared_rlock:unlock,
>-linuxulator*:locks:emul_shared_wlock:unlock,
> linuxulator*:locks:futex_mtx:unlock
> /check[probefunc] == 0/
> {
>@@ -82,9 +71,6 @@
> 	stack();
> }
> 
>-linuxulator*:locks:emul_lock:unlock,
>-linuxulator*:locks:emul_shared_rlock:unlock,
>-linuxulator*:locks:emul_shared_wlock:unlock,
> linuxulator*:locks:futex_mtx:unlock
> {
> 	discard(spec[probefunc]);
>@@ -95,27 +81,6 @@
> /* Timeout handling */
> 
> tick-10s
>-/spec["emul_lock"] != 0 && timestamp - ts["emul_lock"] >= 9999999000/
>-{
>-	commit(spec["emul_lock"]);
>-	spec["emul_lock"] = 0;
>-}
>-
>-tick-10s
>-/spec["emul_shared_wlock"] != 0 && timestamp - ts["emul_shared_wlock"] >= 9999999000/
>-{
>-	commit(spec["emul_shared_wlock"]);
>-	spec["emul_shared_wlock"] = 0;
>-}
>-
>-tick-10s
>-/spec["emul_shared_rlock"] != 0 && timestamp - ts["emul_shared_rlock"] >= 9999999000/
>-{
>-	commit(spec["emul_shared_rlock"]);
>-	spec["emul_shared_rlock"] = 0;
>-}
>-
>-tick-10s
> /spec["futex_mtx"] != 0 && timestamp - ts["futex_mtx"] >= 9999999000/
> {
> 	commit(spec["futex_mtx"]);
>Index: sys/compat/linux/linux.c
>===================================================================
>--- sys/compat/linux/linux.c	(revision 0)
>+++ sys/compat/linux/linux.c	(working copy)
>@@ -0,0 +1,205 @@
>+/*-
>+ * Copyright (c) 2015 Dmitry Chagin
>+ * 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 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 AUTHOR 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include <sys/param.h>
>+#include <sys/systm.h>
>+#include <sys/signalvar.h>
>+
>+#include <compat/linux/linux.h>
>+
>+
>+static int bsd_to_linux_sigtbl[LINUX_SIGTBLSZ] = {
>+	LINUX_SIGHUP,	/* SIGHUP */
>+	LINUX_SIGINT,	/* SIGINT */
>+	LINUX_SIGQUIT,	/* SIGQUIT */
>+	LINUX_SIGILL,	/* SIGILL */
>+	LINUX_SIGTRAP,	/* SIGTRAP */
>+	LINUX_SIGABRT,	/* SIGABRT */
>+	0,		/* SIGEMT */
>+	LINUX_SIGFPE,	/* SIGFPE */
>+	LINUX_SIGKILL,	/* SIGKILL */
>+	LINUX_SIGBUS,	/* SIGBUS */
>+	LINUX_SIGSEGV,	/* SIGSEGV */
>+	LINUX_SIGSYS,	/* SIGSYS */
>+	LINUX_SIGPIPE,	/* SIGPIPE */
>+	LINUX_SIGALRM,	/* SIGALRM */
>+	LINUX_SIGTERM,	/* SIGTERM */
>+	LINUX_SIGURG,	/* SIGURG */
>+	LINUX_SIGSTOP,	/* SIGSTOP */
>+	LINUX_SIGTSTP,	/* SIGTSTP */
>+	LINUX_SIGCONT,	/* SIGCONT */
>+	LINUX_SIGCHLD,	/* SIGCHLD */
>+	LINUX_SIGTTIN,	/* SIGTTIN */
>+	LINUX_SIGTTOU,	/* SIGTTOU */
>+	LINUX_SIGIO,	/* SIGIO */
>+	LINUX_SIGXCPU,	/* SIGXCPU */
>+	LINUX_SIGXFSZ,	/* SIGXFSZ */
>+	LINUX_SIGVTALRM,/* SIGVTALRM */
>+	LINUX_SIGPROF,	/* SIGPROF */
>+	LINUX_SIGWINCH,	/* SIGWINCH */
>+	0,		/* SIGINFO */
>+	LINUX_SIGUSR1,	/* SIGUSR1 */
>+	LINUX_SIGUSR2	/* SIGUSR2 */
>+};
>+
>+static int linux_to_bsd_sigtbl[LINUX_SIGTBLSZ] = {
>+	SIGHUP,		/* LINUX_SIGHUP */
>+	SIGINT,		/* LINUX_SIGINT */
>+	SIGQUIT,	/* LINUX_SIGQUIT */
>+	SIGILL,		/* LINUX_SIGILL */
>+	SIGTRAP,	/* LINUX_SIGTRAP */
>+	SIGABRT,	/* LINUX_SIGABRT */
>+	SIGBUS,		/* LINUX_SIGBUS */
>+	SIGFPE,		/* LINUX_SIGFPE */
>+	SIGKILL,	/* LINUX_SIGKILL */
>+	SIGUSR1,	/* LINUX_SIGUSR1 */
>+	SIGSEGV,	/* LINUX_SIGSEGV */
>+	SIGUSR2,	/* LINUX_SIGUSR2 */
>+	SIGPIPE,	/* LINUX_SIGPIPE */
>+	SIGALRM,	/* LINUX_SIGALRM */
>+	SIGTERM,	/* LINUX_SIGTERM */
>+	SIGBUS,		/* LINUX_SIGSTKFLT */
>+	SIGCHLD,	/* LINUX_SIGCHLD */
>+	SIGCONT,	/* LINUX_SIGCONT */
>+	SIGSTOP,	/* LINUX_SIGSTOP */
>+	SIGTSTP,	/* LINUX_SIGTSTP */
>+	SIGTTIN,	/* LINUX_SIGTTIN */
>+	SIGTTOU,	/* LINUX_SIGTTOU */
>+	SIGURG,		/* LINUX_SIGURG */
>+	SIGXCPU,	/* LINUX_SIGXCPU */
>+	SIGXFSZ,	/* LINUX_SIGXFSZ */
>+	SIGVTALRM,	/* LINUX_SIGVTALARM */
>+	SIGPROF,	/* LINUX_SIGPROF */
>+	SIGWINCH,	/* LINUX_SIGWINCH */
>+	SIGIO,		/* LINUX_SIGIO */
>+	/*
>+	 * FreeBSD does not have SIGPWR signal, map Linux SIGPWR signal
>+	 * to the first unused FreeBSD signal number. Since Linux supports
>+	 * signals from 1 to 64 we are ok here as our SIGRTMIN = 65.
>+	 */
>+	SIGRTMIN,	/* LINUX_SIGPWR */
>+	SIGSYS		/* LINUX_SIGSYS */
>+};
>+
>+/*
>+ * Map Linux RT signals to the FreeBSD RT signals.
>+ */
>+static inline int
>+linux_to_bsd_rt_signal(int sig)
>+{
>+
>+	return (SIGRTMIN + 1 + sig - LINUX_SIGRTMIN);
>+}
>+
>+static inline int
>+bsd_to_linux_rt_signal(int sig)
>+{
>+
>+	return (sig - SIGRTMIN - 1 + LINUX_SIGRTMIN);
>+}
>+
>+int
>+linux_to_bsd_signal(int sig)
>+{
>+
>+	KASSERT(sig > 0 && sig <= LINUX_SIGRTMAX, ("Invalid Linux signal\n"));
>+
>+	if (sig < LINUX_SIGRTMIN)
>+		return (linux_to_bsd_sigtbl[_SIG_IDX(sig)]);
>+
>+	return (linux_to_bsd_rt_signal(sig));
>+}
>+
>+int
>+bsd_to_linux_signal(int sig)
>+{
>+
>+	if (sig <= LINUX_SIGTBLSZ)
>+		return (bsd_to_linux_sigtbl[_SIG_IDX(sig)]);
>+	if (sig == SIGRTMIN)
>+		return (LINUX_SIGPWR);
>+
>+	return (bsd_to_linux_rt_signal(sig));
>+}
>+
>+int
>+linux_to_bsd_sigaltstack(int lsa)
>+{
>+	int bsa = 0;
>+
>+	if (lsa & LINUX_SS_DISABLE)
>+		bsa |= SS_DISABLE;
>+	/*
>+	 * Linux ignores SS_ONSTACK flag for ss
>+	 * parameter while FreeBSD prohibits it.
>+	 */
>+	return (bsa);
>+}
>+
>+int
>+bsd_to_linux_sigaltstack(int bsa)
>+{
>+	int lsa = 0;
>+
>+	if (bsa & SS_DISABLE)
>+		lsa |= LINUX_SS_DISABLE;
>+	if (bsa & SS_ONSTACK)
>+		lsa |= LINUX_SS_ONSTACK;
>+	return (lsa);
>+}
>+
>+void
>+linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss)
>+{
>+	int b, l;
>+
>+	SIGEMPTYSET(*bss);
>+	for (l = 1; l <= LINUX_SIGRTMAX; l++) {
>+		if (LINUX_SIGISMEMBER(*lss, l)) {
>+			b = linux_to_bsd_signal(l);
>+			if (b)
>+				SIGADDSET(*bss, b);
>+		}
>+	}
>+}
>+
>+void
>+bsd_to_linux_sigset(sigset_t *bss, l_sigset_t *lss)
>+{
>+	int b, l;
>+
>+	LINUX_SIGEMPTYSET(*lss);
>+	for (b = 1; b <= SIGRTMAX; b++) {
>+		if (SIGISMEMBER(*bss, b)) {
>+			l = bsd_to_linux_signal(b);
>+			if (l)
>+				LINUX_SIGADDSET(*lss, l);
>+		}
>+	}
>+}
>Index: sys/compat/linux/linux.h
>===================================================================
>--- sys/compat/linux/linux.h	(revision 0)
>+++ sys/compat/linux/linux.h	(working copy)
>@@ -0,0 +1,95 @@
>+/*-
>+ * Copyright (c) 2015 Dmitry Chagin
>+ * 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 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 AUTHOR 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.
>+ *
>+ * $FreeBSD$
>+ */
>+
>+#ifndef _LINUX_MI_H_
>+#define _LINUX_MI_H_
>+
>+/* sigaltstack */
>+#define	LINUX_SS_ONSTACK	1
>+#define	LINUX_SS_DISABLE	2
>+
>+int linux_to_bsd_sigaltstack(int lsa);
>+int bsd_to_linux_sigaltstack(int bsa);
>+
>+/* sigset */
>+typedef struct {
>+	uint64_t	__mask;
>+} l_sigset_t;
>+
>+/* primitives to manipulate sigset_t */
>+#define	LINUX_SIGEMPTYSET(set)		(set).__mask = 0
>+#define	LINUX_SIGISMEMBER(set, sig)	(1UL & ((set).__mask >> _SIG_IDX(sig)))
>+#define	LINUX_SIGADDSET(set, sig)	(set).__mask |= 1UL << _SIG_IDX(sig)
>+
>+void linux_to_bsd_sigset(l_sigset_t *, sigset_t *);
>+void bsd_to_linux_sigset(sigset_t *, l_sigset_t *);
>+
>+/* signaling */
>+#define	LINUX_SIGHUP		1
>+#define	LINUX_SIGINT		2
>+#define	LINUX_SIGQUIT		3
>+#define	LINUX_SIGILL		4
>+#define	LINUX_SIGTRAP		5
>+#define	LINUX_SIGABRT		6
>+#define	LINUX_SIGIOT		LINUX_SIGABRT
>+#define	LINUX_SIGBUS		7
>+#define	LINUX_SIGFPE		8
>+#define	LINUX_SIGKILL		9
>+#define	LINUX_SIGUSR1		10
>+#define	LINUX_SIGSEGV		11
>+#define	LINUX_SIGUSR2		12
>+#define	LINUX_SIGPIPE		13
>+#define	LINUX_SIGALRM		14
>+#define	LINUX_SIGTERM		15
>+#define	LINUX_SIGSTKFLT		16
>+#define	LINUX_SIGCHLD		17
>+#define	LINUX_SIGCONT		18
>+#define	LINUX_SIGSTOP		19
>+#define	LINUX_SIGTSTP		20
>+#define	LINUX_SIGTTIN		21
>+#define	LINUX_SIGTTOU		22
>+#define	LINUX_SIGURG		23
>+#define	LINUX_SIGXCPU		24
>+#define	LINUX_SIGXFSZ		25
>+#define	LINUX_SIGVTALRM		26
>+#define	LINUX_SIGPROF		27
>+#define	LINUX_SIGWINCH		28
>+#define	LINUX_SIGIO		29
>+#define	LINUX_SIGPOLL		LINUX_SIGIO
>+#define	LINUX_SIGPWR		30
>+#define	LINUX_SIGSYS		31
>+#define	LINUX_SIGTBLSZ		31
>+#define	LINUX_SIGRTMIN		32
>+#define	LINUX_SIGRTMAX		64
>+
>+#define LINUX_SIG_VALID(sig)	((sig) <= LINUX_SIGRTMAX && (sig) > 0)
>+
>+int linux_to_bsd_signal(int sig);
>+int bsd_to_linux_signal(int sig);
>+
>+#endif /* _LINUX_MI_H_ */
>Index: sys/compat/linux/linux_common.c
>===================================================================
>--- sys/compat/linux/linux_common.c	(revision 0)
>+++ sys/compat/linux/linux_common.c	(working copy)
>@@ -0,0 +1,93 @@
>+/*-
>+ * Copyright (c) 2014 Vassilis Laganakos
>+ * 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 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 AUTHOR 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include <sys/param.h>
>+#include <sys/systm.h>
>+#include <sys/exec.h>
>+#include <sys/imgact.h>
>+#include <sys/imgact_elf.h>
>+#include <sys/kernel.h>
>+#include <sys/malloc.h>
>+#include <sys/eventhandler.h>
>+#include <sys/sysctl.h>
>+
>+#include <compat/linux/linux_emul.h>
>+#include <compat/linux/linux_mib.h>
>+#include <compat/linux/linux_util.h>
>+
>+FEATURE(linuxulator_v4l, "V4L ioctl wrapper support in the linuxulator");
>+FEATURE(linuxulator_v4l2, "V4L2 ioctl wrapper support in the linuxulator");
>+
>+MODULE_VERSION(linux_common, 1);
>+
>+SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
>+
>+static eventhandler_tag linux_exec_tag;
>+static eventhandler_tag linux_thread_dtor_tag;
>+static eventhandler_tag	linux_exit_tag;
>+
>+
>+static int
>+linux_common_modevent(module_t mod, int type, void *data)
>+{
>+	struct linux_device_handler **ldhp;
>+
>+	switch(type) {
>+	case MOD_LOAD:
>+		linux_osd_jail_register();
>+		linux_exit_tag = EVENTHANDLER_REGISTER(process_exit,
>+		    linux_proc_exit, NULL, 1000);
>+		linux_exec_tag = EVENTHANDLER_REGISTER(process_exec,
>+		    linux_proc_exec, NULL, 1000);
>+		linux_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor,
>+		    linux_thread_dtor, NULL, EVENTHANDLER_PRI_ANY);
>+		SET_FOREACH(ldhp, linux_device_handler_set)
>+			linux_device_register_handler(*ldhp);
>+		break;
>+	case MOD_UNLOAD:
>+		linux_osd_jail_deregister();
>+		SET_FOREACH(ldhp, linux_device_handler_set)
>+			linux_device_unregister_handler(*ldhp);
>+		EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
>+		EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
>+		EVENTHANDLER_DEREGISTER(thread_dtor, linux_thread_dtor_tag);
>+		break;
>+	default:
>+		return (EOPNOTSUPP);
>+	}
>+	return (0);
>+}
>+
>+static moduledata_t linux_common_mod = {
>+	"linuxcommon",
>+	linux_common_modevent,
>+	0
>+};
>+
>+DECLARE_MODULE(linuxcommon, linux_common_mod, SI_SUB_EXEC, SI_ORDER_ANY);
>Index: sys/compat/linux/linux_emul.c
>===================================================================
>--- sys/compat/linux/linux_emul.c	(revision 285633)
>+++ sys/compat/linux/linux_emul.c	(working copy)
>@@ -1,5 +1,6 @@
> /*-
>  * Copyright (c) 2006 Roman Divacky
>+ * Copyright (c) 2013 Dmitry Chagin
>  * All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>@@ -29,364 +30,235 @@
> #include <sys/cdefs.h>
> __FBSDID("$FreeBSD$");
> 
>-#include "opt_compat.h"
>-#include "opt_kdtrace.h"
>-
> #include <sys/param.h>
> #include <sys/systm.h>
> #include <sys/imgact.h>
> #include <sys/kernel.h>
>+#include <sys/ktr.h>
> #include <sys/lock.h>
> #include <sys/malloc.h>
> #include <sys/mutex.h>
>-#include <sys/sdt.h>
> #include <sys/sx.h>
> #include <sys/proc.h>
> #include <sys/syscallsubr.h>
> #include <sys/sysent.h>
>-#include <sys/sysproto.h>
>-#include <sys/unistd.h>
> 
>-#ifdef COMPAT_LINUX32
>-#include <machine/../linux32/linux.h>
>-#include <machine/../linux32/linux32_proto.h>
>-#else
>-#include <machine/../linux/linux.h>
>-#include <machine/../linux/linux_proto.h>
>-#endif
>-
>-#include <compat/linux/linux_dtrace.h>
> #include <compat/linux/linux_emul.h>
>-#include <compat/linux/linux_futex.h>
> #include <compat/linux/linux_misc.h>
>+#include <compat/linux/linux_util.h>
> 
>-/**
>- * Special DTrace provider for the linuxulator.
>+
>+/*
>+ * This returns reference to the thread emuldata entry (if found)
>  *
>- * In this file we define the provider for the entire linuxulator. All
>- * modules (= files of the linuxulator) use it.
>- *
>- * We define a different name depending on the emulated bitsize, see
>- * ../../<ARCH>/linux{,32}/linux.h, e.g.:
>- *      native bitsize          = linuxulator
>- *      amd64, 32bit emulation  = linuxulator32
>+ * Hold PROC_LOCK when referencing emuldata from other threads.
>  */
>-LIN_SDT_PROVIDER_DEFINE(LINUX_DTRACE);
>-
>-/**
>- * Special DTrace module "locks", it covers some linuxulator internal
>- * locks.
>- */
>-LIN_SDT_PROBE_DEFINE1(locks, emul_lock, locked, "struct mtx *");
>-LIN_SDT_PROBE_DEFINE1(locks, emul_lock, unlock, "struct mtx *");
>-LIN_SDT_PROBE_DEFINE1(locks, emul_shared_rlock, locked, "struct sx *");
>-LIN_SDT_PROBE_DEFINE1(locks, emul_shared_rlock, unlock, "struct sx *");
>-LIN_SDT_PROBE_DEFINE1(locks, emul_shared_wlock, locked, "struct sx *");
>-LIN_SDT_PROBE_DEFINE1(locks, emul_shared_wlock, unlock, "struct sx *");
>-
>-/**
>- * DTrace probes in this module.
>- */
>-LIN_SDT_PROBE_DEFINE2(emul, em_find, entry, "struct proc *", "int");
>-LIN_SDT_PROBE_DEFINE0(emul, em_find, return);
>-LIN_SDT_PROBE_DEFINE3(emul, proc_init, entry, "struct thread *", "pid_t",
>-    "int");
>-LIN_SDT_PROBE_DEFINE0(emul, proc_init, create_thread);
>-LIN_SDT_PROBE_DEFINE0(emul, proc_init, fork);
>-LIN_SDT_PROBE_DEFINE0(emul, proc_init, exec);
>-LIN_SDT_PROBE_DEFINE0(emul, proc_init, return);
>-LIN_SDT_PROBE_DEFINE1(emul, proc_exit, entry, "struct proc *");
>-LIN_SDT_PROBE_DEFINE0(emul, proc_exit, futex_failed);
>-LIN_SDT_PROBE_DEFINE3(emul, proc_exit, reparent, "pid_t", "pid_t",
>-    "struct proc *");
>-LIN_SDT_PROBE_DEFINE1(emul, proc_exit, child_clear_tid_error, "int");
>-LIN_SDT_PROBE_DEFINE0(emul, proc_exit, return);
>-LIN_SDT_PROBE_DEFINE2(emul, proc_exec, entry, "struct proc *",
>-    "struct image_params *");
>-LIN_SDT_PROBE_DEFINE0(emul, proc_exec, return);
>-LIN_SDT_PROBE_DEFINE0(emul, linux_schedtail, entry);
>-LIN_SDT_PROBE_DEFINE1(emul, linux_schedtail, copyout_error, "int");
>-LIN_SDT_PROBE_DEFINE0(emul, linux_schedtail, return);
>-LIN_SDT_PROBE_DEFINE1(emul, linux_set_tid_address, entry, "int *");
>-LIN_SDT_PROBE_DEFINE0(emul, linux_set_tid_address, return);
>-LIN_SDT_PROBE_DEFINE2(emul, linux_kill_threads, entry, "struct thread *",
>-    "int");
>-LIN_SDT_PROBE_DEFINE1(emul, linux_kill_threads, kill, "pid_t");
>-LIN_SDT_PROBE_DEFINE0(emul, linux_kill_threads, return);
>-
>-struct sx	emul_shared_lock;
>-struct mtx	emul_lock;
>-
>-/* this returns locked reference to the emuldata entry (if found) */
> struct linux_emuldata *
>-em_find(struct proc *p, int locked)
>+em_find(struct thread *td)
> {
> 	struct linux_emuldata *em;
> 
>-	LIN_SDT_PROBE2(emul, em_find, entry, p, locked);
>+	em = td->td_emuldata;
> 
>-	if (locked == EMUL_DOLOCK)
>-		EMUL_LOCK(&emul_lock);
>+	return (em);
>+}
> 
>-	em = p->p_emuldata;
>+/*
>+ * This returns reference to the proc pemuldata entry (if found)
>+ *
>+ * Hold PROC_LOCK when referencing proc pemuldata from other threads.
>+ * Hold LINUX_PEM_LOCK wher referencing pemuldata members.
>+ */
>+struct linux_pemuldata *
>+pem_find(struct proc *p)
>+{
>+	struct linux_pemuldata *pem;
> 
>-	if (em == NULL && locked == EMUL_DOLOCK)
>-		EMUL_UNLOCK(&emul_lock);
>+	pem = p->p_emuldata;
> 
>-	LIN_SDT_PROBE1(emul, em_find, return, em);
>-	return (em);
>+	return (pem);
> }
> 
>-int
>-linux_proc_init(struct thread *td, pid_t child, int flags)
>+void
>+linux_proc_init(struct thread *td, struct thread *newtd, int flags)
> {
>-	struct linux_emuldata *em, *p_em;
>+	struct linux_emuldata *em;
>+	struct linux_pemuldata *pem;
>+	struct epoll_emuldata *emd;
> 	struct proc *p;
> 
>-	LIN_SDT_PROBE3(emul, proc_init, entry, td, child, flags);
>+	if (newtd != NULL) {
>+		p = newtd->td_proc;
> 
>-	if (child != 0) {
>-		/* fork or create a thread */
>-		em = malloc(sizeof *em, M_LINUX, M_WAITOK | M_ZERO);
>-		em->pid = child;
>-		em->pdeath_signal = 0;
>-		em->flags = 0;
>-		em->robust_futexes = NULL;
>+		/* non-exec call */
>+		em = malloc(sizeof(*em), M_TEMP, M_WAITOK | M_ZERO);
> 		if (flags & LINUX_CLONE_THREAD) {
>-			/* handled later in the code */
>-			LIN_SDT_PROBE0(emul, proc_init, create_thread);
>+			LINUX_CTR1(proc_init, "thread newtd(%d)",
>+			    newtd->td_tid);
>+
>+			em->em_tid = newtd->td_tid;
> 		} else {
>-			struct linux_emuldata_shared *s;
>+			LINUX_CTR1(proc_init, "fork newtd(%d)", p->p_pid);
> 
>-			LIN_SDT_PROBE0(emul, proc_init, fork);
>+			em->em_tid = p->p_pid;
> 
>-			s = malloc(sizeof *s, M_LINUX, M_WAITOK | M_ZERO);
>-			s->refs = 1;
>-			s->group_pid = child;
>-
>-			LIST_INIT(&s->threads);
>-			em->shared = s;
>+			pem = malloc(sizeof(*pem), M_LINUX, M_WAITOK | M_ZERO);
>+			sx_init(&pem->pem_sx, "lpemlk");
>+			p->p_emuldata = pem;
> 		}
>+		newtd->td_emuldata = em;
> 	} else {
>+		p = td->td_proc;
>+
> 		/* exec */
>-		LIN_SDT_PROBE0(emul, proc_init, exec);
>+		LINUX_CTR1(proc_init, "exec newtd(%d)", p->p_pid);
> 
> 		/* lookup the old one */
>-		em = em_find(td->td_proc, EMUL_DOLOCK);
>+		em = em_find(td);
> 		KASSERT(em != NULL, ("proc_init: emuldata not found in exec case.\n"));
>-	}
> 
>-	em->child_clear_tid = NULL;
>-	em->child_set_tid = NULL;
>+		em->em_tid = p->p_pid;
>+		em->flags = 0;
>+		em->pdeath_signal = 0;
>+		em->robust_futexes = NULL;
>+		em->child_clear_tid = NULL;
>+		em->child_set_tid = NULL;
> 
>-	/*
>-	 * allocate the shared struct only in clone()/fork cases in the case
>-	 * of clone() td = calling proc and child = pid of the newly created
>-	 * proc
>-	 */
>-	if (child != 0) {
>-		if (flags & LINUX_CLONE_THREAD) {
>-			/* lookup the parent */
>-			/* 
>-			 * we dont have to lock the p_em because
>-			 * its waiting for us in linux_clone so
>-			 * there is no chance of it changing the
>-			 * p_em->shared address
>-			 */
>-			p_em = em_find(td->td_proc, EMUL_DONTLOCK);
>-			KASSERT(p_em != NULL, ("proc_init: parent emuldata not found for CLONE_THREAD\n"));
>-			em->shared = p_em->shared;
>-			EMUL_SHARED_WLOCK(&emul_shared_lock);
>-			em->shared->refs++;
>-			EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>-		} else {
>-			/*
>-			 * handled earlier to avoid malloc(M_WAITOK) with
>-			 * rwlock held
>-			 */
>+		 /* epoll should be destroyed in a case of exec. */
>+		pem = pem_find(p);
>+		KASSERT(pem != NULL, ("proc_exit: proc emuldata not found.\n"));
>+
>+		if (pem->epoll != NULL) {
>+			emd = pem->epoll;
>+			pem->epoll = NULL;
>+			free(emd, M_EPOLL);
> 		}
>+	}
> 
>-		EMUL_SHARED_WLOCK(&emul_shared_lock);
>-		LIST_INSERT_HEAD(&em->shared->threads, em, threads);
>-		EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>-
>-		p = pfind(child);
>-		KASSERT(p != NULL, ("process not found in proc_init\n"));
>-		p->p_emuldata = em;
>-		PROC_UNLOCK(p);
>-	} else
>-		EMUL_UNLOCK(&emul_lock);
>-
>-	LIN_SDT_PROBE0(emul, proc_init, return);
>-	return (0);
> }
> 
>-void
>+void 
> linux_proc_exit(void *arg __unused, struct proc *p)
> {
>-	struct linux_emuldata *em;
>-	int error, shared_flags, shared_xstat;
>-	struct thread *td = FIRST_THREAD_IN_PROC(p);
>-	int *child_clear_tid;
>-	struct proc *q, *nq;
>+	struct linux_pemuldata *pem;
>+	struct epoll_emuldata *emd;
>+	struct thread *td = curthread;
> 
>-	if (__predict_true(p->p_sysent != &elf_linux_sysvec))
>+	if (__predict_false(SV_CURPROC_ABI() != SV_ABI_LINUX))
> 		return;
> 
>-	LIN_SDT_PROBE1(emul, proc_exit, entry, p);
>+	LINUX_CTR3(proc_exit, "thread(%d) proc(%d) p %p",
>+	    td->td_tid, p->p_pid, p);
> 
>-	release_futexes(p);
>+	pem = pem_find(p);
>+	if (pem == NULL)
>+		return;	
>+	(p->p_sysent->sv_thread_detach)(td);
> 
>-	/* find the emuldata */
>-	em = em_find(p, EMUL_DOLOCK);
>+	p->p_emuldata = NULL;
> 
>-	KASSERT(em != NULL, ("proc_exit: emuldata not found.\n"));
>-
>-	/* reparent all procs that are not a thread leader to initproc */
>-	if (em->shared->group_pid != p->p_pid) {
>-		LIN_SDT_PROBE3(emul, proc_exit, reparent,
>-		    em->shared->group_pid, p->p_pid, p);
>-
>-		child_clear_tid = em->child_clear_tid;
>-		EMUL_UNLOCK(&emul_lock);
>-		sx_xlock(&proctree_lock);
>-		wakeup(initproc);
>-		PROC_LOCK(p);
>-		proc_reparent(p, initproc);
>-		p->p_sigparent = SIGCHLD;
>-		PROC_UNLOCK(p);
>-		sx_xunlock(&proctree_lock);
>-	} else {
>-		child_clear_tid = em->child_clear_tid;
>-		EMUL_UNLOCK(&emul_lock);	
>+	if (pem->epoll != NULL) {
>+		emd = pem->epoll;
>+		pem->epoll = NULL;
>+		free(emd, M_EPOLL);
> 	}
> 
>-	EMUL_SHARED_WLOCK(&emul_shared_lock);
>-	shared_flags = em->shared->flags;
>-	shared_xstat = em->shared->xstat;
>-	LIST_REMOVE(em, threads);
>+	sx_destroy(&pem->pem_sx);
>+	free(pem, M_LINUX);
>+}
> 
>-	em->shared->refs--;
>-	if (em->shared->refs == 0) {
>-		EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>-		free(em->shared, M_LINUX);
>-	} else	
>-		EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>+int 
>+linux_common_execve(struct thread *td, struct image_args *eargs)
>+{
>+	struct linux_pemuldata *pem;
>+	struct epoll_emuldata *emd;
>+	struct vmspace *oldvmspace;
>+	struct linux_emuldata *em;
>+	struct proc *p;
>+	int error;
> 
>-	if ((shared_flags & EMUL_SHARED_HASXSTAT) != 0)
>-		p->p_xstat = shared_xstat;
>+	p = td->td_proc;
> 
>-	if (child_clear_tid != NULL) {
>-		struct linux_sys_futex_args cup;
>-		int null = 0;
>+	error = pre_execve(td, &oldvmspace);
>+	if (error != 0)
>+		return (error);
> 
>-		error = copyout(&null, child_clear_tid, sizeof(null));
>-		if (error) {
>-			LIN_SDT_PROBE1(emul, proc_exit,
>-			    child_clear_tid_error, error);
>+	error = kern_execve(td, eargs, NULL);
>+	post_execve(td, error, oldvmspace);
>+	if (error != 0)
>+		return (error);
> 
>-			free(em, M_LINUX);
>+	/*
>+	 * In a case of transition from Linux binary execing to
>+	 * FreeBSD binary we destroy linux emuldata thread & proc entries.
>+	 */
>+	if (SV_CURPROC_ABI() != SV_ABI_LINUX) {
>+		PROC_LOCK(p);
>+		em = em_find(td);
>+		KASSERT(em != NULL, ("proc_exec: thread emuldata not found.\n"));
>+		td->td_emuldata = NULL;
> 
>-			LIN_SDT_PROBE0(emul, proc_exit, return);
>-			return;
>-		}
>+		pem = pem_find(p);
>+		KASSERT(pem != NULL, ("proc_exec: proc pemuldata not found.\n"));
>+		p->p_emuldata = NULL;
>+		PROC_UNLOCK(p);
> 
>-		/* futexes stuff */
>-		cup.uaddr = child_clear_tid;
>-		cup.op = LINUX_FUTEX_WAKE;
>-		cup.val = 0x7fffffff;	/* Awake everyone */
>-		cup.timeout = NULL;
>-		cup.uaddr2 = NULL;
>-		cup.val3 = 0;
>-		error = linux_sys_futex(FIRST_THREAD_IN_PROC(p), &cup);
>-		/*
>-		 * this cannot happen at the moment and if this happens it
>-		 * probably means there is a user space bug
>-		 */
>-		if (error) {
>-			LIN_SDT_PROBE0(emul, proc_exit, futex_failed);
>-			printf(LMSG("futex stuff in proc_exit failed.\n"));
>+		if (pem->epoll != NULL) {
>+			emd = pem->epoll;
>+			pem->epoll = NULL;
>+			free(emd, M_EPOLL);
> 		}
>-	}
> 
>-	/* clean the stuff up */
>-	free(em, M_LINUX);
>-
>-	/* this is a little weird but rewritten from exit1() */
>-	sx_xlock(&proctree_lock);
>-	q = LIST_FIRST(&p->p_children);
>-	for (; q != NULL; q = nq) {
>-		nq = LIST_NEXT(q, p_sibling);
>-		if (q->p_flag & P_WEXIT)
>-			continue;
>-		if (__predict_false(q->p_sysent != &elf_linux_sysvec))
>-			continue;
>-		em = em_find(q, EMUL_DOLOCK);
>-		KASSERT(em != NULL, ("linux_reparent: emuldata not found: %i\n", q->p_pid));
>-		PROC_LOCK(q);
>-		if ((q->p_flag & P_WEXIT) == 0 && em->pdeath_signal != 0) {
>-			kern_psignal(q, em->pdeath_signal);
>-		}
>-		PROC_UNLOCK(q);
>-		EMUL_UNLOCK(&emul_lock);
>+		free(em, M_TEMP);
>+		free(pem, M_LINUX);
> 	}
>-	sx_xunlock(&proctree_lock);
>-
>-	LIN_SDT_PROBE0(emul, proc_exit, return);
>+	return (0);
> }
> 
>-/*
>- * This is used in a case of transition from FreeBSD binary execing to linux binary
>- * in this case we create linux emuldata proc entry with the pid of the currently running
>- * process.
>- */
> void 
> linux_proc_exec(void *arg __unused, struct proc *p, struct image_params *imgp)
> {
>-	if (__predict_false(imgp->sysent == &elf_linux_sysvec)) {
>-		LIN_SDT_PROBE2(emul, proc_exec, entry, p, imgp);
>+	struct thread *td = curthread;
>+	struct thread *othertd;
>+
>+	/*
>+	 * In a case of execing from linux binary properly detach
>+	 * other threads from the user space.
>+	 */
>+	if (__predict_false(SV_PROC_ABI(p) == SV_ABI_LINUX)) {
>+		FOREACH_THREAD_IN_PROC(p, othertd) {
>+			if (td != othertd)
>+				(p->p_sysent->sv_thread_detach)(othertd);
>+		}
> 	}
>-	if (__predict_false(imgp->sysent == &elf_linux_sysvec
>-	    && p->p_sysent != &elf_linux_sysvec))
>-		linux_proc_init(FIRST_THREAD_IN_PROC(p), p->p_pid, 0);
>-	if (__predict_false((p->p_sysent->sv_flags & SV_ABI_MASK) ==
>-	    SV_ABI_LINUX))
>-		/* Kill threads regardless of imgp->sysent value */
>-		linux_kill_threads(FIRST_THREAD_IN_PROC(p), SIGKILL);
>-	if (__predict_false(imgp->sysent != &elf_linux_sysvec
>-	    && p->p_sysent == &elf_linux_sysvec)) {
>-		struct linux_emuldata *em;
> 
>-		/* 
>-		 * XXX:There's a race because here we assign p->p_emuldata NULL
>-		 * but the process is still counted as linux one for a short
>- 		 * time so some other process might reference it and try to
>- 		 * access its p->p_emuldata and panicing on a NULL reference.
>-		 */
>-		em = em_find(p, EMUL_DONTLOCK);
>+	/*
>+	 * In a case of execing to linux binary we create linux
>+	 * emuldata thread entry.
>+	 */
>+	if (__predict_false((imgp->sysent->sv_flags & SV_ABI_MASK) ==
>+	    SV_ABI_LINUX)) {
> 
>-		KASSERT(em != NULL, ("proc_exec: emuldata not found.\n"));
>+		if (SV_PROC_ABI(p) == SV_ABI_LINUX)
>+			linux_proc_init(td, NULL, 0);
>+		else
>+			linux_proc_init(td, td, 0);
>+	}
>+}
> 
>-		EMUL_SHARED_WLOCK(&emul_shared_lock);
>-		LIST_REMOVE(em, threads);
>+void
>+linux_thread_dtor(void *arg __unused, struct thread *td)
>+{
>+	struct linux_emuldata *em;
> 
>-		PROC_LOCK(p);
>-		p->p_emuldata = NULL;
>-		PROC_UNLOCK(p);
>+	em = em_find(td);
>+	if (em == NULL)
>+		return;
>+	td->td_emuldata = NULL;
> 
>-		em->shared->refs--;
>-		if (em->shared->refs == 0) {
>-			EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>-			free(em->shared, M_LINUX);
>-		} else
>-			EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>+	LINUX_CTR1(thread_dtor, "thread(%d)", em->em_tid);
> 
>-		free(em, M_LINUX);
>-	}
>-
>-	if (__predict_false(imgp->sysent == &elf_linux_sysvec)) {
>-		LIN_SDT_PROBE0(emul, proc_exec, return);
>-	}
>+	free(em, M_TEMP);
> }
> 
> void
>@@ -399,76 +271,15 @@
> 
> 	p = td->td_proc;
> 
>-	LIN_SDT_PROBE1(emul, linux_schedtail, entry, p);
>-
>-	/* find the emuldata */
>-	em = em_find(p, EMUL_DOLOCK);
>-
>-	KASSERT(em != NULL, ("linux_schedtail: emuldata not found.\n"));
>+	em = em_find(td);
>+	KASSERT(em != NULL, ("linux_schedtail: thread emuldata not found.\n"));
> 	child_set_tid = em->child_set_tid;
>-	EMUL_UNLOCK(&emul_lock);
> 
> 	if (child_set_tid != NULL) {
>-		error = copyout(&p->p_pid, (int *)child_set_tid,
>-		    sizeof(p->p_pid));
>-
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(emul, linux_schedtail, copyout_error,
>-			    error);
>-		}
>-	}
>-
>-	LIN_SDT_PROBE0(emul, linux_schedtail, return);
>-
>-	return;
>+		error = copyout(&em->em_tid, child_set_tid,
>+		    sizeof(em->em_tid));
>+		LINUX_CTR4(schedtail, "thread(%d) %p stored %d error %d",
>+		    td->td_tid, child_set_tid, em->em_tid, error);
>+	} else
>+		LINUX_CTR1(schedtail, "thread(%d)", em->em_tid);
> }
>-
>-int
>-linux_set_tid_address(struct thread *td, struct linux_set_tid_address_args *args)
>-{
>-	struct linux_emuldata *em;
>-
>-	LIN_SDT_PROBE1(emul, linux_set_tid_address, entry, args->tidptr);
>-
>-	/* find the emuldata */
>-	em = em_find(td->td_proc, EMUL_DOLOCK);
>-
>-	KASSERT(em != NULL, ("set_tid_address: emuldata not found.\n"));
>-
>-	em->child_clear_tid = args->tidptr;
>-	td->td_retval[0] = td->td_proc->p_pid;
>-
>-	EMUL_UNLOCK(&emul_lock);
>-
>-	LIN_SDT_PROBE0(emul, linux_set_tid_address, return);
>-	return 0;
>-}
>-
>-void
>-linux_kill_threads(struct thread *td, int sig)
>-{
>-	struct linux_emuldata *em, *td_em, *tmp_em;
>-	struct proc *sp;
>-
>-	LIN_SDT_PROBE2(emul, linux_kill_threads, entry, td, sig);
>-
>-	td_em = em_find(td->td_proc, EMUL_DONTLOCK);
>-
>-	KASSERT(td_em != NULL, ("linux_kill_threads: emuldata not found.\n"));
>-
>-	EMUL_SHARED_RLOCK(&emul_shared_lock);
>-	LIST_FOREACH_SAFE(em, &td_em->shared->threads, threads, tmp_em) {
>-		if (em->pid == td_em->pid)
>-			continue;
>-
>-		sp = pfind(em->pid);
>-		if ((sp->p_flag & P_WEXIT) == 0)
>-			kern_psignal(sp, sig);
>-		PROC_UNLOCK(sp);
>-
>-		LIN_SDT_PROBE1(emul, linux_kill_threads, kill, em->pid);
>-	}
>-	EMUL_SHARED_RUNLOCK(&emul_shared_lock);
>-
>-	LIN_SDT_PROBE0(emul, linux_kill_threads, return);
>-}
>Index: sys/compat/linux/linux_emul.h
>===================================================================
>--- sys/compat/linux/linux_emul.h	(revision 285633)
>+++ sys/compat/linux/linux_emul.h	(working copy)
>@@ -1,5 +1,6 @@
> /*-
>  * Copyright (c) 2006 Roman Divacky
>+ * Copyright (c) 2013 Dmitry Chagin
>  * All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>@@ -31,91 +32,50 @@
> #ifndef _LINUX_EMUL_H_
> #define	_LINUX_EMUL_H_
> 
>-#define EMUL_SHARED_HASXSTAT	0x01
>-
>-struct linux_emuldata_shared {
>-	int	refs;
>-	int	flags;
>-	int	xstat;
>-	pid_t	group_pid;
>-
>-	LIST_HEAD(, linux_emuldata) threads; /* head of list of linux threads */
>-};
>-
> /*
>  * modeled after similar structure in NetBSD
>  * this will be extended as we need more functionality
>  */
> struct linux_emuldata {
>-	pid_t	pid;
>-
> 	int    *child_set_tid;	/* in clone(): Child's TID to set on clone */
> 	int    *child_clear_tid;/* in clone(): Child's TID to clear on exit */
> 
>-	struct linux_emuldata_shared *shared;
>-
> 	int	pdeath_signal;		/* parent death signal */
>-	int	flags;			/* different emuldata flags */
>+	int	flags;			/* thread emuldata flags */
>+	int	em_tid;			/* thread id */
> 
> 	struct	linux_robust_list_head	*robust_futexes;
>-
>-	LIST_ENTRY(linux_emuldata) threads;	/* list of linux threads */
> };
> 
>-struct linux_emuldata	*em_find(struct proc *, int locked);
>+struct linux_emuldata	*em_find(struct thread *);
> 
>-/*
>- * DTrace probes for locks should be fired after locking and before releasing
>- * to prevent races (to provide data/function stability in dtrace, see the
>- * output of "dtrace -v ..." and the corresponding dtrace docs).
>- */
>-#define	EMUL_LOCK(l)		do { \
>-				    mtx_lock(l); \
>-				    LIN_SDT_PROBE1(locks, emul_lock, \
>-					locked, l); \
>-				} while (0)
>-#define	EMUL_UNLOCK(l)		do { \
>-				    LIN_SDT_PROBE1(locks, emul_lock, \
>-					unlock, l); \
>-				    mtx_unlock(l); \
>-				} while (0)
>+/* thread emuldata flags */
>+#define	LINUX_THREAD_DETACHED	0x00000002
> 
>-#define	EMUL_SHARED_RLOCK(l)	do { \
>-				    sx_slock(l); \
>-				    LIN_SDT_PROBE1(locks, emul_shared_rlock, \
>-					locked, l); \
>-				} while (0)
>-#define	EMUL_SHARED_RUNLOCK(l)	do { \
>-				    LIN_SDT_PROBE1(locks, emul_shared_rlock, \
>-					unlock, l); \
>-				    sx_sunlock(l); \
>-				} while (0)
>-#define	EMUL_SHARED_WLOCK(l)	do { \
>-				    sx_xlock(l); \
>-				    LIN_SDT_PROBE1(locks, emul_shared_wlock, \
>-					locked, l); \
>-				} while (0)
>-#define	EMUL_SHARED_WUNLOCK(l)	do { \
>-				    LIN_SDT_PROBE1(locks, emul_shared_wlock, \
>-					unlock, l); \
>-				    sx_xunlock(l); \
>-				} while (0)
>+void	linux_proc_init(struct thread *, struct thread *, int);
>+void	linux_proc_exit(void *, struct proc *);
>+void	linux_schedtail(struct thread *);
>+void	linux_proc_exec(void *, struct proc *, struct image_params *);
>+void	linux_thread_dtor(void *arg __unused, struct thread *);
>+void	linux_thread_detach(struct thread *);
>+int	linux_common_execve(struct thread *, struct image_args *);
> 
>-/* for em_find use */
>-#define	EMUL_DOLOCK		1
>-#define	EMUL_DONTLOCK		0
>-
>-/* emuldata flags */
>+/* process emuldata flags */
> #define	LINUX_XDEPR_REQUEUEOP	0x00000001	/* uses deprecated
> 						   futex REQUEUE op*/
>+#define	LINUX_XUNSUP_EPOLL	0x00000002	/* unsupported epoll events */
> 
>-int	linux_proc_init(struct thread *, pid_t, int);
>-void	linux_proc_exit(void *, struct proc *);
>-void	linux_schedtail(struct thread *);
>-void	linux_proc_exec(void *, struct proc *, struct image_params *);
>-void	linux_kill_threads(struct thread *, int);
>+struct linux_pemuldata {
>+	uint32_t	flags;		/* process emuldata flags */
>+	struct sx	pem_sx;		/* lock for this struct */
>+	void		*epoll;		/* epoll data */
>+};
> 
>-extern struct sx	emul_shared_lock;
>-extern struct mtx	emul_lock;
>+#define	LINUX_PEM_XLOCK(p)	sx_xlock(&(p)->pem_sx)
>+#define	LINUX_PEM_XUNLOCK(p)	sx_xunlock(&(p)->pem_sx)
>+#define	LINUX_PEM_SLOCK(p)	sx_slock(&(p)->pem_sx)
>+#define	LINUX_PEM_SUNLOCK(p)	sx_sunlock(&(p)->pem_sx)
> 
>+struct linux_pemuldata	*pem_find(struct proc *);
>+
> #endif	/* !_LINUX_EMUL_H_ */
>Index: sys/compat/linux/linux_event.c
>===================================================================
>--- sys/compat/linux/linux_event.c	(revision 0)
>+++ sys/compat/linux/linux_event.c	(working copy)
>@@ -0,0 +1,883 @@
>+/*-
>+ * Copyright (c) 2007 Roman Divacky
>+ * Copyright (c) 2014 Dmitry Chagin
>+ * 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 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 AUTHOR 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include "opt_compat.h"
>+
>+#include <sys/param.h>
>+#include <sys/systm.h>
>+#include <sys/imgact.h>
>+#include <sys/kernel.h>
>+#include <sys/limits.h>
>+#include <sys/lock.h>
>+#include <sys/mutex.h>
>+#include <sys/capability.h>
>+#include <sys/types.h>
>+#include <sys/user.h>
>+#include <sys/file.h>
>+#include <sys/filedesc.h>
>+#include <sys/errno.h>
>+#include <sys/event.h>
>+#include <sys/poll.h>
>+#include <sys/proc.h>
>+#include <sys/selinfo.h>
>+#include <sys/sx.h>
>+#include <sys/syscallsubr.h>
>+#include <sys/timespec.h>
>+
>+#ifdef COMPAT_LINUX32
>+#include <machine/../linux32/linux.h>
>+#include <machine/../linux32/linux32_proto.h>
>+#else
>+#include <machine/../linux/linux.h>
>+#include <machine/../linux/linux_proto.h>
>+#endif
>+
>+#include <compat/linux/linux_emul.h>
>+#include <compat/linux/linux_event.h>
>+#include <compat/linux/linux_file.h>
>+#include <compat/linux/linux_util.h>
>+
>+/*
>+ * epoll defines 'struct epoll_event' with the field 'data' as 64 bits
>+ * on all architectures. But on 32 bit architectures BSD 'struct kevent' only
>+ * has 32 bit opaque pointer as 'udata' field. So we can't pass epoll supplied
>+ * data verbatuim. Therefore we allocate 64-bit memory block to pass
>+ * user supplied data for every file descriptor.
>+ */
>+
>+typedef uint64_t	epoll_udata_t;
>+
>+struct epoll_emuldata {
>+	uint32_t	fdc;		/* epoll udata max index */
>+	epoll_udata_t	udata[1];	/* epoll user data vector */
>+};
>+
>+#define	EPOLL_DEF_SZ		16
>+#define	EPOLL_SIZE(fdn)			\
>+	(sizeof(struct epoll_emuldata)+(fdn) * sizeof(epoll_udata_t))
>+
>+struct epoll_event {
>+	uint32_t	events;
>+	epoll_udata_t	data;
>+}
>+#if defined(__amd64__)
>+__attribute__((packed))
>+#endif
>+;
>+
>+#define	LINUX_MAX_EVENTS	(INT_MAX / sizeof(struct epoll_event))
>+
>+static void	epoll_fd_install(struct thread *td, int fd, epoll_udata_t udata);
>+static int	epoll_to_kevent(struct thread *td, struct file *epfp,
>+		    int fd, struct epoll_event *l_event, int *kev_flags,
>+		    struct kevent *kevent, int *nkevents);
>+static void	kevent_to_epoll(struct kevent *kevent, struct epoll_event *l_event);
>+static int	epoll_kev_copyout(void *arg, struct kevent *kevp, int count);
>+static int	epoll_kev_copyin(void *arg, struct kevent *kevp, int count);
>+static int	epoll_delete_event(struct thread *td, struct file *epfp,
>+		    int fd, int filter);
>+static int	epoll_delete_all_events(struct thread *td, struct file *epfp,
>+		    int fd);
>+
>+struct epoll_copyin_args {
>+	struct kevent	*changelist;
>+};
>+
>+struct epoll_copyout_args {
>+	struct epoll_event	*leventlist;
>+	struct proc		*p;
>+	uint32_t		count;
>+	int			error;
>+};
>+
>+/* eventfd */
>+typedef uint64_t	eventfd_t;
>+
>+static fo_rdwr_t	eventfd_read;
>+static fo_rdwr_t	eventfd_write;
>+static fo_truncate_t	eventfd_truncate;
>+static fo_ioctl_t	eventfd_ioctl;
>+static fo_poll_t	eventfd_poll;
>+static fo_kqfilter_t	eventfd_kqfilter;
>+static fo_stat_t	eventfd_stat;
>+static fo_close_t	eventfd_close;
>+
>+static struct fileops eventfdops = {
>+	.fo_read = eventfd_read,
>+	.fo_write = eventfd_write,
>+	.fo_truncate = eventfd_truncate,
>+	.fo_ioctl = eventfd_ioctl,
>+	.fo_poll = eventfd_poll,
>+	.fo_kqfilter = eventfd_kqfilter,
>+	.fo_stat = eventfd_stat,
>+	.fo_close = eventfd_close,
>+	.fo_chmod = invfo_chmod,
>+	.fo_chown = invfo_chown,
>+	.fo_sendfile = invfo_sendfile,
>+	.fo_flags = DFLAG_PASSABLE
>+};
>+
>+static void	filt_eventfddetach(struct knote *kn);
>+static int	filt_eventfdread(struct knote *kn, long hint);
>+static int	filt_eventfdwrite(struct knote *kn, long hint);
>+
>+static struct filterops eventfd_rfiltops = {
>+	.f_isfd = 1,
>+	.f_detach = filt_eventfddetach,
>+	.f_event = filt_eventfdread
>+};
>+static struct filterops eventfd_wfiltops = {
>+	.f_isfd = 1,
>+	.f_detach = filt_eventfddetach,
>+	.f_event = filt_eventfdwrite
>+};
>+
>+struct eventfd {
>+	eventfd_t	efd_count;
>+	uint32_t	efd_flags;
>+	struct selinfo	efd_sel;
>+	struct mtx	efd_lock;
>+};
>+
>+static int	eventfd_create(struct thread *td, uint32_t initval, int flags);
>+
>+
>+static void
>+epoll_fd_install(struct thread *td, int fd, epoll_udata_t udata)
>+{
>+	struct linux_pemuldata *pem;
>+	struct epoll_emuldata *emd;
>+	struct proc *p;
>+
>+	p = td->td_proc;
>+
>+	pem = pem_find(p);
>+	KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
>+
>+	LINUX_PEM_XLOCK(pem);
>+	if (pem->epoll == NULL) {
>+		emd = malloc(EPOLL_SIZE(fd), M_EPOLL, M_WAITOK);
>+		emd->fdc = fd;
>+		pem->epoll = emd;
>+	} else {
>+		emd = pem->epoll;
>+		if (fd > emd->fdc) {
>+			emd = realloc(emd, EPOLL_SIZE(fd), M_EPOLL, M_WAITOK);
>+			emd->fdc = fd;
>+			pem->epoll = emd;
>+		}
>+	}
>+	emd->udata[fd] = udata;
>+	LINUX_PEM_XUNLOCK(pem);
>+}
>+
>+static int
>+epoll_create_common(struct thread *td, int flags)
>+{
>+	int error;
>+
>+	error = kern_kqueue(td, flags);
>+	if (error)
>+		return (error);
>+
>+	epoll_fd_install(td, EPOLL_DEF_SZ, 0);
>+
>+	return (0);
>+}
>+
>+int
>+linux_epoll_create(struct thread *td, struct linux_epoll_create_args *args)
>+{
>+
>+	/*
>+	 * args->size is unused. Linux just tests it
>+	 * and then forgets it as well.
>+	 */
>+	if (args->size <= 0)
>+		return (EINVAL);
>+
>+	return (epoll_create_common(td, 0));
>+}
>+
>+int
>+linux_epoll_create1(struct thread *td, struct linux_epoll_create1_args *args)
>+{
>+	int flags;
>+
>+	if ((args->flags & ~(LINUX_O_CLOEXEC)) != 0)
>+		return (EINVAL);
>+
>+	flags = 0;
>+	if ((args->flags & LINUX_O_CLOEXEC) != 0)
>+		flags |= O_CLOEXEC;
>+
>+	return (epoll_create_common(td, flags));
>+}
>+
>+/* Structure converting function from epoll to kevent. */
>+static int
>+epoll_to_kevent(struct thread *td, struct file *epfp,
>+    int fd, struct epoll_event *l_event, int *kev_flags,
>+    struct kevent *kevent, int *nkevents)
>+{
>+	uint32_t levents = l_event->events;
>+	struct linux_pemuldata *pem;
>+	struct proc *p;
>+
>+	/* flags related to how event is registered */
>+	if ((levents & LINUX_EPOLLONESHOT) != 0)
>+		*kev_flags |= EV_ONESHOT;
>+	if ((levents & LINUX_EPOLLET) != 0)
>+		*kev_flags |= EV_CLEAR;
>+	if ((levents & LINUX_EPOLLERR) != 0)
>+		*kev_flags |= EV_ERROR;
>+	if ((levents & LINUX_EPOLLRDHUP) != 0)
>+		*kev_flags |= EV_EOF;
>+
>+	/* flags related to what event is registered */
>+	if ((levents & LINUX_EPOLL_EVRD) != 0) {
>+		EV_SET(kevent++, fd, EVFILT_READ, *kev_flags, 0, 0, 0);
>+		++(*nkevents);
>+	}
>+	if ((levents & LINUX_EPOLL_EVWR) != 0) {
>+		EV_SET(kevent++, fd, EVFILT_WRITE, *kev_flags, 0, 0, 0);
>+		++(*nkevents);
>+	}
>+
>+	if ((levents & ~(LINUX_EPOLL_EVSUP)) != 0) {
>+		p = td->td_proc;
>+
>+		pem = pem_find(p);
>+		KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
>+		KASSERT(pem->epoll != NULL, ("epoll proc epolldata not found.\n"));
>+
>+		LINUX_PEM_XLOCK(pem);
>+		if ((pem->flags & LINUX_XUNSUP_EPOLL) == 0) {
>+			pem->flags |= LINUX_XUNSUP_EPOLL;
>+			LINUX_PEM_XUNLOCK(pem);
>+			linux_msg(td, "epoll_ctl unsupported flags: 0x%x\n",
>+			    levents);
>+		} else
>+			LINUX_PEM_XUNLOCK(pem);
>+		return (EINVAL);
>+	}
>+
>+	return (0);
>+}
>+
>+/* 
>+ * Structure converting function from kevent to epoll. In a case
>+ * this is called on error in registration we store the error in
>+ * event->data and pick it up later in linux_epoll_ctl().
>+ */
>+static void
>+kevent_to_epoll(struct kevent *kevent, struct epoll_event *l_event)
>+{
>+
>+	if ((kevent->flags & EV_ERROR) != 0) {
>+		l_event->events = LINUX_EPOLLERR;
>+		return;
>+	}
>+
>+	switch (kevent->filter) {
>+	case EVFILT_READ:
>+		l_event->events = LINUX_EPOLLIN|LINUX_EPOLLRDNORM|LINUX_EPOLLPRI;
>+		if ((kevent->flags & EV_EOF) != 0)
>+			l_event->events |= LINUX_EPOLLRDHUP;
>+	break;
>+	case EVFILT_WRITE:
>+		l_event->events = LINUX_EPOLLOUT|LINUX_EPOLLWRNORM;
>+	break;
>+	}
>+}
>+
>+/* 
>+ * Copyout callback used by kevent. This converts kevent
>+ * events to epoll events and copies them back to the
>+ * userspace. This is also called on error on registering
>+ * of the filter.
>+ */
>+static int
>+epoll_kev_copyout(void *arg, struct kevent *kevp, int count)
>+{
>+	struct epoll_copyout_args *args;
>+	struct linux_pemuldata *pem;
>+	struct epoll_emuldata *emd;
>+	struct epoll_event *eep;
>+	int error, fd, i;
>+
>+	args = (struct epoll_copyout_args*) arg;
>+	eep = malloc(sizeof(*eep) * count, M_EPOLL, M_WAITOK | M_ZERO);
>+
>+	pem = pem_find(args->p);
>+	KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
>+	LINUX_PEM_SLOCK(pem);
>+	emd = pem->epoll;
>+	KASSERT(emd != NULL, ("epoll proc epolldata not found.\n"));
>+
>+	for (i = 0; i < count; i++) {
>+		kevent_to_epoll(&kevp[i], &eep[i]);
>+
>+		fd = kevp[i].ident;
>+		KASSERT(fd <= emd->fdc, ("epoll user data vector"
>+						    " is too small.\n"));
>+		eep[i].data = emd->udata[fd];
>+	}
>+	LINUX_PEM_SUNLOCK(pem);
>+
>+	error = copyout(eep, args->leventlist, count * sizeof(*eep));
>+	if (error == 0) {
>+		args->leventlist += count;
>+		args->count += count;
>+	} else if (args->error == 0)
>+		args->error = error;
>+
>+	free(eep, M_EPOLL);
>+	return (error);
>+}
>+
>+/*
>+ * Copyin callback used by kevent. This copies already
>+ * converted filters from kernel memory to the kevent 
>+ * internal kernel memory. Hence the memcpy instead of
>+ * copyin.
>+ */
>+static int
>+epoll_kev_copyin(void *arg, struct kevent *kevp, int count)
>+{
>+	struct epoll_copyin_args *args;
>+
>+	args = (struct epoll_copyin_args*) arg;
>+	
>+	memcpy(kevp, args->changelist, count * sizeof(*kevp));
>+	args->changelist += count;
>+
>+	return (0);
>+}
>+
>+/*
>+ * Load epoll filter, convert it to kevent filter
>+ * and load it into kevent subsystem.
>+ */
>+int
>+linux_epoll_ctl(struct thread *td, struct linux_epoll_ctl_args *args)
>+{
>+	struct file *epfp, *fp;
>+	struct epoll_copyin_args ciargs;
>+	struct kevent kev[2];
>+	struct kevent_copyops k_ops = { &ciargs,
>+					NULL,
>+					epoll_kev_copyin};
>+	struct epoll_event le;
>+	cap_rights_t rights;
>+	int kev_flags;
>+	int nchanges = 0;
>+	int error;
>+
>+	if (args->op != LINUX_EPOLL_CTL_DEL) {
>+		error = copyin(args->event, &le, sizeof(le));
>+		if (error != 0)
>+			return (error);
>+	}
>+
>+	error = fget(td, args->epfd,
>+	    cap_rights_init(&rights, CAP_KQUEUE_CHANGE), &epfp);
>+	if (error != 0)
>+		return (error);
>+	if (epfp->f_type != DTYPE_KQUEUE)
>+		goto leave1;
>+
>+	 /* Protect user data vector from incorrectly supplied fd. */
>+	error = fget(td, args->fd, cap_rights_init(&rights, CAP_POLL_EVENT), &fp);
>+	if (error != 0)
>+		goto leave1;
>+
>+	/* Linux disallows spying on himself */
>+	if (epfp == fp) {
>+		error = EINVAL;
>+		goto leave0;
>+	}
>+
>+	ciargs.changelist = kev;
>+
>+	switch (args->op) {
>+	case LINUX_EPOLL_CTL_MOD:
>+		/*
>+		 * We don't memorize which events were set for this FD
>+		 * on this level, so just delete all we could have set:
>+		 * EVFILT_READ and EVFILT_WRITE, ignoring any errors
>+		 */
>+		error = epoll_delete_all_events(td, epfp, args->fd);
>+		if (error)
>+			goto leave0;
>+		/* FALLTHROUGH */
>+
>+	case LINUX_EPOLL_CTL_ADD:
>+			kev_flags = EV_ADD | EV_ENABLE;
>+		break;
>+
>+	case LINUX_EPOLL_CTL_DEL:
>+		/* CTL_DEL means unregister this fd with this epoll */
>+		error = epoll_delete_all_events(td, epfp, args->fd);
>+		goto leave0;
>+
>+	default:
>+		error = EINVAL;
>+		goto leave0;
>+	}
>+
>+	error = epoll_to_kevent(td, epfp, args->fd, &le, &kev_flags,
>+	    kev, &nchanges);
>+	if (error)
>+		goto leave0;
>+
>+	epoll_fd_install(td, args->fd, le.data);
>+
>+	error = kern_kevent_fp(td, epfp, nchanges, 0, &k_ops, NULL);
>+
>+leave0:
>+	fdrop(fp, td);
>+
>+leave1:
>+	fdrop(epfp, td);
>+	return (error);
>+}
>+
>+/*
>+ * Wait for a filter to be triggered on the epoll file descriptor.
>+ */
>+static int
>+linux_epoll_wait_common(struct thread *td, int epfd, struct epoll_event *events,
>+    int maxevents, int timeout, sigset_t *uset)
>+{
>+	struct file *epfp;
>+	struct timespec ts, *tsp;
>+	cap_rights_t rights;
>+	struct epoll_copyout_args coargs;
>+	struct kevent_copyops k_ops = { &coargs,
>+					epoll_kev_copyout,
>+					NULL};
>+	int error;
>+
>+	if (maxevents <= 0 || maxevents > LINUX_MAX_EVENTS)
>+		return (EINVAL);
>+
>+	if (uset != NULL) {
>+		error = kern_sigprocmask(td, SIG_SETMASK, uset,
>+		    &td->td_oldsigmask, 0);
>+		if (error != 0)
>+			return (error);
>+		td->td_pflags |= TDP_OLDMASK;
>+		/*
>+		 * Make sure that ast() is called on return to
>+		 * usermode and TDP_OLDMASK is cleared, restoring old
>+		 * sigmask.
>+		 */
>+		thread_lock(td);
>+		td->td_flags |= TDF_ASTPENDING;
>+		thread_unlock(td);
>+	}
>+
>+	error = fget(td, epfd,
>+	    cap_rights_init(&rights, CAP_KQUEUE_EVENT), &epfp);
>+	if (error != 0)
>+		return (error);
>+
>+	coargs.leventlist = events;
>+	coargs.p = td->td_proc;
>+	coargs.count = 0;
>+	coargs.error = 0;
>+
>+	if (timeout != -1) {
>+		if (timeout < 0) {
>+			error = EINVAL;
>+			goto leave;
>+		}
>+		/* Convert from milliseconds to timespec. */
>+		ts.tv_sec = timeout / 1000;
>+		ts.tv_nsec = (timeout % 1000) * 1000000;
>+		tsp = &ts;
>+	} else {
>+		tsp = NULL;
>+	}
>+
>+	error = kern_kevent_fp(td, epfp, 0, maxevents, &k_ops, tsp);
>+	if (error == 0 && coargs.error != 0)
>+		error = coargs.error;
>+
>+	/* 
>+	 * kern_kevent might return ENOMEM which is not expected from epoll_wait.
>+	 * Maybe we should translate that but I don't think it matters at all.
>+	 */
>+	if (error == 0)
>+		td->td_retval[0] = coargs.count;
>+leave:
>+	fdrop(epfp, td);
>+	return (error);
>+}
>+
>+int
>+linux_epoll_wait(struct thread *td, struct linux_epoll_wait_args *args)
>+{
>+
>+	return (linux_epoll_wait_common(td, args->epfd, args->events,
>+	    args->maxevents, args->timeout, NULL));
>+}
>+
>+int
>+linux_epoll_pwait(struct thread *td, struct linux_epoll_pwait_args *args)
>+{
>+	sigset_t mask, *pmask;
>+	l_sigset_t lmask;
>+	int error;
>+
>+	if (args->mask != NULL) {
>+		error = copyin(args->mask, &lmask, sizeof(l_sigset_t));
>+		if (error != 0)
>+			return (error);
>+		linux_to_bsd_sigset(&lmask, &mask);
>+		pmask = &mask;
>+	} else
>+		pmask = NULL;
>+	return (linux_epoll_wait_common(td, args->epfd, args->events,
>+	    args->maxevents, args->timeout, pmask));
>+}
>+
>+static int
>+epoll_delete_event(struct thread *td, struct file *epfp, int fd, int filter)
>+{
>+	struct epoll_copyin_args ciargs;
>+	struct kevent kev;
>+	struct kevent_copyops k_ops = { &ciargs,
>+					NULL,
>+					epoll_kev_copyin};
>+	int error;
>+
>+	ciargs.changelist = &kev;
>+	EV_SET(&kev, fd, filter, EV_DELETE | EV_DISABLE, 0, 0, 0);
>+
>+	error = kern_kevent_fp(td, epfp, 1, 0, &k_ops, NULL);
>+
>+	/*
>+	 * here we ignore ENONT, because we don't keep track of events here
>+	 */
>+	if (error == ENOENT)
>+		error = 0;
>+	return (error);
>+}
>+
>+static int
>+epoll_delete_all_events(struct thread *td, struct file *epfp, int fd)
>+{
>+	int error1, error2;
>+
>+	error1 = epoll_delete_event(td, epfp, fd, EVFILT_READ);
>+	error2 = epoll_delete_event(td, epfp, fd, EVFILT_WRITE);
>+
>+	/* report any errors we got */
>+	return (error1 == 0 ? error2 : error1);
>+}
>+
>+static int
>+eventfd_create(struct thread *td, uint32_t initval, int flags)
>+{
>+	struct filedesc *fdp;
>+	struct eventfd *efd;
>+	struct file *fp;
>+	int fflags, fd, error;
>+
>+	fflags = 0;
>+	if ((flags & LINUX_O_CLOEXEC) != 0)
>+		fflags |= O_CLOEXEC;
>+
>+	fdp = td->td_proc->p_fd;
>+	error = falloc(td, &fp, &fd, fflags);
>+	if (error)
>+		return (error);
>+
>+	efd = malloc(sizeof(*efd), M_EPOLL, M_WAITOK | M_ZERO);
>+	efd->efd_flags = flags;
>+	efd->efd_count = initval;
>+	mtx_init(&efd->efd_lock, "eventfd", NULL, MTX_DEF);
>+
>+	knlist_init_mtx(&efd->efd_sel.si_note, &efd->efd_lock);
>+
>+	fflags = FREAD | FWRITE; 
>+	if ((flags & LINUX_O_NONBLOCK) != 0)
>+		fflags |= FNONBLOCK;
>+
>+	finit(fp, fflags, DTYPE_LINUXEFD, efd, &eventfdops);
>+	fdrop(fp, td);
>+
>+	td->td_retval[0] = fd;
>+	return (error);
>+}
>+
>+int
>+linux_eventfd(struct thread *td, struct linux_eventfd_args *args)
>+{
>+
>+	return (eventfd_create(td, args->initval, 0));
>+}
>+
>+int
>+linux_eventfd2(struct thread *td, struct linux_eventfd2_args *args)
>+{
>+
>+	if ((args->flags & ~(LINUX_O_CLOEXEC|LINUX_O_NONBLOCK|LINUX_EFD_SEMAPHORE)) != 0)
>+		return (EINVAL);
>+
>+	return (eventfd_create(td, args->initval, args->flags));
>+}
>+
>+static int
>+eventfd_close(struct file *fp, struct thread *td)
>+{
>+	struct eventfd *efd;
>+
>+	efd = fp->f_data;
>+	if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
>+		return (EBADF);
>+
>+	seldrain(&efd->efd_sel);
>+	knlist_destroy(&efd->efd_sel.si_note);
>+
>+	fp->f_ops = &badfileops;
>+	mtx_destroy(&efd->efd_lock);
>+	free(efd, M_EPOLL);
>+
>+	return (0);
>+}
>+
>+static int
>+eventfd_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
>+	int flags, struct thread *td)
>+{
>+	struct eventfd *efd;
>+	eventfd_t count;
>+	int error;
>+
>+	efd = fp->f_data;
>+	if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
>+		return (EBADF);
>+
>+	if (uio->uio_resid < sizeof(eventfd_t))
>+		return (EINVAL);
>+
>+	error = 0;
>+	mtx_lock(&efd->efd_lock);
>+retry:
>+	if (efd->efd_count == 0) {
>+		if ((efd->efd_flags & LINUX_O_NONBLOCK) != 0) {
>+			mtx_unlock(&efd->efd_lock);
>+			return (EAGAIN);
>+		}
>+		error = mtx_sleep(&efd->efd_count, &efd->efd_lock, PCATCH, "lefdrd", 0);
>+		if (error == 0)
>+			goto retry;
>+	}
>+	if (error == 0) {
>+		if ((efd->efd_flags & LINUX_EFD_SEMAPHORE) != 0) {
>+			count = 1;
>+			--efd->efd_count;
>+		} else {
>+			count = efd->efd_count;
>+			efd->efd_count = 0;
>+		}
>+		KNOTE_LOCKED(&efd->efd_sel.si_note, 0);
>+		selwakeup(&efd->efd_sel);
>+		wakeup(&efd->efd_count);
>+		mtx_unlock(&efd->efd_lock);
>+		error = uiomove(&count, sizeof(eventfd_t), uio);
>+	} else
>+		mtx_unlock(&efd->efd_lock);
>+
>+	return (error);
>+}
>+
>+static int
>+eventfd_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
>+	 int flags, struct thread *td)
>+{
>+	struct eventfd *efd;
>+	eventfd_t count;
>+	int error;
>+
>+	efd = fp->f_data;
>+	if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
>+		return (EBADF);
>+
>+	if (uio->uio_resid < sizeof(eventfd_t))
>+		return (EINVAL);
>+
>+	error = uiomove(&count, sizeof(eventfd_t), uio);
>+	if (error)
>+		return (error);
>+	if (count == UINT64_MAX)
>+		return (EINVAL);
>+
>+	mtx_lock(&efd->efd_lock);
>+retry:
>+	if (UINT64_MAX - efd->efd_count <= count) {
>+		if ((efd->efd_flags & LINUX_O_NONBLOCK) != 0) {
>+			mtx_unlock(&efd->efd_lock);
>+			return (EAGAIN);
>+		}
>+		error = mtx_sleep(&efd->efd_count, &efd->efd_lock,
>+		    PCATCH, "lefdwr", 0);
>+		if (error == 0)
>+			goto retry;
>+	}
>+	if (error == 0) {
>+		efd->efd_count += count;
>+		KNOTE_LOCKED(&efd->efd_sel.si_note, 0);
>+		selwakeup(&efd->efd_sel);
>+		wakeup(&efd->efd_count);
>+	}
>+	mtx_unlock(&efd->efd_lock);
>+
>+	return (error);
>+}
>+
>+static int
>+eventfd_poll(struct file *fp, int events, struct ucred *active_cred,
>+	struct thread *td)
>+{
>+	struct eventfd *efd;
>+	int revents = 0;
>+
>+	efd = fp->f_data;
>+	if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
>+		return (POLLERR);
>+
>+	mtx_lock(&efd->efd_lock);
>+	if ((events & (POLLIN|POLLRDNORM)) && efd->efd_count > 0)
>+		revents |= events & (POLLIN|POLLRDNORM);
>+	if ((events & (POLLOUT|POLLWRNORM)) && UINT64_MAX - 1 > efd->efd_count)
>+		revents |= events & (POLLOUT|POLLWRNORM);
>+	if (revents == 0)
>+		selrecord(td, &efd->efd_sel);
>+	mtx_unlock(&efd->efd_lock);
>+
>+	return (revents);
>+}
>+
>+/*ARGSUSED*/
>+static int
>+eventfd_kqfilter(struct file *fp, struct knote *kn)
>+{
>+	struct eventfd *efd;
>+
>+	efd = fp->f_data;
>+	if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
>+		return (EINVAL);
>+
>+	mtx_lock(&efd->efd_lock);
>+	switch (kn->kn_filter) {
>+	case EVFILT_READ:
>+		kn->kn_fop = &eventfd_rfiltops;
>+		break;
>+	case EVFILT_WRITE:
>+		kn->kn_fop = &eventfd_wfiltops;
>+		break;
>+	default:
>+		mtx_unlock(&efd->efd_lock);
>+		return (EINVAL);
>+	}
>+
>+	kn->kn_hook = efd;
>+	knlist_add(&efd->efd_sel.si_note, kn, 1);
>+	mtx_unlock(&efd->efd_lock);
>+
>+	return (0);
>+}
>+
>+static void
>+filt_eventfddetach(struct knote *kn)
>+{
>+	struct eventfd *efd = kn->kn_hook;
>+
>+	mtx_lock(&efd->efd_lock);
>+	knlist_remove(&efd->efd_sel.si_note, kn, 1);
>+	mtx_unlock(&efd->efd_lock);
>+}
>+
>+/*ARGSUSED*/
>+static int
>+filt_eventfdread(struct knote *kn, long hint)
>+{
>+	struct eventfd *efd = kn->kn_hook;
>+	int ret;
>+
>+	mtx_assert(&efd->efd_lock, MA_OWNED);
>+	ret = (efd->efd_count > 0);
>+
>+	return (ret);
>+}
>+
>+/*ARGSUSED*/
>+static int
>+filt_eventfdwrite(struct knote *kn, long hint)
>+{
>+	struct eventfd *efd = kn->kn_hook;
>+	int ret;
>+
>+	mtx_assert(&efd->efd_lock, MA_OWNED);
>+	ret = (UINT64_MAX - 1 > efd->efd_count);
>+
>+	return (ret);
>+}
>+
>+/*ARGSUSED*/
>+static int
>+eventfd_truncate(struct file *fp, off_t length, struct ucred *active_cred,
>+	struct thread *td)
>+{
>+
>+	return (ENXIO);
>+}
>+
>+/*ARGSUSED*/
>+static int
>+eventfd_ioctl(struct file *fp, u_long cmd, void *data,
>+	struct ucred *active_cred, struct thread *td)
>+{
>+
>+	return (ENXIO);
>+}
>+
>+/*ARGSUSED*/
>+static int
>+eventfd_stat(struct file *fp, struct stat *st, struct ucred *active_cred,
>+	struct thread *td)
>+{
>+
>+	return (ENXIO);
>+}
>Index: sys/compat/linux/linux_event.h
>===================================================================
>--- sys/compat/linux/linux_event.h	(revision 0)
>+++ sys/compat/linux/linux_event.h	(working copy)
>@@ -0,0 +1,60 @@
>+/*-
>+ * Copyright (c) 2007 Roman Divacky
>+ * Copyright (c) 2014 Dmitry Chagin
>+ * 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 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 AUTHOR 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.
>+ *
>+ * $FreeBSD$
>+ */
>+
>+#ifndef _LINUX_EVENT_H_
>+#define	_LINUX_EVENT_H_
>+
>+#define	LINUX_EPOLLIN		0x001
>+#define	LINUX_EPOLLPRI		0x002
>+#define	LINUX_EPOLLOUT		0x004
>+#define	LINUX_EPOLLRDNORM	0x040
>+#define	LINUX_EPOLLRDBAND	0x080
>+#define	LINUX_EPOLLWRNORM	0x100
>+#define	LINUX_EPOLLWRBAND	0x200
>+#define	LINUX_EPOLLMSG		0x400
>+#define	LINUX_EPOLLERR		0x008
>+#define	LINUX_EPOLLHUP		0x010
>+#define	LINUX_EPOLLRDHUP	0x2000
>+#define	LINUX_EPOLLWAKEUP	1u<<29
>+#define	LINUX_EPOLLONESHOT	1u<<30
>+#define	LINUX_EPOLLET		1u<<31
>+
>+#define	LINUX_EPOLL_EVRD	(LINUX_EPOLLIN|LINUX_EPOLLRDNORM	\
>+		|LINUX_EPOLLHUP|LINUX_EPOLLERR|LINUX_EPOLLPRI)
>+#define	LINUX_EPOLL_EVWR	(LINUX_EPOLLOUT|LINUX_EPOLLWRNORM)
>+#define	LINUX_EPOLL_EVSUP	(LINUX_EPOLLET|LINUX_EPOLLONESHOT	\
>+		|LINUX_EPOLL_EVRD|LINUX_EPOLL_EVWR|LINUX_EPOLLRDHUP)
>+
>+#define	LINUX_EPOLL_CTL_ADD	1
>+#define	LINUX_EPOLL_CTL_DEL	2
>+#define	LINUX_EPOLL_CTL_MOD	3
>+
>+#define	LINUX_EFD_SEMAPHORE	(1 << 0)
>+
>+#endif	/* !_LINUX_EVENT_H_ */
>Index: sys/compat/linux/linux_file.c
>===================================================================
>--- sys/compat/linux/linux_file.c	(revision 285633)
>+++ sys/compat/linux/linux_file.c	(working copy)
>@@ -239,6 +239,7 @@
>     return error;
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_llseek(struct thread *td, struct linux_llseek_args *args)
> {
>@@ -277,6 +278,7 @@
> 	lda.count = 1;
> 	return linux_getdents(td, &lda);
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> /*
>  * Note that linux_getdents(2) and linux_getdents64(2) have the same
>@@ -371,8 +373,8 @@
> 
> 	buflen = max(LINUX_DIRBLKSIZ, nbytes);
> 	buflen = min(buflen, MAXBSIZE);
>-	buf = malloc(buflen, M_TEMP, M_WAITOK);
>-	lbuf = malloc(LINUX_MAXRECLEN, M_TEMP, M_WAITOK | M_ZERO);
>+	buf = malloc(buflen, M_LINUX, M_WAITOK);
>+	lbuf = malloc(LINUX_MAXRECLEN, M_LINUX, M_WAITOK | M_ZERO);
> 	vn_lock(vp, LK_SHARED | LK_RETRY);
> 
> 	aiov.iov_base = buf;
>@@ -523,8 +525,8 @@
> 	VOP_UNLOCK(vp, 0);
> 	foffset_unlock(fp, off, 0);
> 	fdrop(fp, td);
>-	free(buf, M_TEMP);
>-	free(lbuf, M_TEMP);
>+	free(buf, M_LINUX);
>+	free(lbuf, M_LINUX);
> 	return (error);
> }
> 
>@@ -584,8 +586,6 @@
> 	char *path;
> 	int error, dfd, flag;
> 
>-	if (args->flag & ~LINUX_AT_EACCESS)
>-		return (EINVAL);
> 	/* linux convention */
> 	if (args->amode & ~(F_OK | X_OK | W_OK | R_OK))
> 		return (EINVAL);
>@@ -598,7 +598,7 @@
> 		printf(ARGS(access, "%s, %d"), path, args->amode);
> #endif
> 
>-	flag = (args->flag & LINUX_AT_EACCESS) == 0 ? 0 : AT_EACCESS;
>+	flag = AT_EACCESS;
> 	error = kern_accessat(td, dfd, path, UIO_SYSSPACE, flag, args->amode);
> 	LFREEPATH(path);
> 
>@@ -923,6 +923,7 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_truncate64(struct thread *td, struct linux_truncate64_args *args)
> {
>@@ -940,6 +941,8 @@
> 	LFREEPATH(path);
> 	return (error);
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
>+
> int
> linux_ftruncate(struct thread *td, struct linux_ftruncate_args *args)
> {
>@@ -1147,6 +1150,7 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_oldumount(struct thread *td, struct linux_oldumount_args *args)
> {
>@@ -1156,6 +1160,7 @@
> 	args2.flags = 0;
> 	return (linux_umount(td, &args2));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_umount(struct thread *td, struct linux_umount_args *args)
>@@ -1286,7 +1291,7 @@
> #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> static int
>-fcntl_common(struct thread *td, struct linux_fcntl64_args *args)
>+fcntl_common(struct thread *td, struct linux_fcntl_args *args)
> {
> 	struct l_flock linux_flock;
> 	struct flock bsd_flock;
>@@ -1404,6 +1409,9 @@
> 		fdrop(fp, td);
> 
> 		return (kern_fcntl(td, args->fd, F_SETOWN, args->arg));
>+
>+	case LINUX_F_DUPFD_CLOEXEC:
>+		return (kern_fcntl(td, args->fd, F_DUPFD_CLOEXEC, args->arg));
> 	}
> 
> 	return (EINVAL);
>@@ -1412,7 +1420,6 @@
> int
> linux_fcntl(struct thread *td, struct linux_fcntl_args *args)
> {
>-	struct linux_fcntl64_args args64;
> 
> #ifdef DEBUG
> 	if (ldebug(fcntl))
>@@ -1419,10 +1426,7 @@
> 		printf(ARGS(fcntl, "%d, %08x, *"), args->fd, args->cmd);
> #endif
> 
>-	args64.fd = args->fd;
>-	args64.cmd = args->cmd;
>-	args64.arg = args->arg;
>-	return (fcntl_common(td, &args64));
>+	return (fcntl_common(td, args));
> }
> 
> #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
>@@ -1431,6 +1435,7 @@
> {
> 	struct l_flock64 linux_flock;
> 	struct flock bsd_flock;
>+	struct linux_fcntl_args fcntl_args;
> 	int error;
> 
> #ifdef DEBUG
>@@ -1471,7 +1476,10 @@
> 		    (intptr_t)&bsd_flock));
> 	}
> 
>-	return (fcntl_common(td, args));
>+	fcntl_args.fd = args->fd;
>+	fcntl_args.cmd = args->cmd;
>+	fcntl_args.arg = args->arg;
>+	return (fcntl_common(td, &fcntl_args));
> }
> #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
>@@ -1567,6 +1575,7 @@
> 	    advice));
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_fadvise64_64(struct thread *td, struct linux_fadvise64_64_args *args)
> {
>@@ -1578,6 +1587,7 @@
> 	return (kern_posix_fadvise(td, args->fd, args->offset, args->len,
> 	    advice));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_pipe(struct thread *td, struct linux_pipe_args *args)
>@@ -1624,3 +1634,37 @@
> 	/* XXX: Close descriptors on error. */
> 	return (copyout(fildes, args->pipefds, sizeof(fildes)));
> }
>+
>+int
>+linux_dup3(struct thread *td, struct linux_dup3_args *args)
>+{
>+	int cmd;
>+	intptr_t newfd;
>+
>+	if (args->oldfd == args->newfd)
>+		return (EINVAL);
>+	if ((args->flags & ~LINUX_O_CLOEXEC) != 0)
>+		return (EINVAL);
>+	if (args->flags & LINUX_O_CLOEXEC)
>+		cmd = F_DUP2FD_CLOEXEC;
>+	else
>+		cmd = F_DUP2FD;
>+
>+	newfd = args->newfd;
>+	return (kern_fcntl(td, args->oldfd, cmd, newfd));
>+}
>+
>+int
>+linux_fallocate(struct thread *td, struct linux_fallocate_args *args)
>+{
>+
>+	/*
>+	 * We emulate only posix_fallocate system call for which
>+	 * mode should be 0.
>+	 */
>+	if (args->mode != 0)
>+		return (ENOSYS);
>+
>+	return (kern_posix_fallocate(td, args->fd, args->offset,
>+	    args->len));
>+}
>Index: sys/compat/linux/linux_file.h
>===================================================================
>--- sys/compat/linux/linux_file.h	(revision 285633)
>+++ sys/compat/linux/linux_file.h	(working copy)
>@@ -54,4 +54,75 @@
> #define	LINUX_MS_NOEXEC		0x0008
> #define	LINUX_MS_REMOUNT	0x0020
> 
>+/*
>+ * common open/fcntl flags
>+ */
>+#define	LINUX_O_RDONLY		00000000
>+#define	LINUX_O_WRONLY		00000001
>+#define	LINUX_O_RDWR		00000002
>+#define	LINUX_O_ACCMODE		00000003
>+#define	LINUX_O_CREAT		00000100
>+#define	LINUX_O_EXCL		00000200
>+#define	LINUX_O_NOCTTY		00000400
>+#define	LINUX_O_TRUNC		00001000
>+#define	LINUX_O_APPEND		00002000
>+#define	LINUX_O_NONBLOCK	00004000
>+#define	LINUX_O_NDELAY		LINUX_O_NONBLOCK
>+#define	LINUX_O_SYNC		00010000
>+#define	LINUX_FASYNC		00020000
>+#define	LINUX_O_DIRECT		00040000	/* Direct disk access hint */
>+#define	LINUX_O_LARGEFILE	00100000
>+#define	LINUX_O_DIRECTORY	00200000	/* Must be a directory */
>+#define	LINUX_O_NOFOLLOW	00400000	/* Do not follow links */
>+#define	LINUX_O_NOATIME		01000000
>+#define	LINUX_O_CLOEXEC		02000000
>+
>+#define	LINUX_F_DUPFD		0
>+#define	LINUX_F_GETFD		1
>+#define	LINUX_F_SETFD		2
>+#define	LINUX_F_GETFL		3
>+#define	LINUX_F_SETFL		4
>+#ifndef LINUX_F_GETLK
>+#define	LINUX_F_GETLK		5
>+#define	LINUX_F_SETLK		6
>+#define	LINUX_F_SETLKW		7
>+#endif
>+#ifndef LINUX_F_SETOWN
>+#define	LINUX_F_SETOWN		8
>+#define	LINUX_F_GETOWN		9
>+#endif
>+#ifndef LINUX_F_SETSIG
>+#define	LINUX_F_SETSIG		10
>+#define	LINUX_F_GETSIG		11
>+#endif
>+#ifndef LINUX_F_SETOWN_EX
>+#define	LINUX_F_SETOWN_EX	15
>+#define	LINUX_F_GETOWN_EX	16
>+#define	LINUX_F_GETOWNER_UIDS	17
>+#endif
>+
>+#define	LINUX_F_SPECIFIC_BASE	1024
>+
>+#define	LINUX_F_SETLEASE	(LINUX_F_SPECIFIC_BASE + 0)
>+#define	LINUX_F_GETLEASE	(LINUX_F_SPECIFIC_BASE + 1)
>+#define	LINUX_F_CANCELLK	(LINUX_F_SPECIFIC_BASE + 5)
>+#define	LINUX_F_DUPFD_CLOEXEC	(LINUX_F_SPECIFIC_BASE + 6)
>+#define	LINUX_F_NOTIFY		(LINUX_F_SPECIFIC_BASE + 2)
>+#define	LINUX_F_SETPIPE_SZ	(LINUX_F_SPECIFIC_BASE + 7)
>+#define	LINUX_F_GETPIPE_SZ	(LINUX_F_SPECIFIC_BASE + 8)
>+
>+#define	LINUX_F_GETLKP		36
>+#define	LINUX_F_SETLKP		37
>+#define	LINUX_F_SETLKPW		38
>+
>+#define	LINUX_F_OWNER_TID	0
>+#define	LINUX_F_OWNER_PID	1
>+#define	LINUX_F_OWNER_PGRP	2
>+
>+#ifndef LINUX_F_RDLCK
>+#define	LINUX_F_RDLCK		0
>+#define	LINUX_F_WRLCK		1
>+#define	LINUX_F_UNLCK		2
>+#endif
>+
> #endif	/* !_LINUX_FILE_H_ */
>Index: sys/compat/linux/linux_fork.c
>===================================================================
>--- sys/compat/linux/linux_fork.c	(revision 285633)
>+++ sys/compat/linux/linux_fork.c	(working copy)
>@@ -35,14 +35,21 @@
> #include <sys/param.h>
> #include <sys/systm.h>
> #include <sys/imgact.h>
>+#include <sys/ktr.h>
> #include <sys/lock.h>
> #include <sys/mutex.h>
> #include <sys/proc.h>
>+#include <sys/racct.h>
> #include <sys/sched.h>
>-#include <sys/sdt.h>
>+#include <sys/syscallsubr.h>
> #include <sys/sx.h>
> #include <sys/unistd.h>
>+#include <sys/wait.h>
> 
>+#include <vm/vm.h>
>+#include <vm/pmap.h>
>+#include <vm/vm_map.h>
>+
> #ifdef COMPAT_LINUX32
> #include <machine/../linux32/linux.h>
> #include <machine/../linux32/linux32_proto.h>
>@@ -50,19 +57,11 @@
> #include <machine/../linux/linux.h>
> #include <machine/../linux/linux_proto.h>
> #endif
>-#include <compat/linux/linux_dtrace.h>
>-#include <compat/linux/linux_signal.h>
> #include <compat/linux/linux_emul.h>
>+#include <compat/linux/linux_futex.h>
> #include <compat/linux/linux_misc.h>
>+#include <compat/linux/linux_util.h>
> 
>-/* DTrace init */
>-LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
>-
>-/* Linuxulator-global DTrace probes */
>-LIN_SDT_PROBE_DECLARE(locks, emul_lock, locked);
>-LIN_SDT_PROBE_DECLARE(locks, emul_lock, unlock);
>-
>-
> int
> linux_fork(struct thread *td, struct linux_fork_args *args)
> {
>@@ -79,14 +78,11 @@
> 	    != 0)
> 		return (error);
> 
>-	td->td_retval[0] = p2->p_pid;
>-	td->td_retval[1] = 0;
>+	td2 = FIRST_THREAD_IN_PROC(p2);
> 
>-	error = linux_proc_init(td, td->td_retval[0], 0);
>-	if (error)
>-		return (error);
>+	linux_proc_init(td, td2, 0);
> 
>-	td2 = FIRST_THREAD_IN_PROC(p2);
>+	td->td_retval[0] = p2->p_pid;
> 
> 	/*
> 	 * Make this runnable after we are finished with it.
>@@ -116,17 +112,16 @@
> 	    NULL, 0)) != 0)
> 		return (error);
> 
>-   	td->td_retval[0] = p2->p_pid;
> 
>-	error = linux_proc_init(td, td->td_retval[0], 0);
>-	if (error)
>-		return (error);
>+	td2 = FIRST_THREAD_IN_PROC(p2);
> 
>+	linux_proc_init(td, td2, 0);
>+
> 	PROC_LOCK(p2);
> 	p2->p_flag |= P_PPWAIT;
> 	PROC_UNLOCK(p2);
> 
>-	td2 = FIRST_THREAD_IN_PROC(p2);
>+   	td->td_retval[0] = p2->p_pid;
> 
> 	/*
> 	 * Make this runnable after we are finished with it.
>@@ -145,8 +140,8 @@
> 	return (0);
> }
> 
>-int
>-linux_clone(struct thread *td, struct linux_clone_args *args)
>+static int
>+linux_clone_proc(struct thread *td, struct linux_clone_args *args)
> {
> 	int error, ff = RFPROC | RFSTOPPED;
> 	struct proc *p2;
>@@ -164,9 +159,7 @@
> 
> 	exit_signal = args->flags & 0x000000ff;
> 	if (LINUX_SIG_VALID(exit_signal)) {
>-		if (exit_signal <= LINUX_SIGTBLSZ)
>-			exit_signal =
>-			    linux_to_bsd_signal[_SIG_IDX(exit_signal)];
>+		exit_signal = linux_to_bsd_signal(exit_signal);
> 	} else if (exit_signal != 0)
> 		return (EINVAL);
> 
>@@ -183,22 +176,6 @@
> 	if (!(args->flags & (LINUX_CLONE_FILES | LINUX_CLONE_FS)))
> 		ff |= RFFDG;
> 
>-	/*
>-	 * Attempt to detect when linux_clone(2) is used for creating
>-	 * kernel threads. Unfortunately despite the existence of the
>-	 * CLONE_THREAD flag, version of linuxthreads package used in
>-	 * most popular distros as of beginning of 2005 doesn't make
>-	 * any use of it. Therefore, this detection relies on
>-	 * empirical observation that linuxthreads sets certain
>-	 * combination of flags, so that we can make more or less
>-	 * precise detection and notify the FreeBSD kernel that several
>-	 * processes are in fact part of the same threading group, so
>-	 * that special treatment is necessary for signal delivery
>-	 * between those processes and fd locking.
>-	 */
>-	if ((args->flags & 0xffffff00) == LINUX_THREADING_FLAGS)
>-		ff |= RFTHREAD;
>-
> 	if (args->flags & LINUX_CLONE_PARENT_SETTID)
> 		if (args->parent_tidptr == NULL)
> 			return (EINVAL);
>@@ -207,29 +184,13 @@
> 	if (error)
> 		return (error);
> 
>-	if (args->flags & (LINUX_CLONE_PARENT | LINUX_CLONE_THREAD)) {
>-	   	sx_xlock(&proctree_lock);
>-		PROC_LOCK(p2);
>-		proc_reparent(p2, td->td_proc->p_pptr);
>-		PROC_UNLOCK(p2);
>-		sx_xunlock(&proctree_lock);
>-	}
>+	td2 = FIRST_THREAD_IN_PROC(p2);
> 
> 	/* create the emuldata */
>-	error = linux_proc_init(td, p2->p_pid, args->flags);
>-	/* reference it - no need to check this */
>-	em = em_find(p2, EMUL_DOLOCK);
>-	KASSERT(em != NULL, ("clone: emuldata not found."));
>-	/* and adjust it */
>+	linux_proc_init(td, td2, args->flags);
> 
>-	if (args->flags & LINUX_CLONE_THREAD) {
>-#ifdef notyet
>-	   	PROC_LOCK(p2);
>-	   	p2->p_pgrp = td->td_proc->p_pgrp;
>-	   	PROC_UNLOCK(p2);
>-#endif
>-		exit_signal = 0;
>-	}
>+	em = em_find(td2);
>+	KASSERT(em != NULL, ("clone_proc: emuldata not found.\n"));
> 
> 	if (args->flags & LINUX_CLONE_CHILD_SETTID)
> 		em->child_set_tid = args->child_tidptr;
>@@ -241,8 +202,6 @@
> 	else
> 	   	em->child_clear_tid = NULL;
> 
>-	EMUL_UNLOCK(&emul_lock);
>-
> 	if (args->flags & LINUX_CLONE_PARENT_SETTID) {
> 		error = copyout(&p2->p_pid, args->parent_tidptr,
> 		    sizeof(p2->p_pid));
>@@ -253,14 +212,12 @@
> 	PROC_LOCK(p2);
> 	p2->p_sigparent = exit_signal;
> 	PROC_UNLOCK(p2);
>-	td2 = FIRST_THREAD_IN_PROC(p2);
> 	/*
> 	 * In a case of stack = NULL, we are supposed to COW calling process
> 	 * stack. This is what normal fork() does, so we just keep tf_rsp arg
> 	 * intact.
> 	 */
>-	if (args->stack)
>-		linux_set_upcall_kse(td2, PTROUT(args->stack));
>+	linux_set_upcall_kse(td2, PTROUT(args->stack));
> 
> 	if (args->flags & LINUX_CLONE_SETTLS)
> 		linux_set_cloned_tls(td2, args->tls);
>@@ -271,6 +228,7 @@
> 		    "stack %p sig = %d"), (int)p2->p_pid, args->stack,
> 		    exit_signal);
> #endif
>+
> 	if (args->flags & LINUX_CLONE_VFORK) {
> 	   	PROC_LOCK(p2);
> 	   	p2->p_flag |= P_PPWAIT;
>@@ -286,7 +244,6 @@
> 	thread_unlock(td2);
> 
> 	td->td_retval[0] = p2->p_pid;
>-	td->td_retval[1] = 0;
> 
> 	if (args->flags & LINUX_CLONE_VFORK) {
> 		/* wait for the children to exit, ie. emulate vfork */
>@@ -298,3 +255,216 @@
> 
> 	return (0);
> }
>+
>+static int
>+linux_clone_thread(struct thread *td, struct linux_clone_args *args)
>+{
>+	struct linux_emuldata *em;
>+	struct thread *newtd;
>+	struct proc *p;
>+	int error;
>+
>+#ifdef DEBUG
>+	if (ldebug(clone)) {
>+		printf(ARGS(clone, "thread: flags %x, stack %p, parent tid: %p, "
>+		    "child tid: %p"), (unsigned)args->flags,
>+		    args->stack, args->parent_tidptr, args->child_tidptr);
>+	}
>+#endif
>+
>+	LINUX_CTR4(clone_thread, "thread(%d) flags %x ptid %p ctid %p",
>+	    td->td_tid, (unsigned)args->flags,
>+	    args->parent_tidptr, args->child_tidptr);
>+
>+	if (args->flags & LINUX_CLONE_PARENT_SETTID)
>+		if (args->parent_tidptr == NULL)
>+			return (EINVAL);
>+
>+	/* Threads should be created with own stack */
>+	if (args->stack == NULL)
>+		return (EINVAL);
>+
>+	p = td->td_proc;
>+
>+	/* Initialize our td */
>+	error = kern_thr_alloc(p, 0, &newtd);
>+	if (error)
>+		return (error);
>+														
>+	cpu_set_upcall(newtd, td);
>+
>+	bzero(&newtd->td_startzero,
>+	    __rangeof(struct thread, td_startzero, td_endzero));
>+	bcopy(&td->td_startcopy, &newtd->td_startcopy,
>+	    __rangeof(struct thread, td_startcopy, td_endcopy));
>+
>+	newtd->td_proc = p;
>+	newtd->td_ucred = crhold(td->td_ucred);
>+
>+	/* create the emuldata */
>+	linux_proc_init(td, newtd, args->flags);
>+
>+	em = em_find(newtd);
>+	KASSERT(em != NULL, ("clone_thread: emuldata not found.\n"));
>+
>+	if (args->flags & LINUX_CLONE_SETTLS)
>+		linux_set_cloned_tls(newtd, args->tls);
>+
>+	if (args->flags & LINUX_CLONE_CHILD_SETTID)
>+		em->child_set_tid = args->child_tidptr;
>+	else
>+	   	em->child_set_tid = NULL;
>+
>+	if (args->flags & LINUX_CLONE_CHILD_CLEARTID)
>+		em->child_clear_tid = args->child_tidptr;
>+	else
>+	   	em->child_clear_tid = NULL;
>+
>+	cpu_thread_clean(newtd);
>+	
>+	linux_set_upcall_kse(newtd, PTROUT(args->stack));
>+
>+	PROC_LOCK(p);
>+	p->p_flag |= P_HADTHREADS;
>+	bcopy(p->p_comm, newtd->td_name, sizeof(newtd->td_name));
>+
>+	if (args->flags & LINUX_CLONE_PARENT)
>+		thread_link(newtd, p->p_pptr);
>+	else
>+		thread_link(newtd, p);
>+
>+	thread_lock(td);
>+	/* let the scheduler know about these things. */
>+	sched_fork_thread(td, newtd);
>+	thread_unlock(td);
>+	if (P_SHOULDSTOP(p))
>+		newtd->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK;
>+	PROC_UNLOCK(p);
>+
>+	tidhash_add(newtd);
>+
>+#ifdef DEBUG
>+	if (ldebug(clone))
>+		printf(ARGS(clone, "successful clone to %d, stack %p"),
>+		(int)newtd->td_tid, args->stack);
>+#endif
>+
>+	LINUX_CTR2(clone_thread, "thread(%d) successful clone to %d",
>+	    td->td_tid, newtd->td_tid);
>+
>+	if (args->flags & LINUX_CLONE_PARENT_SETTID) {
>+		error = copyout(&newtd->td_tid, args->parent_tidptr,
>+		    sizeof(newtd->td_tid));
>+		if (error)
>+			printf(LMSG("clone_thread: copyout failed!"));
>+	}
>+
>+	/*
>+	 * Make this runnable after we are finished with it.
>+	 */
>+	thread_lock(newtd);
>+	TD_SET_CAN_RUN(newtd);
>+	sched_add(newtd, SRQ_BORING);
>+	thread_unlock(newtd);
>+
>+	td->td_retval[0] = newtd->td_tid;
>+
>+	return (0);
>+}
>+
>+int
>+linux_clone(struct thread *td, struct linux_clone_args *args)
>+{
>+
>+	if (args->flags & LINUX_CLONE_THREAD)
>+		return (linux_clone_thread(td, args));
>+	else
>+		return (linux_clone_proc(td, args));
>+}
>+
>+int
>+linux_exit(struct thread *td, struct linux_exit_args *args)
>+{
>+	struct linux_emuldata *em;
>+	struct proc *p;
>+
>+	em = em_find(td);
>+	KASSERT(em != NULL, ("exit: emuldata not found.\n"));
>+
>+	LINUX_CTR2(exit, "thread(%d) (%d)", em->em_tid, args->rval);
>+
>+	p = td->td_proc;
>+
>+	linux_thread_detach(td);
>+
>+	kern_thr_exit(td);
>+	exit1(td, W_EXITCODE(args->rval, 0));
>+		/* NOTREACHED */
>+}
>+
>+int
>+linux_set_tid_address(struct thread *td, struct linux_set_tid_address_args *args)
>+{
>+	struct linux_emuldata *em;
>+
>+	em = em_find(td);
>+	KASSERT(em != NULL, ("set_tid_address: emuldata not found.\n"));
>+
>+	em->child_clear_tid = args->tidptr;
>+
>+	td->td_retval[0] = em->em_tid;
>+
>+	LINUX_CTR3(set_tid_address, "tidptr(%d) %p, returns %d",
>+	    em->em_tid, args->tidptr, td->td_retval[0]);
>+
>+	return (0);
>+}
>+
>+void
>+linux_thread_detach(struct thread *td)
>+{
>+	struct linux_sys_futex_args cup;
>+	struct linux_emuldata *em;
>+	int *child_clear_tid;
>+	int null = 0;
>+	int error;
>+
>+	em = em_find(td);
>+	KASSERT(em != NULL, ("thread_detach: emuldata not found.\n"));
>+
>+	if (em->flags & LINUX_THREAD_DETACHED) {
>+		LINUX_CTR1(thread_detach, "thread(%d) already detached", em->em_tid);
>+		return;
>+	}
>+
>+	em->flags |= LINUX_THREAD_DETACHED;
>+	LINUX_CTR1(thread_detach, "thread(%d)", em->em_tid);
>+
>+	release_futexes(td, em);
>+
>+	child_clear_tid = em->child_clear_tid;
>+
>+	if (child_clear_tid != NULL) {
>+
>+		LINUX_CTR2(thread_detach, "thread(%d) %p",
>+		    em->em_tid, child_clear_tid);
>+	
>+		error = copyout(&null, child_clear_tid, sizeof(null));
>+		if (error)
>+			return;
>+
>+		cup.uaddr = child_clear_tid;
>+		cup.op = LINUX_FUTEX_WAKE;
>+		cup.val = 1;		/* wake one */
>+		cup.timeout = NULL;
>+		cup.uaddr2 = NULL;
>+		cup.val3 = 0;
>+		error = linux_sys_futex(td, &cup);
>+		/*
>+		 * this cannot happen at the moment and if this happens it
>+		 * probably means there is a user space bug
>+		 */
>+		if (error)
>+			printf(LMSG("futex stuff in thread_detach failed.\n"));
>+	}
>+}
>Index: sys/compat/linux/linux_futex.c
>===================================================================
>--- sys/compat/linux/linux_futex.c	(revision 285633)
>+++ sys/compat/linux/linux_futex.c	(working copy)
>@@ -66,15 +66,12 @@
> #include <compat/linux/linux_dtrace.h>
> #include <compat/linux/linux_emul.h>
> #include <compat/linux/linux_futex.h>
>+#include <compat/linux/linux_timer.h>
> #include <compat/linux/linux_util.h>
> 
> /* DTrace init */
> LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
> 
>-/* Linuxulator-global DTrace probes */
>-LIN_SDT_PROBE_DECLARE(locks, emul_lock, locked);
>-LIN_SDT_PROBE_DECLARE(locks, emul_lock, unlock);
>-
> /**
>  * Futex part for the special DTrace module "locks".
>  */
>@@ -175,8 +172,8 @@
>     "struct linux_get_robust_list_args *");
> LIN_SDT_PROBE_DEFINE1(futex, linux_get_robust_list, copyout_error, "int");
> LIN_SDT_PROBE_DEFINE1(futex, linux_get_robust_list, return, "int");
>-LIN_SDT_PROBE_DEFINE3(futex, handle_futex_death, entry, "struct proc *",
>-    "uint32_t *", "unsigned int");
>+LIN_SDT_PROBE_DEFINE3(futex, handle_futex_death, entry,
>+    "struct linux_emuldata *", "uint32_t *", "unsigned int");
> LIN_SDT_PROBE_DEFINE1(futex, handle_futex_death, copyin_error, "int");
> LIN_SDT_PROBE_DEFINE1(futex, handle_futex_death, return, "int");
> LIN_SDT_PROBE_DEFINE3(futex, fetch_robust_entry, entry,
>@@ -184,13 +181,11 @@
>     "unsigned int *");
> LIN_SDT_PROBE_DEFINE1(futex, fetch_robust_entry, copyin_error, "int");
> LIN_SDT_PROBE_DEFINE1(futex, fetch_robust_entry, return, "int");
>-LIN_SDT_PROBE_DEFINE1(futex, release_futexes, entry, "struct proc *");
>+LIN_SDT_PROBE_DEFINE2(futex, release_futexes, entry, "struct thread *",
>+    "struct linux_emuldata *");
> LIN_SDT_PROBE_DEFINE1(futex, release_futexes, copyin_error, "int");
> LIN_SDT_PROBE_DEFINE0(futex, release_futexes, return);
> 
>-static MALLOC_DEFINE(M_FUTEX, "futex", "Linux futexes");
>-static MALLOC_DEFINE(M_FUTEX_WP, "futex wp", "Linux futexes wp");
>-
> struct futex;
> 
> struct waiting_proc {
>@@ -253,6 +248,21 @@
> 					 * wp_list to prevent double wakeup.
> 					 */
> 
>+static void futex_put(struct futex *, struct waiting_proc *);
>+static int futex_get0(uint32_t *, struct futex **f, uint32_t);
>+static int futex_get(uint32_t *, struct waiting_proc **, struct futex **,
>+    uint32_t);
>+static int futex_sleep(struct futex *, struct waiting_proc *, int);
>+static int futex_wake(struct futex *, int, uint32_t);
>+static int futex_requeue(struct futex *, int, struct futex *, int);
>+static int futex_wait(struct futex *, struct waiting_proc *, int,
>+    uint32_t);
>+static int futex_atomic_op(struct thread *, int, uint32_t *);
>+static int handle_futex_death(struct linux_emuldata *, uint32_t *,
>+    unsigned int);
>+static int fetch_robust_entry(struct linux_robust_list **,
>+    struct linux_robust_list **, unsigned int *);
>+
> /* support.s */
> int futex_xchgl(int oparg, uint32_t *uaddr, int *oldval);
> int futex_addl(int oparg, uint32_t *uaddr, int *oldval);
>@@ -260,6 +270,7 @@
> int futex_andl(int oparg, uint32_t *uaddr, int *oldval);
> int futex_xorl(int oparg, uint32_t *uaddr, int *oldval);
> 
>+
> static void
> futex_put(struct futex *f, struct waiting_proc *wp)
> {
>@@ -657,10 +668,11 @@
> linux_sys_futex(struct thread *td, struct linux_sys_futex_args *args)
> {
> 	int clockrt, nrwake, op_ret, ret;
>-	struct linux_emuldata *em;
>+	struct linux_pemuldata *pem;
> 	struct waiting_proc *wp;
> 	struct futex *f, *f2;
>-	struct l_timespec timeout;
>+	struct l_timespec ltimeout;
>+	struct timespec timeout;
> 	struct timeval utv, ctv;
> 	int timeout_hz;
> 	int error;
>@@ -704,6 +716,38 @@
> 		LINUX_CTR3(sys_futex, "WAIT uaddr %p val 0x%x bitset 0x%x",
> 		    args->uaddr, args->val, args->val3);
> 
>+		if (args->timeout != NULL) {
>+			error = copyin(args->timeout, &ltimeout, sizeof(ltimeout));
>+			if (error) {
>+				LIN_SDT_PROBE1(futex, linux_sys_futex, copyin_error,
>+				    error);
>+				LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
>+				return (error);
>+			}
>+			error = linux_to_native_timespec(&timeout, &ltimeout);
>+			if (error)
>+				return (error);
>+			TIMESPEC_TO_TIMEVAL(&utv, &timeout);
>+			error = itimerfix(&utv);
>+			if (error) {
>+				LIN_SDT_PROBE1(futex, linux_sys_futex, itimerfix_error,
>+				    error);
>+				LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
>+				return (error);
>+			}
>+			if (clockrt) {
>+				microtime(&ctv);
>+				timevalsub(&utv, &ctv);
>+			} else if (args->op == LINUX_FUTEX_WAIT_BITSET) {
>+				microuptime(&ctv);
>+				timevalsub(&utv, &ctv);
>+			}
>+			if (utv.tv_sec < 0)
>+				timevalclear(&utv);
>+			timeout_hz = tvtohz(&utv);
>+		} else
>+			timeout_hz = 0;
>+
> 		error = futex_get(args->uaddr, &wp, &f,
> 		    flags | FUTEX_CREATE_WP);
> 		if (error) {
>@@ -736,37 +780,6 @@
> 			return (EWOULDBLOCK);
> 		}
> 
>-		if (args->timeout != NULL) {
>-			error = copyin(args->timeout, &timeout, sizeof(timeout));
>-			if (error) {
>-				LIN_SDT_PROBE1(futex, linux_sys_futex, copyin_error,
>-				    error);
>-				LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
>-				futex_put(f, wp);
>-				return (error);
>-			}
>-			TIMESPEC_TO_TIMEVAL(&utv, &timeout);
>-			error = itimerfix(&utv);
>-			if (error) {
>-				LIN_SDT_PROBE1(futex, linux_sys_futex, itimerfix_error,
>-				    error);
>-				LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
>-				futex_put(f, wp);
>-				return (error);
>-			}
>-			if (clockrt) {
>-				microtime(&ctv);
>-				timevalsub(&utv, &ctv);
>-			} else if (args->op == LINUX_FUTEX_WAIT_BITSET) {
>-				microuptime(&ctv);
>-				timevalsub(&utv, &ctv);
>-			}
>-			if (utv.tv_sec < 0)
>-				timevalclear(&utv);
>-			timeout_hz = tvtohz(&utv);
>-		} else
>-			timeout_hz = 0;
>-
> 		error = futex_wait(f, wp, timeout_hz, args->val3);
> 		break;
> 
>@@ -977,12 +990,12 @@
> 		 * Glibc versions prior to 2.3.3 fall back to FUTEX_WAKE when
> 		 * FUTEX_REQUEUE returned EINVAL.
> 		 */
>-		em = em_find(td->td_proc, EMUL_DONTLOCK);
>-		if ((em->flags & LINUX_XDEPR_REQUEUEOP) == 0) {
>+		pem = pem_find(td->td_proc);
>+		if ((pem->flags & LINUX_XDEPR_REQUEUEOP) == 0) {
> 			linux_msg(td,
> 				  "linux_sys_futex: "
> 				  "unsupported futex_requeue op\n");
>-			em->flags |= LINUX_XDEPR_REQUEUEOP;
>+			pem->flags |= LINUX_XDEPR_REQUEUEOP;
> 			LIN_SDT_PROBE0(futex, linux_sys_futex,
> 			    deprecated_requeue);
> 		}
>@@ -1036,9 +1049,8 @@
> 		return (EINVAL);
> 	}
> 
>-	em = em_find(td->td_proc, EMUL_DOLOCK);
>+	em = em_find(td);
> 	em->robust_futexes = args->head;
>-	EMUL_UNLOCK(&emul_lock);
> 
> 	LIN_SDT_PROBE1(futex, linux_set_robust_list, return, 0);
> 	return (0);
>@@ -1050,29 +1062,30 @@
> 	struct linux_emuldata *em;
> 	struct linux_robust_list_head *head;
> 	l_size_t len = sizeof(struct linux_robust_list_head);
>+	struct thread *td2;
> 	int error = 0;
> 
> 	LIN_SDT_PROBE2(futex, linux_get_robust_list, entry, td, args);
> 
> 	if (!args->pid) {
>-		em = em_find(td->td_proc, EMUL_DONTLOCK);
>+		em = em_find(td);
>+		KASSERT(em != NULL, ("get_robust_list: emuldata notfound.\n"));
> 		head = em->robust_futexes;
> 	} else {
>-		struct proc *p;
>-
>-		p = pfind(args->pid);
>-		if (p == NULL) {
>+		td2 = tdfind(args->pid, -1);
>+		if (td2 == NULL) {
> 			LIN_SDT_PROBE1(futex, linux_get_robust_list, return,
> 			    ESRCH);
> 			return (ESRCH);
> 		}
> 
>-		em = em_find(p, EMUL_DONTLOCK);
>+		em = em_find(td2);
>+		KASSERT(em != NULL, ("get_robust_list: emuldata notfound.\n"));
> 		/* XXX: ptrace? */
> 		if (priv_check(td, PRIV_CRED_SETUID) ||
> 		    priv_check(td, PRIV_CRED_SETEUID) ||
>-		    p_candebug(td, p)) {
>-			PROC_UNLOCK(p);
>+		    p_candebug(td, td2->td_proc)) {
>+			PROC_UNLOCK(td2->td_proc);
> 
> 			LIN_SDT_PROBE1(futex, linux_get_robust_list, return,
> 			    EPERM);
>@@ -1080,7 +1093,7 @@
> 		}
> 		head = em->robust_futexes;
> 
>-		PROC_UNLOCK(p);
>+		PROC_UNLOCK(td2->td_proc);
> 	}
> 
> 	error = copyout(&len, args->len, sizeof(l_size_t));
>@@ -1102,13 +1115,14 @@
> }
> 
> static int
>-handle_futex_death(struct proc *p, uint32_t *uaddr, unsigned int pi)
>+handle_futex_death(struct linux_emuldata *em, uint32_t *uaddr,
>+    unsigned int pi)
> {
> 	uint32_t uval, nval, mval;
> 	struct futex *f;
> 	int error;
> 
>-	LIN_SDT_PROBE3(futex, handle_futex_death, entry, p, uaddr, pi);
>+	LIN_SDT_PROBE3(futex, handle_futex_death, entry, em, uaddr, pi);
> 
> retry:
> 	error = copyin(uaddr, &uval, 4);
>@@ -1117,7 +1131,7 @@
> 		LIN_SDT_PROBE1(futex, handle_futex_death, return, EFAULT);
> 		return (EFAULT);
> 	}
>-	if ((uval & FUTEX_TID_MASK) == p->p_pid) {
>+	if ((uval & FUTEX_TID_MASK) == em->em_tid) {
> 		mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
> 		nval = casuword32(uaddr, uval, mval);
> 
>@@ -1174,18 +1188,16 @@
> 
> /* This walks the list of robust futexes releasing them. */
> void
>-release_futexes(struct proc *p)
>+release_futexes(struct thread *td, struct linux_emuldata *em)
> {
> 	struct linux_robust_list_head *head = NULL;
> 	struct linux_robust_list *entry, *next_entry, *pending;
> 	unsigned int limit = 2048, pi, next_pi, pip;
>-	struct linux_emuldata *em;
> 	l_long futex_offset;
> 	int rc, error;
> 
>-	LIN_SDT_PROBE1(futex, release_futexes, entry, p);
>+	LIN_SDT_PROBE2(futex, release_futexes, entry, td, em);
> 
>-	em = em_find(p, EMUL_DONTLOCK);
> 	head = em->robust_futexes;
> 
> 	if (head == NULL) {
>@@ -1215,7 +1227,7 @@
> 		rc = fetch_robust_entry(&next_entry, PTRIN(&entry->next), &next_pi);
> 
> 		if (entry != pending)
>-			if (handle_futex_death(p,
>+			if (handle_futex_death(em,
> 			    (uint32_t *)((caddr_t)entry + futex_offset), pi)) {
> 				LIN_SDT_PROBE0(futex, release_futexes, return);
> 				return;
>@@ -1235,7 +1247,7 @@
> 	}
> 
> 	if (pending)
>-		handle_futex_death(p, (uint32_t *)((caddr_t)pending + futex_offset), pip);
>+		handle_futex_death(em, (uint32_t *)((caddr_t)pending + futex_offset), pip);
> 
> 	LIN_SDT_PROBE0(futex, release_futexes, return);
> }
>Index: sys/compat/linux/linux_futex.h
>===================================================================
>--- sys/compat/linux/linux_futex.h	(revision 285633)
>+++ sys/compat/linux/linux_futex.h	(working copy)
>@@ -76,6 +76,7 @@
> #define	FUTEX_TID_MASK		0x3fffffff
> #define	FUTEX_BITSET_MATCH_ANY	0xffffffff
> 
>-void	release_futexes(struct proc *);
>+void	release_futexes(struct thread *,
>+			struct linux_emuldata *);
> 
> #endif	/* !_LINUX_FUTEX_H */
>Index: sys/compat/linux/linux_getcwd.c
>===================================================================
>--- sys/compat/linux/linux_getcwd.c	(revision 285633)
>+++ sys/compat/linux/linux_getcwd.c	(working copy)
>@@ -119,7 +119,7 @@
> 	int     tries;
> 	struct uio uio;
> 	struct iovec iov;
>-	char   *dirbuf = NULL;
>+	char   *dirbuf;
> 	int	dirbuflen;
> 	ino_t   fileno;
> 	struct vattr va;
>@@ -139,7 +139,7 @@
> 			vput(lvp);
> 			*lvpp = NULL;
> 			*uvpp = NULL;
>-			return error;
>+			return (error);
> 		}
> 	}
> 
>@@ -170,7 +170,7 @@
> 		vput(lvp);
> 		*lvpp = NULL;
> 		*uvpp = NULL;
>-		return error;
>+		return (error);
> 	}
> 	uvp = *uvpp;
> 
>@@ -178,7 +178,7 @@
> 	if (bufp == NULL) {
> 		vput(lvp);
> 		*lvpp = NULL;
>-		return 0;
>+		return (0);
> 	}
> 	
> 	fileno = va.va_fileid;
>@@ -186,7 +186,7 @@
> 	dirbuflen = DIRBLKSIZ;
> 	if (dirbuflen < va.va_blocksize)
> 		dirbuflen = va.va_blocksize;
>-	dirbuf = malloc(dirbuflen, M_TEMP, M_WAITOK);
>+	dirbuf = malloc(dirbuflen, M_LINUX, M_WAITOK);
> 
> #if 0
> unionread:
>@@ -228,7 +228,7 @@
> 			continue;	/* once more, with feeling */
> 		}
> 
>-		if (!error) {
>+		if (error == 0) {
> 			char   *cpos;
> 			struct dirent *dp;
> 			
>@@ -274,8 +274,8 @@
> out:
> 	vput(lvp);
> 	*lvpp = NULL;
>-	free(dirbuf, M_TEMP);
>-	return error;
>+	free(dirbuf, M_LINUX);
>+	return (error);
> }
> 
> 
>@@ -399,7 +399,7 @@
> 	if (lvp)
> 		vput(lvp);
> 	vrele(rvp);
>-	return error;
>+	return (error);
> }
> 
> 
>@@ -426,18 +426,17 @@
> 	if (len > MAXPATHLEN*4)
> 		len = MAXPATHLEN*4;
> 	else if (len < 2)
>-		return ERANGE;
>+		return (ERANGE);
> 
>-	path = malloc(len, M_TEMP, M_WAITOK);
>+	path = malloc(len, M_LINUX, M_WAITOK);
> 
> 	error = kern___getcwd(td, path, UIO_SYSSPACE, len);
>-	if (!error) {
>+	if (error == 0) {
> 		lenused = strlen(path) + 1;
> 		if (lenused <= args->bufsize) {
> 			td->td_retval[0] = lenused;
> 			error = copyout(path, args->buf, lenused);
>-		}
>-		else
>+		} else
> 			error = ERANGE;
> 	} else {
> 		bp = &path[len];
>@@ -450,7 +449,7 @@
> 		 * limit it to N/2 vnodes for an N byte buffer.
> 		 */
> 
>-		error = linux_getcwd_common (td->td_proc->p_fd->fd_cdir, NULL,
>+		error = linux_getcwd_common(td->td_proc->p_fd->fd_cdir, NULL,
> 		    &bp, path, len/2, GETCWD_CHECK_ACCESS, td);
> 		if (error)
> 			goto out;
>@@ -460,7 +459,6 @@
> 		error = copyout(bp, args->buf, lenused);
> 	}
> out:
>-	free(path, M_TEMP);
>+	free(path, M_LINUX);
> 	return (error);
> }
>-
>Index: sys/compat/linux/linux_ioctl.c
>===================================================================
>--- sys/compat/linux/linux_ioctl.c	(revision 285633)
>+++ sys/compat/linux/linux_ioctl.c	(working copy)
>@@ -68,7 +68,6 @@
> #include <net/if.h>
> #include <net/if_dl.h>
> #include <net/if_types.h>
>-#include <net/vnet.h>
> 
> #include <dev/usb/usb_ioctl.h>
> 
>@@ -95,9 +94,6 @@
> 
> CTASSERT(LINUX_IFNAMSIZ == IFNAMSIZ);
> 
>-FEATURE(linuxulator_v4l, "V4L ioctl wrapper support in the linuxulator");
>-FEATURE(linuxulator_v4l2, "V4L2 ioctl wrapper support in the linuxulator");
>-
> static linux_ioctl_function_t linux_ioctl_cdrom;
> static linux_ioctl_function_t linux_ioctl_vfat;
> static linux_ioctl_function_t linux_ioctl_console;
>@@ -1980,8 +1976,6 @@
>  * Console related ioctls
>  */
> 
>-#define ISSIGVALID(sig)		((sig) > 0 && (sig) < NSIG)
>-
> static int
> linux_ioctl_console(struct thread *td, struct linux_ioctl_args *args)
> {
>@@ -2064,8 +2058,16 @@
> 		struct vt_mode mode;
> 		if ((error = copyin((void *)args->arg, &mode, sizeof(mode))))
> 			break;
>-		if (!ISSIGVALID(mode.frsig) && ISSIGVALID(mode.acqsig))
>-			mode.frsig = mode.acqsig;
>+		if (LINUX_SIG_VALID(mode.relsig))
>+			mode.relsig = linux_to_bsd_signal(mode.relsig);
>+		else
>+			mode.relsig = 0;
>+		if (LINUX_SIG_VALID(mode.acqsig))
>+			mode.acqsig = linux_to_bsd_signal(mode.acqsig);
>+		else
>+			mode.acqsig = 0;
>+		/* XXX. Linux ignores frsig and set it to 0. */
>+		mode.frsig = 0;
> 		if ((error = copyout(&mode, (void *)args->arg, sizeof(mode))))
> 			break;
> 		args->cmd = VT_SETMODE;
>@@ -2108,34 +2110,6 @@
> #define IFP_IS_ETH(ifp) (ifp->if_type == IFT_ETHER)
> 
> /*
>- * Interface function used by linprocfs (at the time of writing). It's not
>- * used by the Linuxulator itself.
>- */
>-int
>-linux_ifname(struct ifnet *ifp, char *buffer, size_t buflen)
>-{
>-	struct ifnet *ifscan;
>-	int ethno;
>-
>-	IFNET_RLOCK_ASSERT();
>-
>-	/* Short-circuit non ethernet interfaces */
>-	if (!IFP_IS_ETH(ifp))
>-		return (strlcpy(buffer, ifp->if_xname, buflen));
>-
>-	/* Determine the (relative) unit number for ethernet interfaces */
>-	ethno = 0;
>-	TAILQ_FOREACH(ifscan, &V_ifnet, if_link) {
>-		if (ifscan == ifp)
>-			return (snprintf(buffer, buflen, "eth%d", ethno));
>-		if (IFP_IS_ETH(ifscan))
>-			ethno++;
>-	}
>-
>-	return (0);
>-}
>-
>-/*
>  * Translate a Linux interface name to a FreeBSD interface name,
>  * and return the associated ifnet structure
>  * bsdname and lxname need to be least IFNAMSIZ bytes long, but
>@@ -3621,10 +3595,17 @@
> 	sx_sunlock(&linux_ioctl_sx);
> 	fdrop(fp, td);
> 
>-	linux_msg(td, "ioctl fd=%d, cmd=0x%x ('%c',%d) is not implemented",
>-	    args->fd, (int)(args->cmd & 0xffff),
>-	    (int)(args->cmd & 0xff00) >> 8, (int)(args->cmd & 0xff));
>+	switch (args->cmd & 0xffff) {
>+	case LINUX_BTRFS_IOC_CLONE:
>+		return (ENOTSUP);
> 
>+	default:
>+		linux_msg(td, "ioctl fd=%d, cmd=0x%x ('%c',%d) is not implemented",
>+		    args->fd, (int)(args->cmd & 0xffff),
>+		    (int)(args->cmd & 0xff00) >> 8, (int)(args->cmd & 0xff));
>+		break;
>+	}
>+
> 	return (EINVAL);
> }
> 
>Index: sys/compat/linux/linux_ioctl.h
>===================================================================
>--- sys/compat/linux/linux_ioctl.h	(revision 285633)
>+++ sys/compat/linux/linux_ioctl.h	(working copy)
>@@ -581,13 +581,6 @@
> #define	LINUX_IOCTL_DRM_MAX	0x64ff
> 
> /*
>- * This doesn't really belong here, but I can't think of a better
>- * place to put it.
>- */
>-struct ifnet;
>-int		 linux_ifname(struct ifnet *, char *, size_t);
>-
>-/*
>  * video
>  */
> #define LINUX_VIDIOCGCAP		0x7601
>@@ -752,6 +745,12 @@
> #define	FBSD_LUSB_MIN			0xffdd
> 
> /*
>+ * Linux btrfs clone operation
>+ */
>+#define LINUX_BTRFS_IOC_CLONE		0x9409 /* 0x40049409 */
>+
>+
>+/*
>  * Pluggable ioctl handlers
>  */
> struct linux_ioctl_args;
>Index: sys/compat/linux/linux_ipc.c
>===================================================================
>--- sys/compat/linux/linux_ipc.c	(revision 285633)
>+++ sys/compat/linux/linux_ipc.c	(working copy)
>@@ -117,16 +117,6 @@
> 	lpp->swap_successes = bpp->swap_successes ;
> }
> 
>-struct l_ipc_perm {
>-	l_key_t		key;
>-	l_uid16_t	uid;
>-	l_gid16_t	gid;
>-	l_uid16_t	cuid;
>-	l_gid16_t	cgid;
>-	l_ushort	mode;
>-	l_ushort	seq;
>-};
>-
> static void
> linux_to_bsd_ipc_perm(struct l_ipc_perm *lpp, struct ipc_perm *bpp)
> {
>Index: sys/compat/linux/linux_ipc.h
>===================================================================
>--- sys/compat/linux/linux_ipc.h	(revision 285633)
>+++ sys/compat/linux/linux_ipc.h	(working copy)
>@@ -82,7 +82,7 @@
> #define	LINUX_IPC_64	0x0100	/* New version (support 32-bit UIDs, bigger
> 				   message sizes, etc. */
> 
>-#if defined(__i386__) || defined(__amd64__)
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> 
> struct linux_msgctl_args 
> {
>@@ -177,6 +177,6 @@
> int linux_shmdt(struct thread *, struct linux_shmdt_args *);
> int linux_shmget(struct thread *, struct linux_shmget_args *);
> 
>-#endif	/* __i386__ || __amd64__ */
>+#endif	/* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> #endif /* _LINUX_IPC_H_ */
>Index: sys/compat/linux/linux_mib.c
>===================================================================
>--- sys/compat/linux/linux_mib.c	(revision 285633)
>+++ sys/compat/linux/linux_mib.c	(working copy)
>@@ -29,9 +29,6 @@
> #include <sys/cdefs.h>
> __FBSDID("$FreeBSD$");
> 
>-#include "opt_compat.h"
>-#include "opt_kdtrace.h"
>-
> #include <sys/param.h>
> #include <sys/kernel.h>
> #include <sys/sdt.h>
>@@ -42,85 +39,11 @@
> #include <sys/mount.h>
> #include <sys/jail.h>
> #include <sys/lock.h>
>-#include <sys/mutex.h>
> #include <sys/sx.h>
> 
>-#ifdef COMPAT_LINUX32
>-#include <machine/../linux32/linux.h>
>-#else
>-#include <machine/../linux/linux.h>
>-#endif
>-#include <compat/linux/linux_dtrace.h>
> #include <compat/linux/linux_mib.h>
> #include <compat/linux/linux_misc.h>
> 
>-/* DTrace init */
>-LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
>-
>-/**
>- * DTrace probes in this module.
>- */
>-LIN_SDT_PROBE_DEFINE0(mib, linux_sysctl_osname, entry);
>-LIN_SDT_PROBE_DEFINE1(mib, linux_sysctl_osname, sysctl_string_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_sysctl_osname, return, "int");
>-
>-LIN_SDT_PROBE_DEFINE0(mib, linux_sysctl_osrelease, entry);
>-LIN_SDT_PROBE_DEFINE1(mib, linux_sysctl_osrelease, sysctl_string_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_sysctl_osrelease, return, "int");
>-LIN_SDT_PROBE_DEFINE0(mib, linux_sysctl_oss_version, entry);
>-LIN_SDT_PROBE_DEFINE1(mib, linux_sysctl_oss_version, sysctl_string_error,
>-    "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_sysctl_oss_version, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_map_osrel, entry, "char *", "int *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_map_osrel, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_get_prison, entry, "struct prison *",
>-    "struct prison **");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_get_prison, return, "struct linux_prison *");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_alloc_prison, entry, "struct prison *",
>-    "struct linux_prison **");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_alloc_prison, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_prison_create, entry, "void *", "void *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_create, vfs_copyopt_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_create, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_prison_check, entry, "void *", "void *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_check, vfs_copyopt_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_check, vfs_getopt_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_check, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_prison_set, entry, "void *", "void *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_set, vfs_copyopt_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_set, vfs_getopt_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_set, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_prison_get, entry, "void *", "void *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_get, vfs_setopt_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_get, vfs_setopts_error, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_get, return, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_prison_destructor, entry, "void *");
>-LIN_SDT_PROBE_DEFINE0(mib, linux_prison_destructor, return);
>-LIN_SDT_PROBE_DEFINE0(mib, linux_osd_jail_register, entry);
>-LIN_SDT_PROBE_DEFINE0(mib, linux_osd_jail_register, return);
>-LIN_SDT_PROBE_DEFINE0(mib, linux_osd_jail_deregister, entry);
>-LIN_SDT_PROBE_DEFINE0(mib, linux_osd_jail_deregister, return);
>-LIN_SDT_PROBE_DEFINE2(mib, linux_get_osname, entry, "struct thread *",
>-    "char *");
>-LIN_SDT_PROBE_DEFINE0(mib, linux_get_osname, return);
>-LIN_SDT_PROBE_DEFINE2(mib, linux_set_osname, entry, "struct thread *",
>-    "char *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_set_osname, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_get_osrelease, entry, "struct thread *",
>-    "char *");
>-LIN_SDT_PROBE_DEFINE0(mib, linux_get_osrelease, return);
>-LIN_SDT_PROBE_DEFINE1(mib, linux_kernver, entry, "struct thread *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_kernver, return, "int");
>-LIN_SDT_PROBE_DEFINE2(mib, linux_set_osrelease, entry, "struct thread *",
>-    "char *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_set_osrelease, return, "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_get_oss_version, entry, "struct thread *");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_get_oss_version, return, "int");
>-
>-LIN_SDT_PROBE_DEFINE2(mib, linux_set_oss_version, entry, "struct thread *",
>-    "int");
>-LIN_SDT_PROBE_DEFINE1(mib, linux_set_oss_version, return, "int");
>-
> struct linux_prison {
> 	char	pr_osname[LINUX_MAX_UTSNAME];
> 	char	pr_osrelease[LINUX_MAX_UTSNAME];
>@@ -130,15 +53,14 @@
> 
> static struct linux_prison lprison0 = {
> 	.pr_osname =		"Linux",
>-	.pr_osrelease =		"2.6.18",
>+	.pr_osrelease =		LINUX_VERSION_STR,
> 	.pr_oss_version =	0x030600,
>-	.pr_osrel =		2006018
>+	.pr_osrel =		LINUX_VERSION_CODE
> };
> 
> static unsigned linux_osd_jail_slot;
> 
>-static SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0,
>-	    "Linux mode");
>+SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0, "Linux mode");
> 
> static int	linux_set_osname(struct thread *td, char *osname);
> static int	linux_set_osrelease(struct thread *td, char *osrelease);
>@@ -150,19 +72,12 @@
> 	char osname[LINUX_MAX_UTSNAME];
> 	int error;
> 
>-	LIN_SDT_PROBE0(mib, linux_sysctl_osname, entry);
>-
> 	linux_get_osname(req->td, osname);
> 	error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req);
>-	if (error != 0 || req->newptr == NULL) {
>-		LIN_SDT_PROBE1(mib, linux_sysctl_osname, sysctl_string_error,
>-		    error);
>-		LIN_SDT_PROBE1(mib, linux_sysctl_osname, return, error);
>+	if (error != 0 || req->newptr == NULL)
> 		return (error);
>-	}
> 	error = linux_set_osname(req->td, osname);
> 
>-	LIN_SDT_PROBE1(mib, linux_sysctl_osname, return, error);
> 	return (error);
> }
> 
>@@ -177,19 +92,12 @@
> 	char osrelease[LINUX_MAX_UTSNAME];
> 	int error;
> 
>-	LIN_SDT_PROBE0(mib, linux_sysctl_osrelease, entry);
>-
> 	linux_get_osrelease(req->td, osrelease);
> 	error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req);
>-	if (error != 0 || req->newptr == NULL) {
>-		LIN_SDT_PROBE1(mib, linux_sysctl_osrelease, sysctl_string_error,
>-		    error);
>-		LIN_SDT_PROBE1(mib, linux_sysctl_osrelease, return, error);
>+	if (error != 0 || req->newptr == NULL)
> 		return (error);
>-	}
> 	error = linux_set_osrelease(req->td, osrelease);
> 
>-	LIN_SDT_PROBE1(mib, linux_sysctl_osrelease, return, error);
> 	return (error);
> }
> 
>@@ -204,19 +112,12 @@
> 	int oss_version;
> 	int error;
> 
>-	LIN_SDT_PROBE0(mib, linux_sysctl_oss_version, entry);
>-
> 	oss_version = linux_get_oss_version(req->td);
> 	error = sysctl_handle_int(oidp, &oss_version, 0, req);
>-	if (error != 0 || req->newptr == NULL) {
>-		LIN_SDT_PROBE1(mib, linux_sysctl_oss_version,
>-		    sysctl_string_error, error);
>-		LIN_SDT_PROBE1(mib, linux_sysctl_oss_version, return, error);
>+	if (error != 0 || req->newptr == NULL)
> 		return (error);
>-	}
> 	error = linux_set_oss_version(req->td, oss_version);
> 
>-	LIN_SDT_PROBE1(mib, linux_sysctl_oss_version, return, error);
> 	return (error);
> }
> 
>@@ -234,37 +135,26 @@
> 	char *sep, *eosrelease;
> 	int len, v0, v1, v2, v;
> 
>-	LIN_SDT_PROBE2(mib, linux_map_osrel, entry, osrelease, osrel);
>-
> 	len = strlen(osrelease);
> 	eosrelease = osrelease + len;
> 	v0 = strtol(osrelease, &sep, 10);
>-	if (osrelease == sep || sep + 1 >= eosrelease || *sep != '.') {
>-		LIN_SDT_PROBE1(mib, linux_map_osrel, return, EINVAL);
>+	if (osrelease == sep || sep + 1 >= eosrelease || *sep != '.')
> 		return (EINVAL);
>-	}
> 	osrelease = sep + 1;
> 	v1 = strtol(osrelease, &sep, 10);
>-	if (osrelease == sep || sep + 1 >= eosrelease || *sep != '.') {
>-		LIN_SDT_PROBE1(mib, linux_map_osrel, return, EINVAL);
>+	if (osrelease == sep || sep + 1 >= eosrelease || *sep != '.')
> 		return (EINVAL);
>-	}
> 	osrelease = sep + 1;
> 	v2 = strtol(osrelease, &sep, 10);
>-	if (osrelease == sep || sep != eosrelease) {
>-		LIN_SDT_PROBE1(mib, linux_map_osrel, return, EINVAL);
>+	if (osrelease == sep || sep != eosrelease)
> 		return (EINVAL);
>-	}
> 
> 	v = v0 * 1000000 + v1 * 1000 + v2;
>-	if (v < 1000000) {
>-		LIN_SDT_PROBE1(mib, linux_map_osrel, return, EINVAL);
>+	if (v < 1000000)
> 		return (EINVAL);
>-	}
> 
> 	*osrel = v;
> 
>-	LIN_SDT_PROBE1(mib, linux_map_osrel, return, 0);
> 	return (0);
> }
> 
>@@ -278,8 +168,6 @@
> 	struct prison *pr;
> 	struct linux_prison *lpr;
> 
>-	LIN_SDT_PROBE2(mib, linux_get_prison, entry, spr, prp);
>-
> 	if (!linux_osd_jail_slot)
> 		/* In case osd_register failed. */
> 		spr = &prison0;
>@@ -294,7 +182,6 @@
> 	}
> 	*prp = pr;
> 
>-	LIN_SDT_PROBE1(mib, linux_get_prison, return, lpr);
> 	return (lpr);
> }
> 
>@@ -309,8 +196,6 @@
> 	struct linux_prison *lpr, *nlpr;
> 	int error;
> 
>-	LIN_SDT_PROBE2(mib, linux_alloc_prison, entry, pr, lprp);
>-
> 	/* If this prison already has Linux info, return that. */
> 	error = 0;
> 	lpr = linux_find_prison(pr, &ppr);
>@@ -344,7 +229,6 @@
> 	else
> 		mtx_unlock(&pr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_alloc_prison, return, error);
> 	return (error);
> }
> 
>@@ -356,26 +240,16 @@
> {
> 	struct prison *pr = obj;
> 	struct vfsoptlist *opts = data;
>-	int jsys, error;
>+	int jsys;
> 
>-	LIN_SDT_PROBE2(mib, linux_prison_create, entry, obj, data);
>-
>-	error = vfs_copyopt(opts, "linux", &jsys, sizeof(jsys));
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(mib, linux_prison_create, vfs_copyopt_error,
>-		    error);
>-	} else if (jsys == JAIL_SYS_INHERIT) {
>-		LIN_SDT_PROBE1(mib, linux_prison_create, return, 0);
>+	if (vfs_copyopt(opts, "linux", &jsys, sizeof(jsys)) == 0 &&
>+	    jsys == JAIL_SYS_INHERIT)
> 		return (0);
>-	}
> 	/*
> 	 * Inherit a prison's initial values from its parent
> 	 * (different from JAIL_SYS_INHERIT which also inherits changes).
> 	 */
>-	error = linux_alloc_prison(pr, NULL);
>-
>-	LIN_SDT_PROBE1(mib, linux_prison_create, return, error);
>-	return (error);
>+	return (linux_alloc_prison(pr, NULL));
> }
> 
> static int
>@@ -385,80 +259,46 @@
> 	char *osname, *osrelease;
> 	int error, jsys, len, osrel, oss_version;
> 
>-	LIN_SDT_PROBE2(mib, linux_prison_check, entry, obj, data);
>-
> 	/* Check that the parameters are correct. */
> 	error = vfs_copyopt(opts, "linux", &jsys, sizeof(jsys));
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(mib, linux_prison_check, vfs_copyopt_error,
>-		    error);
>-	}
> 	if (error != ENOENT) {
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, error);
>+		if (error != 0)
> 			return (error);
>-		}
>-		if (jsys != JAIL_SYS_NEW && jsys != JAIL_SYS_INHERIT) {
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, EINVAL);
>+		if (jsys != JAIL_SYS_NEW && jsys != JAIL_SYS_INHERIT)
> 			return (EINVAL);
>-		}
> 	}
> 	error = vfs_getopt(opts, "linux.osname", (void **)&osname, &len);
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(mib, linux_prison_check, vfs_getopt_error,
>-		    error);
>-	}
> 	if (error != ENOENT) {
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, error);
>+		if (error != 0)
> 			return (error);
>-		}
>-		if (len == 0 || osname[len - 1] != '\0') {
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, EINVAL);
>+		if (len == 0 || osname[len - 1] != '\0')
> 			return (EINVAL);
>-		}
> 		if (len > LINUX_MAX_UTSNAME) {
> 			vfs_opterror(opts, "linux.osname too long");
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return,
>-			    ENAMETOOLONG);
> 			return (ENAMETOOLONG);
> 		}
> 	}
> 	error = vfs_getopt(opts, "linux.osrelease", (void **)&osrelease, &len);
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(mib, linux_prison_check, vfs_getopt_error,
>-		    error);
>-	}
> 	if (error != ENOENT) {
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, error);
>+		if (error != 0)
> 			return (error);
>-		}
>-		if (len == 0 || osrelease[len - 1] != '\0') {
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, EINVAL);
>+		if (len == 0 || osrelease[len - 1] != '\0')
> 			return (EINVAL);
>-		}
> 		if (len > LINUX_MAX_UTSNAME) {
> 			vfs_opterror(opts, "linux.osrelease too long");
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return,
>-			    ENAMETOOLONG);
> 			return (ENAMETOOLONG);
> 		}
> 		error = linux_map_osrel(osrelease, &osrel);
> 		if (error != 0) {
> 			vfs_opterror(opts, "linux.osrelease format error");
>-			LIN_SDT_PROBE1(mib, linux_prison_check, return, error);
> 			return (error);
> 		}
> 	}
> 	error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
> 	    sizeof(oss_version));
>-	if (error != 0)
>-	    LIN_SDT_PROBE1(mib, linux_prison_check, vfs_copyopt_error, error);
> 
> 	if (error == ENOENT)
> 		error = 0;
>-	LIN_SDT_PROBE1(mib, linux_prison_check, return, error);
> 	return (error);
> }
> 
>@@ -471,24 +311,16 @@
> 	char *osname, *osrelease;
> 	int error, gotversion, jsys, len, oss_version;
> 
>-	LIN_SDT_PROBE2(mib, linux_prison_set, entry, obj, data);
>-
> 	/* Set the parameters, which should be correct. */
> 	error = vfs_copyopt(opts, "linux", &jsys, sizeof(jsys));
>-	if (error != 0)
>-		LIN_SDT_PROBE1(mib, linux_prison_set, vfs_copyopt_error, error);
> 	if (error == ENOENT)
> 		jsys = -1;
> 	error = vfs_getopt(opts, "linux.osname", (void **)&osname, &len);
>-	if (error != 0)
>-		LIN_SDT_PROBE1(mib, linux_prison_set, vfs_getopt_error, error);
> 	if (error == ENOENT)
> 		osname = NULL;
> 	else
> 		jsys = JAIL_SYS_NEW;
> 	error = vfs_getopt(opts, "linux.osrelease", (void **)&osrelease, &len);
>-	if (error != 0)
>-		LIN_SDT_PROBE1(mib, linux_prison_set, vfs_getopt_error, error);
> 	if (error == ENOENT)
> 		osrelease = NULL;
> 	else
>@@ -495,8 +327,6 @@
> 		jsys = JAIL_SYS_NEW;
> 	error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
> 	    sizeof(oss_version));
>-	if (error != 0)
>-		LIN_SDT_PROBE1(mib, linux_prison_set, vfs_copyopt_error, error);
> 	if (error == ENOENT)
> 		gotversion = 0;
> 	else {
>@@ -518,7 +348,6 @@
> 		error = linux_alloc_prison(pr, &lpr);
> 		if (error) {
> 			mtx_unlock(&pr->pr_mtx);
>-			LIN_SDT_PROBE1(mib, linux_prison_set, return, error);
> 			return (error);
> 		}
> 		if (osrelease) {
>@@ -525,8 +354,6 @@
> 			error = linux_map_osrel(osrelease, &lpr->pr_osrel);
> 			if (error) {
> 				mtx_unlock(&pr->pr_mtx);
>-				LIN_SDT_PROBE1(mib, linux_prison_set, return,
>-				    error);
> 				return (error);
> 			}
> 			strlcpy(lpr->pr_osrelease, osrelease,
>@@ -539,7 +366,6 @@
> 		mtx_unlock(&pr->pr_mtx);
> 	}
> 
>-	LIN_SDT_PROBE1(mib, linux_prison_set, return, 0);
> 	return (0);
> }
> 
>@@ -562,40 +388,23 @@
> 
> 	static int version0;
> 
>-	LIN_SDT_PROBE2(mib, linux_prison_get, entry, obj, data);
>-
> 	/* See if this prison is the one with the Linux info. */
> 	lpr = linux_find_prison(pr, &ppr);
> 	i = (ppr == pr) ? JAIL_SYS_NEW : JAIL_SYS_INHERIT;
> 	error = vfs_setopt(opts, "linux", &i, sizeof(i));
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopt_error, error);
>-		if (error != ENOENT)
>-			goto done;
>-	}
>+	if (error != 0 && error != ENOENT)
>+		goto done;
> 	if (i) {
> 		error = vfs_setopts(opts, "linux.osname", lpr->pr_osname);
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopts_error,
>-			    error);
>-			if (error != ENOENT)
>-				goto done;
>-		}
>+		if (error != 0 && error != ENOENT)
>+			goto done;
> 		error = vfs_setopts(opts, "linux.osrelease", lpr->pr_osrelease);
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopts_error,
>-			    error);
>-			if (error != ENOENT)
>-				goto done;
>-		}
>+		if (error != 0 && error != ENOENT)
>+			goto done;
> 		error = vfs_setopt(opts, "linux.oss_version",
> 		    &lpr->pr_oss_version, sizeof(lpr->pr_oss_version));
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopt_error,
>-			    error);
>-			if(error != ENOENT)
>-				goto done;
>-		}
>+		if (error != 0 && error != ENOENT)
>+			goto done;
> 	} else {
> 		/*
> 		 * If this prison is inheriting its Linux info, report
>@@ -602,27 +411,15 @@
> 		 * empty/zero parameters.
> 		 */
> 		error = vfs_setopts(opts, "linux.osname", "");
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopts_error,
>-			    error);
>-			if(error != ENOENT)
>-				goto done;
>-		}
>+		if (error != 0 && error != ENOENT)
>+			goto done;
> 		error = vfs_setopts(opts, "linux.osrelease", "");
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopts_error,
>-			    error);
>-			if(error != ENOENT)
>-				goto done;
>-		}
>+		if (error != 0 && error != ENOENT)
>+			goto done;
> 		error = vfs_setopt(opts, "linux.oss_version", &version0,
> 		    sizeof(lpr->pr_oss_version));
>-		if (error != 0) {
>-			LIN_SDT_PROBE1(mib, linux_prison_get, vfs_setopt_error,
>-			    error);
>-			if(error != ENOENT)
>-				goto done;
>-		}
>+		if (error != 0 && error != ENOENT)
>+			goto done;
> 	}
> 	error = 0;
> 
>@@ -629,7 +426,6 @@
>  done:
> 	mtx_unlock(&ppr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_prison_get, return, error);
> 	return (error);
> }
> 
>@@ -637,9 +433,7 @@
> linux_prison_destructor(void *data)
> {
> 
>-	LIN_SDT_PROBE1(mib, linux_prison_destructor, entry, data);
> 	free(data, M_PRISON);
>-	LIN_SDT_PROBE0(mib, linux_prison_destructor, return);
> }
> 
> void
>@@ -653,8 +447,6 @@
> 	    [PR_METHOD_CHECK] =		linux_prison_check
> 	};
> 
>-	LIN_SDT_PROBE0(mib, linux_osd_jail_register, entry);
>-
> 	linux_osd_jail_slot =
> 	    osd_jail_register(linux_prison_destructor, methods);
> 	if (linux_osd_jail_slot > 0) {
>@@ -664,8 +456,6 @@
> 			(void)linux_alloc_prison(pr, NULL);
> 		sx_xunlock(&allprison_lock);
> 	}
>-
>-	LIN_SDT_PROBE0(mib, linux_osd_jail_register, return);
> }
> 
> void
>@@ -672,12 +462,8 @@
> linux_osd_jail_deregister(void)
> {
> 
>-	LIN_SDT_PROBE0(mib, linux_osd_jail_register, entry);
>-
> 	if (linux_osd_jail_slot)
> 		osd_jail_deregister(linux_osd_jail_slot);
>-
>-	LIN_SDT_PROBE0(mib, linux_osd_jail_register, return);
> }
> 
> void
>@@ -686,13 +472,9 @@
> 	struct prison *pr;
> 	struct linux_prison *lpr;
> 
>-	LIN_SDT_PROBE2(mib, linux_get_osname, entry, td, dst);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME);
> 	mtx_unlock(&pr->pr_mtx);
>-
>-	LIN_SDT_PROBE0(mib, linux_get_osname, return);
> }
> 
> static int
>@@ -701,13 +483,10 @@
> 	struct prison *pr;
> 	struct linux_prison *lpr;
> 
>-	LIN_SDT_PROBE2(mib, linux_set_osname, entry, td, osname);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	strlcpy(lpr->pr_osname, osname, LINUX_MAX_UTSNAME);
> 	mtx_unlock(&pr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_set_osname, return, 0);
> 	return (0);
> }
> 
>@@ -717,13 +496,9 @@
> 	struct prison *pr;
> 	struct linux_prison *lpr;
> 
>-	LIN_SDT_PROBE2(mib, linux_get_osrelease, entry, td, dst);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	bcopy(lpr->pr_osrelease, dst, LINUX_MAX_UTSNAME);
> 	mtx_unlock(&pr->pr_mtx);
>-
>-	LIN_SDT_PROBE0(mib, linux_get_osrelease, return);
> }
> 
> int
>@@ -733,13 +508,10 @@
> 	struct linux_prison *lpr;
> 	int osrel;
> 
>-	LIN_SDT_PROBE1(mib, linux_kernver, entry, td);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	osrel = lpr->pr_osrel;
> 	mtx_unlock(&pr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_kernver, return, osrel);
> 	return (osrel);
> }
> 
>@@ -750,8 +522,6 @@
> 	struct linux_prison *lpr;
> 	int error;
> 
>-	LIN_SDT_PROBE2(mib, linux_set_osrelease, entry, td, osrelease);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	error = linux_map_osrel(osrelease, &lpr->pr_osrel);
> 	if (error == 0)
>@@ -758,7 +528,6 @@
> 		strlcpy(lpr->pr_osrelease, osrelease, LINUX_MAX_UTSNAME);
> 	mtx_unlock(&pr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_set_osrelease, return, error);
> 	return (error);
> }
> 
>@@ -769,13 +538,10 @@
> 	struct linux_prison *lpr;
> 	int version;
> 
>-	LIN_SDT_PROBE1(mib, linux_get_oss_version, entry, td);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	version = lpr->pr_oss_version;
> 	mtx_unlock(&pr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_get_oss_version, return, version);
> 	return (version);
> }
> 
>@@ -785,74 +551,9 @@
> 	struct prison *pr;
> 	struct linux_prison *lpr;
> 
>-	LIN_SDT_PROBE2(mib, linux_set_oss_version, entry, td, oss_version);
>-
> 	lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
> 	lpr->pr_oss_version = oss_version;
> 	mtx_unlock(&pr->pr_mtx);
> 
>-	LIN_SDT_PROBE1(mib, linux_set_oss_version, return, 0);
> 	return (0);
> }
>-
>-#if defined(DEBUG) || defined(KTR)
>-/* XXX: can be removed when every ldebug(...) and KTR stuff are removed. */
>-
>-u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
>-
>-static int
>-linux_debug(int syscall, int toggle, int global)
>-{
>-
>-	if (global) {
>-		char c = toggle ? 0 : 0xff;
>-
>-		memset(linux_debug_map, c, sizeof(linux_debug_map));
>-		return (0);
>-	}
>-	if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL)
>-		return (EINVAL);
>-	if (toggle)
>-		clrbit(linux_debug_map, syscall);
>-	else
>-		setbit(linux_debug_map, syscall);
>-	return (0);
>-}
>-
>-/*
>- * Usage: sysctl linux.debug=<syscall_nr>.<0/1>
>- *
>- *    E.g.: sysctl linux.debug=21.0
>- *
>- * As a special case, syscall "all" will apply to all syscalls globally.
>- */
>-#define LINUX_MAX_DEBUGSTR	16
>-static int
>-linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
>-{
>-	char value[LINUX_MAX_DEBUGSTR], *p;
>-	int error, sysc, toggle;
>-	int global = 0;
>-
>-	value[0] = '\0';
>-	error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
>-	if (error || req->newptr == NULL)
>-		return (error);
>-	for (p = value; *p != '\0' && *p != '.'; p++);
>-	if (*p == '\0')
>-		return (EINVAL);
>-	*p++ = '\0';
>-	sysc = strtol(value, NULL, 0);
>-	toggle = strtol(p, NULL, 0);
>-	if (strcmp(value, "all") == 0)
>-		global = 1;
>-	error = linux_debug(sysc, toggle, global);
>-	return (error);
>-}
>-
>-SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
>-            CTLTYPE_STRING | CTLFLAG_RW,
>-            0, 0, linux_sysctl_debug, "A",
>-            "Linux debugging control");
>-
>-#endif /* DEBUG || KTR */
>Index: sys/compat/linux/linux_mib.h
>===================================================================
>--- sys/compat/linux/linux_mib.h	(revision 285633)
>+++ sys/compat/linux/linux_mib.h	(working copy)
>@@ -31,6 +31,10 @@
> #ifndef _LINUX_MIB_H_
> #define _LINUX_MIB_H_
> 
>+#ifdef SYSCTL_DECL
>+SYSCTL_DECL(_compat_linux);
>+#endif
>+
> void	linux_osd_jail_register(void);
> void	linux_osd_jail_deregister(void);
> 
>@@ -42,9 +46,20 @@
> 
> int	linux_kernver(struct thread *td);
> 
>-#define	LINUX_KERNVER_2004000		2004000
>-#define	LINUX_KERNVER_2006000		2006000
>+#define	LINUX_KVERSION		2
>+#define	LINUX_KPATCHLEVEL	6
>+#define	LINUX_KSUBLEVEL		32
> 
>+#define	LINUX_KERNVER(a,b,c)	(((a) << 16) + ((b) << 8) + (c))
>+#define	LINUX_VERSION_CODE	LINUX_KERNVER(LINUX_KVERSION,		\
>+				    LINUX_KPATCHLEVEL, LINUX_KSUBLEVEL)
>+#define	LINUX_KERNVERSTR(x)	#x
>+#define	LINUX_XKERNVERSTR(x)	LINUX_KERNVERSTR(x)
>+#define	LINUX_VERSION_STR	LINUX_XKERNVERSTR(LINUX_KVERSION.LINUX_KPATCHLEVEL.LINUX_KSUBLEVEL)
>+
>+#define	LINUX_KERNVER_2004000	LINUX_KERNVER(2,4,0)
>+#define	LINUX_KERNVER_2006000	LINUX_KERNVER(2,6,0)
>+
> #define	linux_use26(t)		(linux_kernver(t) >= LINUX_KERNVER_2006000)
> 
> #endif /* _LINUX_MIB_H_ */
>Index: sys/compat/linux/linux_misc.c
>===================================================================
>--- sys/compat/linux/linux_misc.c	(revision 285633)
>+++ sys/compat/linux/linux_misc.c	(working copy)
>@@ -89,22 +89,25 @@
> #include <compat/linux/linux_file.h>
> #include <compat/linux/linux_mib.h>
> #include <compat/linux/linux_signal.h>
>+#include <compat/linux/linux_timer.h>
> #include <compat/linux/linux_util.h>
> #include <compat/linux/linux_sysproto.h>
> #include <compat/linux/linux_emul.h>
> #include <compat/linux/linux_misc.h>
> 
>-/* DTrace init */
>-LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
>+/**
>+ * Special DTrace provider for the linuxulator.
>+ *
>+ * In this file we define the provider for the entire linuxulator. All
>+ * modules (= files of the linuxulator) use it.
>+ *
>+ * We define a different name depending on the emulated bitsize, see
>+ * ../../<ARCH>/linux{,32}/linux.h, e.g.:
>+ *      native bitsize          = linuxulator
>+ *      amd64, 32bit emulation  = linuxulator32
>+ */
>+LIN_SDT_PROVIDER_DEFINE(LINUX_DTRACE);
> 
>-/* Linuxulator-global DTrace probes */
>-LIN_SDT_PROBE_DECLARE(locks, emul_lock, locked);
>-LIN_SDT_PROBE_DECLARE(locks, emul_lock, unlock);
>-LIN_SDT_PROBE_DECLARE(locks, emul_shared_rlock, locked);
>-LIN_SDT_PROBE_DECLARE(locks, emul_shared_rlock, unlock);
>-LIN_SDT_PROBE_DECLARE(locks, emul_shared_wlock, locked);
>-LIN_SDT_PROBE_DECLARE(locks, emul_shared_wlock, unlock);
>-
> int stclohz;				/* Statistics clock frequency */
> 
> static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = {
>@@ -130,6 +133,13 @@
> 	l_uint		mem_unit;
> 	char		_f[20-2*sizeof(l_long)-sizeof(l_int)];	/* padding */
> };
>+
>+struct l_pselect6arg {
>+	l_uintptr_t	ss;
>+	l_size_t	ss_len;
>+};
>+
>+
> int
> linux_sysinfo(struct thread *td, struct linux_sysinfo_args *args)
> {
>@@ -524,7 +534,7 @@
> 		tvp = NULL;
> 
> 	error = kern_select(td, args->nfds, args->readfds, args->writefds,
>-	    args->exceptfds, tvp, sizeof(l_int) * 8);
>+	    args->exceptfds, tvp, sizeof(l_fd_mask) * 8);
> 
> #ifdef DEBUG
> 	if (ldebug(select))
>@@ -691,9 +701,9 @@
> 	if (args->buf != NULL) {
> 		p = td->td_proc;
> 		PROC_LOCK(p);
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 		calcru(p, &utime, &stime);
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> 		calccru(p, &cutime, &cstime);
> 		PROC_UNLOCK(p);
> 
>@@ -739,12 +749,11 @@
> 			*p = '\0';
> 			break;
> 		}
>-	strlcpy(utsname.machine, linux_platform, LINUX_MAX_UTSNAME);
>+	strlcpy(utsname.machine, linux_kplatform, LINUX_MAX_UTSNAME);
> 
> 	return (copyout(&utsname, args->buf, sizeof(utsname)));
> }
> 
>-#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> struct l_utimbuf {
> 	l_time_t l_actime;
> 	l_time_t l_modtime;
>@@ -815,6 +824,12 @@
> 	return (error);
> }
> 
>+int 
>+linux_utimensat(struct thread *td, struct linux_utimensat_args *args)
>+{
>+	return (ENOSYS);
>+}
>+
> int
> linux_futimesat(struct thread *td, struct linux_futimesat_args *args)
> {
>@@ -847,7 +862,6 @@
> 	LFREEPATH(fname);
> 	return (error);
> }
>-#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_common_wait(struct thread *td, int pid, int *status,
>@@ -863,10 +877,12 @@
> 		tmpstat &= 0xffff;
> 		if (WIFSIGNALED(tmpstat))
> 			tmpstat = (tmpstat & 0xffffff80) |
>-			    BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat));
>+			    bsd_to_linux_signal(WTERMSIG(tmpstat));
> 		else if (WIFSTOPPED(tmpstat))
> 			tmpstat = (tmpstat & 0xffff00ff) |
>-			    (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8);
>+			    (bsd_to_linux_signal(WSTOPSIG(tmpstat)) << 8);
>+		else if (WIFCONTINUED(tmpstat))
>+			tmpstat = 0xffff;
> 		error = copyout(&tmpstat, status, sizeof(int));
> 	}
> 
>@@ -873,6 +889,7 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_waitpid(struct thread *td, struct linux_waitpid_args *args)
> {
>@@ -883,20 +900,16 @@
> 		printf(ARGS(waitpid, "%d, %p, %d"),
> 		    args->pid, (void *)args->status, args->options);
> #endif
>-	/*
>-	 * this is necessary because the test in kern_wait doesn't work
>-	 * because we mess with the options here
>-	 */
>-	if (args->options & ~(WUNTRACED | WNOHANG | WCONTINUED | __WCLONE))
>+	if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |
>+	    LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))
> 		return (EINVAL);
>-   
>-	options = (args->options & (WNOHANG | WUNTRACED));
>-	/* WLINUXCLONE should be equal to __WCLONE, but we make sure */
>-	if (args->options & __WCLONE)
>-		options |= WLINUXCLONE;
> 
>+	options = WEXITED;
>+	linux_to_bsd_waitopts(args->options, &options);
>+
> 	return (linux_common_wait(td, args->pid, args->status, options, NULL));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> 
> int
>@@ -909,7 +922,8 @@
> 
> #ifdef DEBUG
> 	if (ldebug(mknod))
>-		printf(ARGS(mknod, "%s, %d, %d"), path, args->mode, args->dev);
>+		printf(ARGS(mknod, "%s, %d, %ju"), path, args->mode,
>+		    (uintmax_t)args->dev);
> #endif
> 
> 	switch (args->mode & S_IFMT) {
>@@ -1079,6 +1093,7 @@
> 	return (copyout(&ls, uap->itv, sizeof(ls)));
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_nice(struct thread *td, struct linux_nice_args *args)
> {
>@@ -1089,6 +1104,7 @@
> 	bsd_args.prio = args->inc;
> 	return (sys_setpriority(td, &bsd_args));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_setgroups(struct thread *td, struct linux_setgroups_args *args)
>@@ -1102,7 +1118,7 @@
> 	ngrp = args->gidsetsize;
> 	if (ngrp < 0 || ngrp >= ngroups_max + 1)
> 		return (EINVAL);
>-	linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_TEMP, M_WAITOK);
>+	linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_LINUX, M_WAITOK);
> 	error = copyin(args->grouplist, linux_gidset, ngrp * sizeof(l_gid_t));
> 	if (error)
> 		goto out;
>@@ -1141,7 +1157,7 @@
> 	crfree(oldcred);
> 	error = 0;
> out:
>-	free(linux_gidset, M_TEMP);
>+	free(linux_gidset, M_LINUX);
> 	return (error);
> }
> 
>@@ -1173,7 +1189,7 @@
> 
> 	ngrp = 0;
> 	linux_gidset = malloc(bsd_gidsetsz * sizeof(*linux_gidset),
>-	    M_TEMP, M_WAITOK);
>+	    M_LINUX, M_WAITOK);
> 	while (ngrp < bsd_gidsetsz) {
> 		linux_gidset[ngrp] = bsd_gidset[ngrp + 1];
> 		ngrp++;
>@@ -1180,7 +1196,7 @@
> 	}
> 
> 	error = copyout(linux_gidset, args->grouplist, ngrp * sizeof(l_gid_t));
>-	free(linux_gidset, M_TEMP);
>+	free(linux_gidset, M_LINUX);
> 	if (error)
> 		return (error);
> 
>@@ -1218,6 +1234,7 @@
> 	return (kern_setrlimit(td, which, &bsd_rlim));
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
> {
>@@ -1260,6 +1277,7 @@
> #endif
> 	return (copyout(&rlim, args->rlim, sizeof(rlim)));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
>@@ -1295,7 +1313,9 @@
> linux_sched_setscheduler(struct thread *td,
>     struct linux_sched_setscheduler_args *args)
> {
>-	struct sched_setscheduler_args bsd;
>+	struct sched_param sched_param;
>+	struct thread *tdt;
>+	int error, policy;
> 
> #ifdef DEBUG
> 	if (ldebug(sched_setscheduler))
>@@ -1305,21 +1325,29 @@
> 
> 	switch (args->policy) {
> 	case LINUX_SCHED_OTHER:
>-		bsd.policy = SCHED_OTHER;
>+		policy = SCHED_OTHER;
> 		break;
> 	case LINUX_SCHED_FIFO:
>-		bsd.policy = SCHED_FIFO;
>+		policy = SCHED_FIFO;
> 		break;
> 	case LINUX_SCHED_RR:
>-		bsd.policy = SCHED_RR;
>+		policy = SCHED_RR;
> 		break;
> 	default:
> 		return (EINVAL);
> 	}
> 
>-	bsd.pid = args->pid;
>-	bsd.param = (struct sched_param *)args->param;
>-	return (sys_sched_setscheduler(td, &bsd));
>+	error = copyin(args->param, &sched_param, sizeof(sched_param));
>+	if (error)
>+		return (error);
>+
>+	tdt = linux_tdfind(td, args->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	error = kern_sched_setscheduler(td, tdt, policy, &sched_param);
>+	PROC_UNLOCK(tdt->td_proc);
>+	return (error);
> }
> 
> int
>@@ -1326,8 +1354,8 @@
> linux_sched_getscheduler(struct thread *td,
>     struct linux_sched_getscheduler_args *args)
> {
>-	struct sched_getscheduler_args bsd;
>-	int error;
>+	struct thread *tdt;
>+	int error, policy;
> 
> #ifdef DEBUG
> 	if (ldebug(sched_getscheduler))
>@@ -1334,10 +1362,14 @@
> 		printf(ARGS(sched_getscheduler, "%d"), args->pid);
> #endif
> 
>-	bsd.pid = args->pid;
>-	error = sys_sched_getscheduler(td, &bsd);
>+	tdt = linux_tdfind(td, args->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
> 
>-	switch (td->td_retval[0]) {
>+	error = kern_sched_getscheduler(td, tdt, &policy);
>+	PROC_UNLOCK(tdt->td_proc);
>+
>+	switch (policy) {
> 	case SCHED_OTHER:
> 		td->td_retval[0] = LINUX_SCHED_OTHER;
> 		break;
>@@ -1348,7 +1380,6 @@
> 		td->td_retval[0] = LINUX_SCHED_RR;
> 		break;
> 	}
>-
> 	return (error);
> }
> 
>@@ -1474,21 +1505,13 @@
> int
> linux_getpid(struct thread *td, struct linux_getpid_args *args)
> {
>-	struct linux_emuldata *em;
> 
> #ifdef DEBUG
> 	if (ldebug(getpid))
> 		printf(ARGS(getpid, ""));
> #endif
>+	td->td_retval[0] = td->td_proc->p_pid;
> 
>-	if (linux_use26(td)) {
>-		em = em_find(td->td_proc, EMUL_DONTLOCK);
>-		KASSERT(em != NULL, ("getpid: emuldata not found.\n"));
>-		td->td_retval[0] = em->shared->group_pid;
>-	} else {
>-		td->td_retval[0] = td->td_proc->p_pid;
>-	}
>-
> 	return (0);
> }
> 
>@@ -1495,6 +1518,7 @@
> int
> linux_gettid(struct thread *td, struct linux_gettid_args *args)
> {
>+	struct linux_emuldata *em;
> 
> #ifdef DEBUG
> 	if (ldebug(gettid))
>@@ -1501,7 +1525,11 @@
> 		printf(ARGS(gettid, ""));
> #endif
> 
>-	td->td_retval[0] = td->td_proc->p_pid;
>+	em = em_find(td);
>+	KASSERT(em != NULL, ("gettid: emuldata not found.\n"));
>+
>+	td->td_retval[0] = em->em_tid;
>+
> 	return (0);
> }
> 
>@@ -1509,8 +1537,6 @@
> int
> linux_getppid(struct thread *td, struct linux_getppid_args *args)
> {
>-	struct linux_emuldata *em;
>-	struct proc *p, *pp;
> 
> #ifdef DEBUG
> 	if (ldebug(getppid))
>@@ -1517,42 +1543,9 @@
> 		printf(ARGS(getppid, ""));
> #endif
> 
>-	if (!linux_use26(td)) {
>-		PROC_LOCK(td->td_proc);
>-		td->td_retval[0] = td->td_proc->p_pptr->p_pid;
>-		PROC_UNLOCK(td->td_proc);
>-		return (0);
>-	}
>-
>-	em = em_find(td->td_proc, EMUL_DONTLOCK);
>-
>-	KASSERT(em != NULL, ("getppid: process emuldata not found.\n"));
>-
>-	/* find the group leader */
>-	p = pfind(em->shared->group_pid);
>-
>-	if (p == NULL) {
>-#ifdef DEBUG
>-	   	printf(LMSG("parent process not found.\n"));
>-#endif
>-		return (0);
>-	}
>-
>-	pp = p->p_pptr;		/* switch to parent */
>-	PROC_LOCK(pp);
>-	PROC_UNLOCK(p);
>-
>-	/* if its also linux process */
>-	if (pp->p_sysent == &elf_linux_sysvec) {
>-		em = em_find(pp, EMUL_DONTLOCK);
>-		KASSERT(em != NULL, ("getppid: parent emuldata not found.\n"));
>-
>-		td->td_retval[0] = em->shared->group_pid;
>-	} else
>-		td->td_retval[0] = pp->p_pid;
>-
>-	PROC_UNLOCK(pp);
>-
>+	PROC_LOCK(td->td_proc);
>+	td->td_retval[0] = td->td_proc->p_pptr->p_pid;
>+	PROC_UNLOCK(td->td_proc);
> 	return (0);
> }
> 
>@@ -1657,7 +1650,6 @@
> int
> linux_exit_group(struct thread *td, struct linux_exit_group_args *args)
> {
>-	struct linux_emuldata *em;
> 
> #ifdef DEBUG
> 	if (ldebug(exit_group))
>@@ -1664,15 +1656,8 @@
> 		printf(ARGS(exit_group, "%i"), args->error_code);
> #endif
> 
>-	em = em_find(td->td_proc, EMUL_DONTLOCK);
>-	if (em->shared->refs > 1) {
>-		EMUL_SHARED_WLOCK(&emul_shared_lock);
>-		em->shared->flags |= EMUL_SHARED_HASXSTAT;
>-		em->shared->xstat = W_EXITCODE(args->error_code, 0);
>-		EMUL_SHARED_WUNLOCK(&emul_shared_lock);
>-		if (linux_use26(td))
>-			linux_kill_threads(td, SIGKILL);
>-	}
>+	LINUX_CTR2(exit_group, "thread(%d) (%d)", td->td_tid,
>+	    args->error_code);
> 
> 	/*
> 	 * XXX: we should send a signal to the parent if
>@@ -1680,8 +1665,7 @@
> 	 * as it doesnt occur often.
> 	 */
> 	exit1(td, W_EXITCODE(args->error_code, 0));
>-
>-	return (0);
>+		/* NOTREACHED */
> }
> 
> #define _LINUX_CAPABILITY_VERSION  0x19980330
>@@ -1789,8 +1773,9 @@
> 
> #ifdef DEBUG
> 	if (ldebug(prctl))
>-		printf(ARGS(prctl, "%d, %d, %d, %d, %d"), args->option,
>-		    args->arg2, args->arg3, args->arg4, args->arg5);
>+		printf(ARGS(prctl, "%d, %ju, %ju, %ju, %ju"), args->option,
>+		    (uintmax_t)args->arg2, (uintmax_t)args->arg3,
>+		    (uintmax_t)args->arg4, (uintmax_t)args->arg5);
> #endif
> 
> 	switch (args->option) {
>@@ -1797,16 +1782,14 @@
> 	case LINUX_PR_SET_PDEATHSIG:
> 		if (!LINUX_SIG_VALID(args->arg2))
> 			return (EINVAL);
>-		em = em_find(p, EMUL_DOLOCK);
>+		em = em_find(td);
> 		KASSERT(em != NULL, ("prctl: emuldata not found.\n"));
> 		em->pdeath_signal = args->arg2;
>-		EMUL_UNLOCK(&emul_lock);
> 		break;
> 	case LINUX_PR_GET_PDEATHSIG:
>-		em = em_find(p, EMUL_DOLOCK);
>+		em = em_find(td);
> 		KASSERT(em != NULL, ("prctl: emuldata not found.\n"));
> 		pdeath_signal = em->pdeath_signal;
>-		EMUL_UNLOCK(&emul_lock);
> 		error = copyout(&pdeath_signal,
> 		    (void *)(register_t)args->arg2,
> 		    sizeof(pdeath_signal));
>@@ -1871,6 +1854,57 @@
> 	return (error);
> }
> 
>+int
>+linux_sched_setparam(struct thread *td,
>+    struct linux_sched_setparam_args *uap)
>+{
>+	struct sched_param sched_param;
>+	struct thread *tdt;
>+	int error;
>+
>+#ifdef DEBUG
>+	if (ldebug(sched_setparam))
>+		printf(ARGS(sched_setparam, "%d, *"), uap->pid);
>+#endif
>+
>+	error = copyin(uap->param, &sched_param, sizeof(sched_param));
>+	if (error)
>+		return (error);
>+
>+	tdt = linux_tdfind(td, uap->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	error = kern_sched_setparam(td, tdt, &sched_param);
>+	PROC_UNLOCK(tdt->td_proc);
>+	return (error);
>+}
>+
>+int
>+linux_sched_getparam(struct thread *td,
>+    struct linux_sched_getparam_args *uap)
>+{
>+	struct sched_param sched_param;
>+	struct thread *tdt;
>+	int error;
>+
>+#ifdef DEBUG
>+	if (ldebug(sched_getparam))
>+		printf(ARGS(sched_getparam, "%d, *"), uap->pid);
>+#endif
>+
>+	tdt = linux_tdfind(td, uap->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	error = kern_sched_getparam(td, tdt, &sched_param);
>+	PROC_UNLOCK(tdt->td_proc);
>+	if (error == 0)
>+		error = copyout(&sched_param, uap->param,
>+		    sizeof(sched_param));
>+	return (error);
>+}
>+
> /*
>  * Get affinity of a process.
>  */
>@@ -1879,6 +1913,7 @@
>     struct linux_sched_getaffinity_args *args)
> {
> 	int error;
>+	struct thread *tdt;
> 	struct cpuset_getaffinity_args cga;
> 
> #ifdef DEBUG
>@@ -1889,9 +1924,14 @@
> 	if (args->len < sizeof(cpuset_t))
> 		return (EINVAL);
> 
>+	tdt = linux_tdfind(td, args->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	PROC_UNLOCK(tdt->td_proc);
> 	cga.level = CPU_LEVEL_WHICH;
>-	cga.which = CPU_WHICH_PID;
>-	cga.id = args->pid;
>+	cga.which = CPU_WHICH_TID;
>+	cga.id = tdt->td_tid;
> 	cga.cpusetsize = sizeof(cpuset_t);
> 	cga.mask = (cpuset_t *) args->user_mask_ptr;
> 
>@@ -1909,6 +1949,7 @@
>     struct linux_sched_setaffinity_args *args)
> {
> 	struct cpuset_setaffinity_args csa;
>+	struct thread *tdt;
> 
> #ifdef DEBUG
> 	if (ldebug(sched_setaffinity))
>@@ -1918,11 +1959,351 @@
> 	if (args->len < sizeof(cpuset_t))
> 		return (EINVAL);
> 
>+	tdt = linux_tdfind(td, args->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	PROC_UNLOCK(tdt->td_proc);
> 	csa.level = CPU_LEVEL_WHICH;
>-	csa.which = CPU_WHICH_PID;
>-	csa.id = args->pid;
>+	csa.which = CPU_WHICH_TID;
>+	csa.id = tdt->td_tid;
> 	csa.cpusetsize = sizeof(cpuset_t);
> 	csa.mask = (cpuset_t *) args->user_mask_ptr;
> 
> 	return (sys_cpuset_setaffinity(td, &csa));
> }
>+
>+int
>+linux_sched_rr_get_interval(struct thread *td,
>+    struct linux_sched_rr_get_interval_args *uap)
>+{
>+	struct timespec ts;
>+	struct l_timespec lts;
>+	struct thread *tdt;
>+	int error;
>+
>+	/*
>+	 * According to man in case the invalid pid specified
>+	 * EINVAL should be returned.
>+	 */
>+	if (uap->pid < 0)
>+		return (EINVAL);
>+
>+	tdt = linux_tdfind(td, uap->pid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	error = kern_sched_rr_get_interval_td(td, tdt, &ts);
>+	PROC_UNLOCK(tdt->td_proc);
>+	if (error != 0)
>+		return (error);
>+	native_to_linux_timespec(&lts, &ts);
>+	return (copyout(&lts, uap->interval, sizeof(lts)));
>+}
>+
>+/*
>+ * In case when the Linux thread is the initial thread in
>+ * the thread group thread id is equal to the process id.
>+ * Glibc depends on this magic (assert in pthread_getattr_np.c).
>+ */
>+struct thread *
>+linux_tdfind(struct thread *td, lwpid_t tid, pid_t pid)
>+{
>+	struct linux_emuldata *em;
>+	struct thread *tdt;
>+	struct proc *p;
>+
>+	tdt = NULL;
>+	if (tid == 0 || tid == td->td_tid) {
>+		tdt = td;
>+		PROC_LOCK(tdt->td_proc);
>+	} else if (tid > PID_MAX)
>+		tdt = tdfind(tid, pid);
>+	else {
>+		/*
>+		 * Initial thread where the tid equal to the pid.
>+		 */
>+		p = pfind(tid);
>+		if (p != NULL) {
>+			if (SV_PROC_ABI(p) != SV_ABI_LINUX) {
>+				/*
>+				 * p is not a Linuxulator process.
>+				 */
>+				PROC_UNLOCK(p);
>+				return (NULL);
>+			}
>+			FOREACH_THREAD_IN_PROC(p, tdt) {
>+				em = em_find(tdt);
>+				if (tid == em->em_tid)
>+					return (tdt);
>+			}
>+			PROC_UNLOCK(p);
>+		}
>+		return (NULL);
>+	}
>+
>+	return (tdt);
>+}
>+
>+void
>+linux_to_bsd_waitopts(int options, int *bsdopts)
>+{
>+
>+	if (options & LINUX_WNOHANG)
>+		*bsdopts |= WNOHANG;
>+	if (options & LINUX_WUNTRACED)
>+		*bsdopts |= WUNTRACED;
>+	if (options & LINUX_WEXITED)
>+		*bsdopts |= WEXITED;
>+	if (options & LINUX_WCONTINUED)
>+		*bsdopts |= WCONTINUED;
>+	if (options & LINUX_WNOWAIT)
>+		*bsdopts |= WNOWAIT;
>+
>+	if (options & __WCLONE)
>+		*bsdopts |= WLINUXCLONE;
>+}
>+
>+int
>+linux_prlimit64(struct thread *td, struct linux_prlimit64_args *args)
>+{
>+	struct rlimit rlim;
>+	struct proc *p;
>+	u_int which;
>+	int error;
>+
>+#ifdef DEBUG
>+	if (ldebug(prlimit64))
>+		printf(ARGS(prlimit64, "%d, %d, %p, %p"), args->pid,
>+		    args->resource, (void *)args->new, (void *)args->old);
>+#endif
>+
>+	if (args->resource >= LINUX_RLIM_NLIMITS)
>+		return (EINVAL);
>+
>+	which = linux_to_bsd_resource[args->resource];
>+	if (which == -1)
>+		return (EINVAL);
>+
>+	if (args->pid == 0) {
>+		p = td->td_proc;
>+		PROC_LOCK(p);
>+	} else {
>+		p = pfind(args->pid);
>+		if (p == NULL)
>+			return (ESRCH);
>+	}
>+	error = p_cansee(td, p);
>+	if (error) {
>+		PROC_UNLOCK(p);
>+		return (EPERM);
>+	}
>+
>+	_PHOLD(p);
>+
>+	if (args->old) {
>+		lim_rlimit(p, which, &rlim);
>+		PROC_UNLOCK(p);
>+		error = copyout(&rlim, args->old, sizeof(rlim));
>+		if (error)
>+			goto out;
>+	} else
>+		PROC_UNLOCK(p);
>+
>+	if (args->new) {
>+		error = copyin(args->new, &rlim, sizeof(rlim));
>+		if (error == 0)
>+			error = kern_proc_setrlimit(td, p, which, &rlim);
>+	}
>+out:
>+	PRELE(p);
>+	return (error);
>+}
>+
>+int
>+linux_pselect6(struct thread *td, struct linux_pselect6_args *args)
>+{
>+	struct timeval utv, tv0, tv1, *tvp;
>+	struct l_pselect6arg lpse6;
>+	struct l_timespec lts;
>+	struct timespec uts;
>+	l_sigset_t l_ss;
>+	sigset_t *ssp;
>+	sigset_t ss;
>+	int error;
>+
>+	ssp = NULL;
>+	if (args->sig) {
>+		error = copyin(args->sig, &lpse6, sizeof(lpse6));
>+		if (error)
>+			return (error);
>+		if (lpse6.ss_len != sizeof(l_ss))
>+			return (EINVAL);
>+		if (lpse6.ss != 0) {
>+			error = copyin(PTRIN(lpse6.ss), &l_ss,
>+			    sizeof(l_ss));
>+			if (error)
>+				return (error);
>+			linux_to_bsd_sigset(&l_ss, &ss);
>+			ssp = &ss;
>+		}
>+	}
>+
>+	/*
>+	 * Currently glibc changes nanosecond number to microsecond.
>+	 * This mean losing precision but for now it is hardly seen.
>+	 */
>+	if (args->tsp) {
>+		error = copyin(args->tsp, &lts, sizeof(lts));
>+		if (error)
>+			return (error);
>+		error = linux_to_native_timespec(&uts, &lts);
>+		if (error)
>+			return (error);
>+
>+		TIMESPEC_TO_TIMEVAL(&utv, &uts);
>+		if (itimerfix(&utv))
>+			return (EINVAL);
>+
>+		microtime(&tv0);
>+		tvp = &utv;
>+	} else
>+		tvp = NULL;
>+
>+	error = kern_pselect(td, args->nfds, args->readfds, args->writefds,
>+	    args->exceptfds, tvp, ssp, sizeof(l_int) * 8);
>+
>+	if (error == 0 && args->tsp) {
>+		if (td->td_retval[0]) {
>+			/*
>+			 * Compute how much time was left of the timeout,
>+			 * by subtracting the current time and the time
>+			 * before we started the call, and subtracting
>+			 * that result from the user-supplied value.
>+			 */
>+
>+			microtime(&tv1);
>+			timevalsub(&tv1, &tv0);
>+			timevalsub(&utv, &tv1);
>+			if (utv.tv_sec < 0)
>+				timevalclear(&utv);
>+		} else
>+			timevalclear(&utv);
>+
>+		TIMEVAL_TO_TIMESPEC(&utv, &uts);
>+		native_to_linux_timespec(&lts, &uts);
>+		error = copyout(&lts, args->tsp, sizeof(lts));
>+	}
>+
>+	return (error);
>+}
>+
>+int
>+linux_ppoll(struct thread *td, struct linux_ppoll_args *args)
>+{
>+	struct timespec ts0, ts1;
>+	struct l_timespec lts;
>+	struct timespec uts, *tsp;
>+	l_sigset_t l_ss;
>+	sigset_t *ssp;
>+	sigset_t ss;
>+	int error;
>+
>+	if (args->sset != NULL) {
>+		if (args->ssize != sizeof(l_ss))
>+			return (EINVAL);
>+		error = copyin(args->sset, &l_ss, sizeof(l_ss));
>+		if (error)
>+			return (error);
>+		linux_to_bsd_sigset(&l_ss, &ss);
>+		ssp = &ss;
>+	} else
>+		ssp = NULL;
>+	if (args->tsp != NULL) {
>+		error = copyin(args->tsp, &lts, sizeof(lts));
>+		if (error)
>+			return (error);
>+		error = linux_to_native_timespec(&uts, &lts);
>+		if (error)
>+			return (error);
>+
>+		nanotime(&ts0);
>+		tsp = &uts;
>+	} else
>+		tsp = NULL;
>+
>+	error = kern_poll(td, args->fds, args->nfds, tsp, ssp);
>+
>+	if (error == 0 && args->tsp != NULL) {
>+		if (td->td_retval[0]) {
>+			nanotime(&ts1);
>+			timespecsub(&ts1, &ts0);
>+			timespecsub(&uts, &ts1);
>+			if (uts.tv_sec < 0)
>+				timespecclear(&uts);
>+		} else
>+			timespecclear(&uts);
>+
>+		native_to_linux_timespec(&lts, &uts);
>+		error = copyout(&lts, args->tsp, sizeof(lts));
>+	}
>+
>+	return (error);
>+}
>+
>+#if defined(DEBUG) || defined(KTR)
>+/* XXX: can be removed when every ldebug(...) and KTR stuff are removed. */
>+
>+u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
>+
>+static int
>+linux_debug(int syscall, int toggle, int global)
>+{
>+
>+	if (global) {
>+		char c = toggle ? 0 : 0xff;
>+
>+		memset(linux_debug_map, c, sizeof(linux_debug_map));
>+		return (0);
>+	}
>+	if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL)
>+		return (EINVAL);
>+	if (toggle)
>+		clrbit(linux_debug_map, syscall);
>+	else
>+		setbit(linux_debug_map, syscall);
>+	return (0);
>+}
>+
>+/*
>+ * Usage: sysctl linux.debug=<syscall_nr>.<0/1>
>+ *
>+ *    E.g.: sysctl linux.debug=21.0
>+ *
>+ * As a special case, syscall "all" will apply to all syscalls globally.
>+ */
>+#define LINUX_MAX_DEBUGSTR	16
>+int
>+linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
>+{
>+	char value[LINUX_MAX_DEBUGSTR], *p;
>+	int error, sysc, toggle;
>+	int global = 0;
>+
>+	value[0] = '\0';
>+	error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
>+	if (error || req->newptr == NULL)
>+		return (error);
>+	for (p = value; *p != '\0' && *p != '.'; p++);
>+	if (*p == '\0')
>+		return (EINVAL);
>+	*p++ = '\0';
>+	sysc = strtol(value, NULL, 0);
>+	toggle = strtol(p, NULL, 0);
>+	if (strcmp(value, "all") == 0)
>+		global = 1;
>+	error = linux_debug(sysc, toggle, global);
>+	return (error);
>+}
>+
>+#endif /* DEBUG || KTR */
>Index: sys/compat/linux/linux_misc.h
>===================================================================
>--- sys/compat/linux/linux_misc.h	(revision 285633)
>+++ sys/compat/linux/linux_misc.h	(working copy)
>@@ -31,6 +31,8 @@
> #ifndef _LINUX_MISC_H_
> #define	_LINUX_MISC_H_
> 
>+#include <sys/sysctl.h>
>+
> /*
>  * Miscellaneous
>  */
>@@ -55,7 +57,7 @@
> #define	LINUX_MREMAP_MAYMOVE	1
> #define	LINUX_MREMAP_FIXED	2
> 
>-extern const char *linux_platform;
>+extern const char *linux_kplatform;
> 
> /*
>  * Non-standard aux entry types used in Linux ELF binaries.
>@@ -68,8 +70,13 @@
> #define	LINUX_AT_BASE_PLATFORM	24	/* string identifying real platform, may
> 					 * differ from AT_PLATFORM.
> 					 */
>+#define	LINUX_AT_RANDOM		25	/* address of random bytes */
> #define	LINUX_AT_EXECFN		31	/* filename of program */
>+#define	LINUX_AT_SYSINFO	32	/* vsyscall */
>+#define	LINUX_AT_SYSINFO_EHDR	33	/* vdso header */
> 
>+#define	LINUX_AT_RANDOM_LEN	16	/* size of random bytes */
>+
> /* Linux sets the i387 to extended precision. */
> #if defined(__i386__) || defined(__amd64__)
> #define	__LINUX_NPXCW__		0x37f
>@@ -88,10 +95,6 @@
> #define	LINUX_CLONE_CHILD_CLEARTID	0x00200000
> #define	LINUX_CLONE_CHILD_SETTID	0x01000000
> 
>-#define	LINUX_THREADING_FLAGS					\
>-	(LINUX_CLONE_VM | LINUX_CLONE_FS | LINUX_CLONE_FILES |	\
>-	LINUX_CLONE_SIGHAND | LINUX_CLONE_THREAD)
>-
> /* Scheduling policies */
> #define	LINUX_SCHED_OTHER	0
> #define	LINUX_SCHED_FIFO	1
>@@ -113,13 +116,36 @@
> #define	LINUX_CLOCK_REALTIME_HR		4
> #define	LINUX_CLOCK_MONOTONIC_HR	5
> 
>+#define LINUX_UTIME_NOW			0x3FFFFFFF
>+#define LINUX_UTIME_OMIT		0x3FFFFFFE
>+
> extern int stclohz;
> 
>-#define __WCLONE 0x80000000
>+#define	LINUX_WNOHANG		0x00000001
>+#define	LINUX_WUNTRACED		0x00000002
>+#define	LINUX_WSTOPPED		LINUX_WUNTRACED
>+#define	LINUX_WEXITED		0x00000004
>+#define	LINUX_WCONTINUED	0x00000008
>+#define	LINUX_WNOWAIT		0x01000000
> 
>+
>+#define	__WNOTHREAD		0x20000000
>+#define	__WALL			0x40000000
>+#define	__WCLONE		0x80000000
>+
>+/* Linux waitid idtype  */
>+#define	LINUX_P_ALL		0
>+#define	LINUX_P_PID		1
>+#define	LINUX_P_PGID		2
>+
>+
> int linux_common_wait(struct thread *td, int pid, int *status,
> 			int options, struct rusage *ru);
>+void linux_to_bsd_waitopts(int options, int *bsdopts);
> int linux_set_upcall_kse(struct thread *td, register_t stack);
> int linux_set_cloned_tls(struct thread *td, void *desc);
>+struct thread	*linux_tdfind(struct thread *, lwpid_t, pid_t);
> 
>+int linux_sysctl_debug(SYSCTL_HANDLER_ARGS);
>+
> #endif	/* _LINUX_MISC_H_ */
>Index: sys/compat/linux/linux_signal.c
>===================================================================
>--- sys/compat/linux/linux_signal.c	(revision 285633)
>+++ sys/compat/linux/linux_signal.c	(working copy)
>@@ -53,41 +53,13 @@
> #include <compat/linux/linux_signal.h>
> #include <compat/linux/linux_util.h>
> #include <compat/linux/linux_emul.h>
>+#include <compat/linux/linux_misc.h>
> 
>-void
>-linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss)
>-{
>-	int b, l;
>+static int	linux_do_tkill(struct thread *td, struct thread *tdt,
>+		    ksiginfo_t *ksi);
>+static void	sicode_to_lsicode(int si_code, int *lsi_code);
> 
>-	SIGEMPTYSET(*bss);
>-	bss->__bits[0] = lss->__bits[0] & ~((1U << LINUX_SIGTBLSZ) - 1);
>-	bss->__bits[1] = lss->__bits[1];
>-	for (l = 1; l <= LINUX_SIGTBLSZ; l++) {
>-		if (LINUX_SIGISMEMBER(*lss, l)) {
>-			b = linux_to_bsd_signal[_SIG_IDX(l)];
>-			if (b)
>-				SIGADDSET(*bss, b);
>-		}
>-	}
>-}
> 
>-void
>-bsd_to_linux_sigset(sigset_t *bss, l_sigset_t *lss)
>-{
>-	int b, l;
>-
>-	LINUX_SIGEMPTYSET(*lss);
>-	lss->__bits[0] = bss->__bits[0] & ~((1U << LINUX_SIGTBLSZ) - 1);
>-	lss->__bits[1] = bss->__bits[1];
>-	for (b = 1; b <= LINUX_SIGTBLSZ; b++) {
>-		if (SIGISMEMBER(*bss, b)) {
>-			l = bsd_to_linux_signal[_SIG_IDX(b)];
>-			if (l)
>-				LINUX_SIGADDSET(*lss, l);
>-		}
>-	}
>-}
>-
> static void
> linux_to_bsd_sigaction(l_sigaction_t *lsa, struct sigaction *bsa)
> {
>@@ -155,12 +127,8 @@
> 		linux_to_bsd_sigaction(linux_nsa, nsa);
> 	} else
> 		nsa = NULL;
>+	sig = linux_to_bsd_signal(linux_sig);
> 
>-	if (linux_sig <= LINUX_SIGTBLSZ)
>-		sig = linux_to_bsd_signal[_SIG_IDX(linux_sig)];
>-	else
>-		sig = linux_sig;
>-
> 	error = kern_sigaction(td, sig, nsa, osa, 0);
> 	if (error)
> 		return (error);
>@@ -171,7 +139,7 @@
> 	return (0);
> }
> 
>-
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_signal(struct thread *td, struct linux_signal_args *args)
> {
>@@ -193,6 +161,7 @@
> 
> 	return (error);
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_rt_sigaction(struct thread *td, struct linux_rt_sigaction_args *args)
>@@ -262,6 +231,7 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_sigprocmask(struct thread *td, struct linux_sigprocmask_args *args)
> {
>@@ -279,7 +249,7 @@
> 		if (error)
> 			return (error);
> 		LINUX_SIGEMPTYSET(set);
>-		set.__bits[0] = mask;
>+		set.__mask = mask;
> 	}
> 
> 	error = linux_do_sigprocmask(td, args->how,
>@@ -287,12 +257,13 @@
> 				     args->omask ? &oset : NULL);
> 
> 	if (args->omask != NULL && !error) {
>-		mask = oset.__bits[0];
>+		mask = oset.__mask;
> 		error = copyout(&mask, args->omask, sizeof(l_osigset_t));
> 	}
> 
> 	return (error);
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_rt_sigprocmask(struct thread *td, struct linux_rt_sigprocmask_args *args)
>@@ -327,6 +298,7 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> int
> linux_sgetmask(struct thread *td, struct linux_sgetmask_args *args)
> {
>@@ -341,7 +313,7 @@
> 	PROC_LOCK(p);
> 	bsd_to_linux_sigset(&td->td_sigmask, &mask);
> 	PROC_UNLOCK(p);
>-	td->td_retval[0] = mask.__bits[0];
>+	td->td_retval[0] = mask.__mask;
> 	return (0);
> }
> 
>@@ -359,9 +331,9 @@
> 
> 	PROC_LOCK(p);
> 	bsd_to_linux_sigset(&td->td_sigmask, &lset);
>-	td->td_retval[0] = lset.__bits[0];
>+	td->td_retval[0] = lset.__mask;
> 	LINUX_SIGEMPTYSET(lset);
>-	lset.__bits[0] = args->mask;
>+	lset.__mask = args->mask;
> 	linux_to_bsd_sigset(&lset, &bset);
> 	td->td_sigmask = bset;
> 	SIG_CANTMASK(td->td_sigmask);
>@@ -370,9 +342,6 @@
> 	return (0);
> }
> 
>-/*
>- * MPSAFE
>- */
> int
> linux_sigpending(struct thread *td, struct linux_sigpending_args *args)
> {
>@@ -392,9 +361,10 @@
> 	SIGSETAND(bset, td->td_sigmask);
> 	PROC_UNLOCK(p);
> 	bsd_to_linux_sigset(&bset, &lset);
>-	mask = lset.__bits[0];
>+	mask = lset.__mask;
> 	return (copyout(&mask, args->mask, sizeof(mask)));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> /*
>  * MPSAFE
>@@ -458,8 +428,8 @@
> #ifdef DEBUG
> 		if (ldebug(rt_sigtimedwait))
> 			printf(LMSG("linux_rt_sigtimedwait: "
>-			    "incoming timeout (%d/%d)\n"),
>-			    ltv.tv_sec, ltv.tv_usec);
>+			    "incoming timeout (%jd/%jd)\n"),
>+			    (intmax_t)ltv.tv_sec, (intmax_t)ltv.tv_usec);
> #endif
> 		tv.tv_sec = (long)ltv.tv_sec;
> 		tv.tv_usec = (suseconds_t)ltv.tv_usec;
>@@ -495,7 +465,7 @@
> 	if (error)
> 		return (error);
> 
>-	sig = BSD_TO_LINUX_SIGNAL(info.ksi_signo);
>+	sig = bsd_to_linux_signal(info.ksi_signo);
> 
> 	if (args->ptr) {
> 		memset(&linfo, 0, sizeof(linfo));
>@@ -527,10 +497,10 @@
> 	if (!LINUX_SIG_VALID(args->signum) && args->signum != 0)
> 		return (EINVAL);
> 
>-	if (args->signum > 0 && args->signum <= LINUX_SIGTBLSZ)
>-		tmp.signum = linux_to_bsd_signal[_SIG_IDX(args->signum)];
>+	if (args->signum > 0)
>+		tmp.signum = linux_to_bsd_signal(args->signum);
> 	else
>-		tmp.signum = args->signum;
>+		tmp.signum = 0;
> 
> 	tmp.pid = args->pid;
> 	return (sys_kill(td, &tmp));
>@@ -537,57 +507,22 @@
> }
> 
> static int
>-linux_do_tkill(struct thread *td, l_int tgid, l_int pid, l_int signum)
>+linux_do_tkill(struct thread *td, struct thread *tdt, ksiginfo_t *ksi)
> {
>-	struct proc *proc = td->td_proc;
>-	struct linux_emuldata *em;
> 	struct proc *p;
>-	ksiginfo_t ksi;
> 	int error;
> 
>-	AUDIT_ARG_SIGNUM(signum);
>-	AUDIT_ARG_PID(pid);
>-
>-	/*
>-	 * Allow signal 0 as a means to check for privileges
>-	 */
>-	if (!LINUX_SIG_VALID(signum) && signum != 0)
>-		return (EINVAL);
>-
>-	if (signum > 0 && signum <= LINUX_SIGTBLSZ)
>-		signum = linux_to_bsd_signal[_SIG_IDX(signum)];
>-
>-	if ((p = pfind(pid)) == NULL) {
>-		if ((p = zpfind(pid)) == NULL)
>-			return (ESRCH);
>-	}
>-
>+	p = tdt->td_proc;
>+	AUDIT_ARG_SIGNUM(ksi->ksi_signo);
>+	AUDIT_ARG_PID(p->p_pid);
> 	AUDIT_ARG_PROCESS(p);
>-	error = p_cansignal(td, p, signum);
>-	if (error != 0 || signum == 0)
>-		goto out;
> 
>-	error = ESRCH;
>-	em = em_find(p, EMUL_DONTLOCK);
>-
>-	if (em == NULL) {
>-#ifdef DEBUG
>-		printf("emuldata not found in do_tkill.\n");
>-#endif
>+	error = p_cansignal(td, p, ksi->ksi_signo);
>+	if (error != 0 || ksi->ksi_signo == 0)
> 		goto out;
>-	}
>-	if (tgid > 0 && em->shared->group_pid != tgid)
>-		goto out;
> 
>-	ksiginfo_init(&ksi);
>-	ksi.ksi_signo = signum;
>-	ksi.ksi_code = LINUX_SI_TKILL;
>-	ksi.ksi_errno = 0;
>-	ksi.ksi_pid = proc->p_pid;
>-	ksi.ksi_uid = proc->p_ucred->cr_ruid;
>+	tdksignal(tdt, ksi->ksi_signo, ksi);
> 
>-	error = pksignal(p, ksi.ksi_signo, &ksi);
>-
> out:
> 	PROC_UNLOCK(p);
> 	return (error);
>@@ -596,20 +531,53 @@
> int
> linux_tgkill(struct thread *td, struct linux_tgkill_args *args)
> {
>+	struct thread *tdt;
>+	ksiginfo_t ksi;
>+	int sig;
> 
> #ifdef DEBUG
> 	if (ldebug(tgkill))
>-		printf(ARGS(tgkill, "%d, %d, %d"), args->tgid, args->pid, args->sig);
>+		printf(ARGS(tgkill, "%d, %d, %d"),
>+		    args->tgid, args->pid, args->sig);
> #endif
>+
> 	if (args->pid <= 0 || args->tgid <=0)
> 		return (EINVAL);
> 
>-	return (linux_do_tkill(td, args->tgid, args->pid, args->sig));
>+	/*
>+	 * Allow signal 0 as a means to check for privileges
>+	 */
>+	if (!LINUX_SIG_VALID(args->sig) && args->sig != 0)
>+		return (EINVAL);
>+
>+	if (args->sig > 0)
>+		sig = linux_to_bsd_signal(args->sig);
>+	else
>+		sig = 0;
>+
>+	tdt = linux_tdfind(td, args->pid, args->tgid);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	ksiginfo_init(&ksi);
>+	ksi.ksi_signo = sig;
>+	ksi.ksi_code = SI_LWP;
>+	ksi.ksi_errno = 0;
>+	ksi.ksi_pid = td->td_proc->p_pid;
>+	ksi.ksi_uid = td->td_proc->p_ucred->cr_ruid;
>+	return (linux_do_tkill(td, tdt, &ksi));
> }
> 
>+/*
>+ * Deprecated since 2.5.75. Replaced by tgkill().
>+ */
> int
> linux_tkill(struct thread *td, struct linux_tkill_args *args)
> {
>+	struct thread *tdt;
>+	ksiginfo_t ksi;
>+	int sig;
>+
> #ifdef DEBUG
> 	if (ldebug(tkill))
> 		printf(ARGS(tkill, "%i, %i"), args->tid, args->sig);
>@@ -617,7 +585,22 @@
> 	if (args->tid <= 0)
> 		return (EINVAL);
> 
>-	return (linux_do_tkill(td, 0, args->tid, args->sig));
>+	if (!LINUX_SIG_VALID(args->sig))
>+		return (EINVAL);
>+
>+	sig = linux_to_bsd_signal(args->sig);
>+
>+	tdt = linux_tdfind(td, args->tid, -1);
>+	if (tdt == NULL)
>+		return (ESRCH);
>+
>+	ksiginfo_init(&ksi);
>+	ksi.ksi_signo = sig;
>+	ksi.ksi_code = SI_LWP;
>+	ksi.ksi_errno = 0;
>+	ksi.ksi_pid = td->td_proc->p_pid;
>+	ksi.ksi_uid = td->td_proc->p_ucred->cr_ruid;
>+	return (linux_do_tkill(td, tdt, &ksi));
> }
> 
> void
>@@ -624,33 +607,149 @@
> ksiginfo_to_lsiginfo(ksiginfo_t *ksi, l_siginfo_t *lsi, l_int sig)
> {
> 
>-	lsi->lsi_signo = sig;
>-	lsi->lsi_code = ksi->ksi_code;
>+	siginfo_to_lsiginfo(&ksi->ksi_info, lsi, sig);
>+}
> 
>-	switch (sig) {
>-	case LINUX_SIGPOLL:
>-		/* XXX si_fd? */
>-		lsi->lsi_band = ksi->ksi_band;
>+static void
>+sicode_to_lsicode(int si_code, int *lsi_code)
>+{
>+
>+	switch (si_code) {
>+	case SI_USER:
>+		*lsi_code = LINUX_SI_TIMER;
> 		break;
>-	case LINUX_SIGCHLD:
>-		lsi->lsi_pid = ksi->ksi_pid;
>-		lsi->lsi_uid = ksi->ksi_uid;
>-		lsi->lsi_status = ksi->ksi_status;
>+	case SI_KERNEL:
>+		*lsi_code = LINUX_SI_KERNEL;
> 		break;
>-	case LINUX_SIGBUS:
>-	case LINUX_SIGILL:
>-	case LINUX_SIGFPE:
>-	case LINUX_SIGSEGV:
>-		lsi->lsi_addr = PTROUT(ksi->ksi_addr);
>+	case SI_QUEUE:
>+		*lsi_code = LINUX_SI_QUEUE;
> 		break;
>+	case SI_TIMER:
>+		*lsi_code = LINUX_SI_TIMER;
>+		break;
>+	case SI_MESGQ:
>+		*lsi_code = LINUX_SI_MESGQ;
>+		break;
>+	case SI_ASYNCIO:
>+		*lsi_code = LINUX_SI_ASYNCIO;
>+		break;
>+	case SI_LWP:
>+		*lsi_code = LINUX_SI_TKILL;
>+		break;
> 	default:
>-		/* XXX SI_TIMER etc... */
>-		lsi->lsi_pid = ksi->ksi_pid;
>-		lsi->lsi_uid = ksi->ksi_uid;
>+		*lsi_code = si_code;
> 		break;
> 	}
>-	if (sig >= LINUX_SIGRTMIN) {
>-		lsi->lsi_int = ksi->ksi_info.si_value.sival_int;
>-		lsi->lsi_ptr = PTROUT(ksi->ksi_info.si_value.sival_ptr);
>+}
>+
>+void
>+lsiginfo_to_ksiginfo(l_siginfo_t *lsi, ksiginfo_t *ksi, int sig)
>+{
>+
>+	ksi->ksi_signo = sig;
>+	ksi->ksi_code = lsi->lsi_code;	/* XXX. Convert. */
>+	ksi->ksi_pid = lsi->lsi_pid;
>+	ksi->ksi_uid = lsi->lsi_uid;
>+	ksi->ksi_status = lsi->lsi_status;
>+	ksi->ksi_addr = PTRIN(lsi->lsi_addr);
>+	ksi->ksi_info.si_value.sival_int = lsi->lsi_int;
>+}
>+
>+int
>+linux_rt_sigqueueinfo(struct thread *td, struct linux_rt_sigqueueinfo_args *args)
>+{
>+	l_siginfo_t linfo;
>+	struct proc *p;
>+	ksiginfo_t ksi;
>+	int error;
>+	int sig;
>+
>+	if (!LINUX_SIG_VALID(args->sig))
>+		return (EINVAL);
>+
>+	if ((error = copyin(args->info, &linfo, sizeof(linfo))))
>+		return (error);
>+
>+	if (linfo.lsi_code >= 0)
>+		return (EPERM);
>+
>+	sig = linux_to_bsd_signal(args->sig);
>+
>+	error = ESRCH;
>+	if ((p = pfind(args->pid)) != NULL ||
>+	    (p = zpfind(args->pid)) != NULL) {
>+		ksiginfo_init(&ksi);
>+		lsiginfo_to_ksiginfo(&linfo, &ksi, sig);
>+		error = tdsendsignal(p, NULL, sig, &ksi);
>+		PROC_UNLOCK(p);
> 	}
>+	return (error);
> }
>+
>+void
>+siginfo_to_lsiginfo(siginfo_t *si, l_siginfo_t *lsi, l_int sig)
>+{
>+
>+	/* sig alredy converted */
>+ 	lsi->lsi_signo = sig;
>+	sicode_to_lsicode(si->si_code, &lsi->lsi_code);
>+ 
>+	switch (si->si_code) {
>+	case SI_LWP:
>+ 		lsi->lsi_pid = si->si_pid;
>+ 		lsi->lsi_uid = si->si_uid;
>+		break;
>+
>+	case SI_TIMER:
>+		lsi->lsi_int = si->si_value.sival_int;
>+		lsi->lsi_ptr = PTROUT(si->si_value.sival_ptr);
>+		lsi->lsi_tid = si->si_timerid;
>+ 		break;
>+
>+	case SI_QUEUE:
>+ 		lsi->lsi_pid = si->si_pid;
>+ 		lsi->lsi_uid = si->si_uid;
>+		lsi->lsi_ptr = PTROUT(si->si_value.sival_ptr);
>+ 		break;
>+
>+	case SI_ASYNCIO:
>+ 		lsi->lsi_int = si->si_value.sival_int;
>+ 		lsi->lsi_ptr = PTROUT(si->si_value.sival_ptr);
>+		break;
>+
>+	default:
>+		switch (sig) {
>+		case LINUX_SIGPOLL:
>+			/* XXX si_fd? */
>+			lsi->lsi_band = si->si_band;
>+			break;
>+		case LINUX_SIGCHLD:
>+			lsi->lsi_errno = 0;
>+			lsi->lsi_pid = si->si_pid;
>+			lsi->lsi_uid = si->si_uid;
>+
>+			if (si->si_code == CLD_STOPPED)
>+				lsi->lsi_status = bsd_to_linux_signal(si->si_status);
>+			else if (si->si_code == CLD_CONTINUED)
>+				lsi->lsi_status = LINUX_SIGCONT;
>+			else
>+				lsi->lsi_status = si->si_status;
>+			break;
>+		case LINUX_SIGBUS:
>+		case LINUX_SIGILL:
>+		case LINUX_SIGFPE:
>+		case LINUX_SIGSEGV:
>+			lsi->lsi_addr = PTROUT(si->si_addr);
>+			break;
>+		default:
>+ 			lsi->lsi_pid = si->si_pid;
>+ 			lsi->lsi_uid = si->si_uid;
>+			if (sig >= LINUX_SIGRTMIN) {
>+ 				lsi->lsi_int = si->si_value.sival_int;
>+ 				lsi->lsi_ptr = PTROUT(si->si_value.sival_ptr);
>+			}
>+			break;
>+		}
>+		break;
>+ 	}
>+}
>Index: sys/compat/linux/linux_signal.h
>===================================================================
>--- sys/compat/linux/linux_signal.h	(revision 285633)
>+++ sys/compat/linux/linux_signal.h	(working copy)
>@@ -31,19 +31,21 @@
> #ifndef _LINUX_SIGNAL_H_
> #define _LINUX_SIGNAL_H_
> 
>-#define	LINUX_SI_TKILL		-6;
>+/*
>+ * si_code values
>+ */
>+#define	LINUX_SI_USER		0	/* sent by kill, sigsend, raise */
>+#define	LINUX_SI_KERNEL		0x80	/* sent by the kernel from somewhere */
>+#define	LINUX_SI_QUEUE		-1	/* sent by sigqueue */
>+#define	LINUX_SI_TIMER		-2	/* sent by timer expiration */
>+#define	LINUX_SI_MESGQ		-3	/* sent by real time mesq state change */
>+#define	LINUX_SI_ASYNCIO	-4	/* sent by AIO completion */
>+#define	LINUX_SI_SIGIO		-5	/* sent by queued SIGIO */
>+#define	LINUX_SI_TKILL		-6	/* sent by tkill system call */
> 
>-extern int bsd_to_linux_signal[];
>-extern int linux_to_bsd_signal[];
>-
>-void linux_to_bsd_sigset(l_sigset_t *, sigset_t *);
>-void bsd_to_linux_sigset(sigset_t *, l_sigset_t *);
> int linux_do_sigaction(struct thread *, int, l_sigaction_t *, l_sigaction_t *);
>+void lsiginfo_to_ksiginfo(l_siginfo_t *lsi, ksiginfo_t *ksi, int sig);
> void ksiginfo_to_lsiginfo(ksiginfo_t *ksi, l_siginfo_t *lsi, l_int sig);
>+void siginfo_to_lsiginfo(siginfo_t *si, l_siginfo_t *lsi, l_int sig);
> 
>-#define LINUX_SIG_VALID(sig)	((sig) <= LINUX_NSIG && (sig) > 0)
>-
>-#define BSD_TO_LINUX_SIGNAL(sig)				\
>-	(((sig) <= LINUX_SIGTBLSZ) ? bsd_to_linux_signal[_SIG_IDX(sig)] : sig)
>-
> #endif /* _LINUX_SIGNAL_H_ */
>Index: sys/compat/linux/linux_socket.c
>===================================================================
>--- sys/compat/linux/linux_socket.c	(revision 285633)
>+++ sys/compat/linux/linux_socket.c	(working copy)
>@@ -70,10 +70,17 @@
> #include <machine/../linux/linux.h>
> #include <machine/../linux/linux_proto.h>
> #endif
>+#include <compat/linux/linux_file.h>
> #include <compat/linux/linux_socket.h>
>+#include <compat/linux/linux_timer.h>
> #include <compat/linux/linux_util.h>
> 
> static int linux_to_bsd_domain(int);
>+static int linux_sendmsg_common(struct thread *, l_int, struct l_msghdr *,
>+					l_uint);
>+static int linux_recvmsg_common(struct thread *, l_int, struct l_msghdr *,
>+					l_uint, struct msghdr *);
>+static int linux_set_socket_flags(int, int *);
> 
> /*
>  * Reads a linux sockaddr and does any necessary translation.
>@@ -428,7 +435,6 @@
> 	return (error);
> }
> 
>-
> static int
> linux_sa_put(struct osockaddr *osa)
> {
>@@ -477,6 +483,8 @@
> 		return (LINUX_SCM_RIGHTS);
> 	case SCM_CREDS:
> 		return (LINUX_SCM_CREDENTIALS);
>+	case SCM_TIMESTAMP:
>+		return (LINUX_SCM_TIMESTAMP);
> 	}
> 	return (-1);
> }
>@@ -529,20 +537,15 @@
> }
> 
> static int
>-linux_set_socket_flags(struct thread *td, int s, int flags)
>+linux_set_socket_flags(int lflags, int *flags)
> {
>-	int error;
> 
>-	if (flags & LINUX_SOCK_NONBLOCK) {
>-		error = kern_fcntl(td, s, F_SETFL, O_NONBLOCK);
>-		if (error)
>-			return (error);
>-	}
>-	if (flags & LINUX_SOCK_CLOEXEC) {
>-		error = kern_fcntl(td, s, F_SETFD, FD_CLOEXEC);
>-		if (error)
>-			return (error);
>-	}
>+	if (lflags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK))
>+		return (EINVAL);
>+	if (lflags & LINUX_SOCK_NONBLOCK)
>+		*flags |= SOCK_NONBLOCK;
>+	if (lflags & LINUX_SOCK_CLOEXEC)
>+		*flags |= SOCK_CLOEXEC;
> 	return (0);
> }
> 
>@@ -585,15 +588,6 @@
> 	return (optval == 0);
> }
> 
>-struct linux_sendto_args {
>-	int s;
>-	l_uintptr_t msg;
>-	int len;
>-	int flags;
>-	l_uintptr_t to;
>-	int tolen;
>-};
>-
> /*
>  * Updated sendto() when IP_HDRINCL is set:
>  * tweak endian-dependent fields in the IP packet.
>@@ -618,7 +612,7 @@
> 	    linux_args->len > IP_MAXPACKET)
> 		return (EINVAL);
> 
>-	packet = (struct ip *)malloc(linux_args->len, M_TEMP, M_WAITOK);
>+	packet = (struct ip *)malloc(linux_args->len, M_LINUX, M_WAITOK);
> 
> 	/* Make kernel copy of the packet to be sent */
> 	if ((error = copyin(PTRIN(linux_args->msg), packet,
>@@ -641,17 +635,11 @@
> 	error = linux_sendit(td, linux_args->s, &msg, linux_args->flags,
> 	    NULL, UIO_SYSSPACE);
> goout:
>-	free(packet, M_TEMP);
>+	free(packet, M_LINUX);
> 	return (error);
> }
> 
>-struct linux_socket_args {
>-	int domain;
>-	int type;
>-	int protocol;
>-};
>-
>-static int
>+int
> linux_socket(struct thread *td, struct linux_socket_args *args)
> {
> 	struct socket_args /* {
>@@ -659,15 +647,16 @@
> 		int type;
> 		int protocol;
> 	} */ bsd_args;
>-	int retval_socket, socket_flags;
>+	int retval_socket;
> 
> 	bsd_args.protocol = args->protocol;
>-	socket_flags = args->type & ~LINUX_SOCK_TYPE_MASK;
>-	if (socket_flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK))
>-		return (EINVAL);
> 	bsd_args.type = args->type & LINUX_SOCK_TYPE_MASK;
> 	if (bsd_args.type < 0 || bsd_args.type > LINUX_SOCK_MAX)
> 		return (EINVAL);
>+	retval_socket = linux_set_socket_flags(args->type & ~LINUX_SOCK_TYPE_MASK,
>+		&bsd_args.type);
>+	if (retval_socket != 0)
>+		return (retval_socket);
> 	bsd_args.domain = linux_to_bsd_domain(args->domain);
> 	if (bsd_args.domain == -1)
> 		return (EAFNOSUPPORT);
>@@ -676,13 +665,6 @@
> 	if (retval_socket)
> 		return (retval_socket);
> 
>-	retval_socket = linux_set_socket_flags(td, td->td_retval[0],
>-	    socket_flags);
>-	if (retval_socket) {
>-		(void)kern_close(td, td->td_retval[0]);
>-		goto out;
>-	}
>-
> 	if (bsd_args.type == SOCK_RAW
> 	    && (bsd_args.protocol == IPPROTO_RAW || bsd_args.protocol == 0)
> 	    && bsd_args.domain == PF_INET) {
>@@ -711,17 +693,10 @@
> 	}
> #endif
> 
>-out:
> 	return (retval_socket);
> }
> 
>-struct linux_bind_args {
>-	int s;
>-	l_uintptr_t name;
>-	int namelen;
>-};
>-
>-static int
>+int
> linux_bind(struct thread *td, struct linux_bind_args *args)
> {
> 	struct sockaddr *sa;
>@@ -739,13 +714,6 @@
> 	return (error);
> }
> 
>-struct linux_connect_args {
>-	int s;
>-	l_uintptr_t name;
>-	int namelen;
>-};
>-int linux_connect(struct thread *, struct linux_connect_args *);
>-
> int
> linux_connect(struct thread *td, struct linux_connect_args *args)
> {
>@@ -790,12 +758,7 @@
> 	return (error);
> }
> 
>-struct linux_listen_args {
>-	int s;
>-	int backlog;
>-};
>-
>-static int
>+int
> linux_listen(struct thread *td, struct linux_listen_args *args)
> {
> 	struct listen_args /* {
>@@ -812,21 +775,22 @@
> linux_accept_common(struct thread *td, int s, l_uintptr_t addr,
>     l_uintptr_t namelen, int flags)
> {
>-	struct accept_args /* {
>+	struct accept4_args /* {
> 		int	s;
> 		struct sockaddr * __restrict name;
> 		socklen_t * __restrict anamelen;
>+		int	flags;
> 	} */ bsd_args;
> 	int error;
> 
>-	if (flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK))
>-		return (EINVAL);
>-
> 	bsd_args.s = s;
> 	/* XXX: */
> 	bsd_args.name = (struct sockaddr * __restrict)PTRIN(addr);
> 	bsd_args.anamelen = PTRIN(namelen);/* XXX */
>-	error = sys_accept(td, &bsd_args);
>+	error = linux_set_socket_flags(flags, &bsd_args.flags);
>+	if (error != 0)
>+		return (error);
>+	error = sys_accept4(td, &bsd_args);
> 	bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.name);
> 	if (error) {
> 		if (error == EFAULT && namelen != sizeof(struct sockaddr_in))
>@@ -833,22 +797,8 @@
> 			return (EINVAL);
> 		return (error);
> 	}
>-
>-	/*
>-	 * linux appears not to copy flags from the parent socket to the
>-	 * accepted one, so we must clear the flags in the new descriptor
>-	 * and apply the requested flags.
>-	 */
>-	error = kern_fcntl(td, td->td_retval[0], F_SETFL, 0);
>-	if (error)
>-		goto out;
>-	error = linux_set_socket_flags(td, td->td_retval[0], flags);
>-	if (error)
>-		goto out;
> 	if (addr)
> 		error = linux_sa_put(PTRIN(addr));
>-
>-out:
> 	if (error) {
> 		(void)kern_close(td, td->td_retval[0]);
> 		td->td_retval[0] = 0;
>@@ -856,13 +806,7 @@
> 	return (error);
> }
> 
>-struct linux_accept_args {
>-	int s;
>-	l_uintptr_t addr;
>-	l_uintptr_t namelen;
>-};
>-
>-static int
>+int
> linux_accept(struct thread *td, struct linux_accept_args *args)
> {
> 
>@@ -870,14 +814,7 @@
> 	    args->namelen, 0));
> }
> 
>-struct linux_accept4_args {
>-	int s;
>-	l_uintptr_t addr;
>-	l_uintptr_t namelen;
>-	int flags;
>-};
>-
>-static int
>+int
> linux_accept4(struct thread *td, struct linux_accept4_args *args)
> {
> 
>@@ -885,13 +822,7 @@
> 	    args->namelen, args->flags));
> }
> 
>-struct linux_getsockname_args {
>-	int s;
>-	l_uintptr_t addr;
>-	l_uintptr_t namelen;
>-};
>-
>-static int
>+int
> linux_getsockname(struct thread *td, struct linux_getsockname_args *args)
> {
> 	struct getsockname_args /* {
>@@ -915,13 +846,7 @@
> 	return (0);
> }
> 
>-struct linux_getpeername_args {
>-	int s;
>-	l_uintptr_t addr;
>-	l_uintptr_t namelen;
>-};
>-
>-static int
>+int
> linux_getpeername(struct thread *td, struct linux_getpeername_args *args)
> {
> 	struct getpeername_args /* {
>@@ -944,14 +869,7 @@
> 	return (0);
> }
> 
>-struct linux_socketpair_args {
>-	int domain;
>-	int type;
>-	int protocol;
>-	l_uintptr_t rsv;
>-};
>-
>-static int
>+int
> linux_socketpair(struct thread *td, struct linux_socketpair_args *args)
> {
> 	struct socketpair_args /* {
>@@ -960,20 +878,18 @@
> 		int protocol;
> 		int *rsv;
> 	} */ bsd_args;
>-	int error, socket_flags;
>-	int sv[2];
>+	int error;
> 
> 	bsd_args.domain = linux_to_bsd_domain(args->domain);
> 	if (bsd_args.domain != PF_LOCAL)
> 		return (EAFNOSUPPORT);
>-
>-	socket_flags = args->type & ~LINUX_SOCK_TYPE_MASK;
>-	if (socket_flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK))
>-		return (EINVAL);
> 	bsd_args.type = args->type & LINUX_SOCK_TYPE_MASK;
> 	if (bsd_args.type < 0 || bsd_args.type > LINUX_SOCK_MAX)
> 		return (EINVAL);
>-
>+	error = linux_set_socket_flags(args->type & ~LINUX_SOCK_TYPE_MASK,
>+		&bsd_args.type);
>+	if (error != 0)
>+		return (error);
> 	if (args->protocol != 0 && args->protocol != PF_UNIX)
> 
> 		/*
>@@ -986,27 +902,10 @@
> 	else
> 		bsd_args.protocol = 0;
> 	bsd_args.rsv = (int *)PTRIN(args->rsv);
>-	error = kern_socketpair(td, bsd_args.domain, bsd_args.type,
>-	    bsd_args.protocol, sv);
>-	if (error)
>-		return (error);
>-	error = linux_set_socket_flags(td, sv[0], socket_flags);
>-	if (error)
>-		goto out;
>-	error = linux_set_socket_flags(td, sv[1], socket_flags);
>-	if (error)
>-		goto out;
>-
>-	error = copyout(sv, bsd_args.rsv, 2 * sizeof(int));
>-
>-out:
>-	if (error) {
>-		(void)kern_close(td, sv[0]);
>-		(void)kern_close(td, sv[1]);
>-	}
>-	return (error);
>+	return (sys_socketpair(td, &bsd_args));
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> struct linux_send_args {
> 	int s;
> 	l_uintptr_t msg;
>@@ -1062,8 +961,9 @@
> 	bsd_args.fromlenaddr = 0;
> 	return (sys_recvfrom(td, &bsd_args));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
>-static int
>+int
> linux_sendto(struct thread *td, struct linux_sendto_args *args)
> {
> 	struct msghdr msg;
>@@ -1087,63 +987,53 @@
> 	return (error);
> }
> 
>-struct linux_recvfrom_args {
>-	int s;
>-	l_uintptr_t buf;
>-	int len;
>-	int flags;
>-	l_uintptr_t from;
>-	l_uintptr_t fromlen;
>-};
>-
>-static int
>+int
> linux_recvfrom(struct thread *td, struct linux_recvfrom_args *args)
> {
>-	struct recvfrom_args /* {
>-		int	s;
>-		caddr_t	buf;
>-		size_t	len;
>-		int	flags;
>-		struct sockaddr * __restrict from;
>-		socklen_t * __restrict fromlenaddr;
>-	} */ bsd_args;
>-	size_t len;
>+	struct msghdr msg;
>+	struct iovec aiov;
> 	int error;
> 
>-	if ((error = copyin(PTRIN(args->fromlen), &len, sizeof(size_t))))
>-		return (error);
>+	if (args->fromlen) {
>+		error = copyin(PTRIN(args->fromlen), &msg.msg_namelen,
>+		    sizeof (msg.msg_namelen));
>+		if (error)
>+			return (error);
> 
>-	bsd_args.s = args->s;
>-	bsd_args.buf = PTRIN(args->buf);
>-	bsd_args.len = args->len;
>-	bsd_args.flags = linux_to_bsd_msg_flags(args->flags);
>-	/* XXX: */
>-	bsd_args.from = (struct sockaddr * __restrict)PTRIN(args->from);
>-	bsd_args.fromlenaddr = PTRIN(args->fromlen);/* XXX */
>-	
>-	linux_to_bsd_sockaddr((struct sockaddr *)bsd_args.from, len);
>-	error = sys_recvfrom(td, &bsd_args);
>-	bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.from);
>-	
>+		error = linux_to_bsd_sockaddr((struct sockaddr *)PTRIN(args->from),
>+		    msg.msg_namelen);
>+		if (error)
>+			return (error);
>+	} else
>+		msg.msg_namelen = 0;
>+
>+	msg.msg_name = (struct sockaddr * __restrict)PTRIN(args->from);
>+	msg.msg_iov = &aiov;
>+	msg.msg_iovlen = 1;
>+	aiov.iov_base = PTRIN(args->buf);
>+	aiov.iov_len = args->len;
>+	msg.msg_control = 0;
>+	msg.msg_flags = linux_to_bsd_msg_flags(args->flags);
>+
>+	error = kern_recvit(td, args->s, &msg, UIO_USERSPACE, NULL);
> 	if (error)
> 		return (error);
>+
> 	if (args->from) {
>-		error = linux_sa_put((struct osockaddr *)
>+		error = bsd_to_linux_sockaddr((struct sockaddr *)
> 		    PTRIN(args->from));
> 		if (error)
> 			return (error);
>+
>+		error = linux_sa_put((struct osockaddr *)
>+		    PTRIN(args->from));
> 	}
>-	return (0);
>+	return (error);
> }
> 
>-struct linux_sendmsg_args {
>-	int s;
>-	l_uintptr_t msg;
>-	int flags;
>-};
>-
> static int
>-linux_sendmsg(struct thread *td, struct linux_sendmsg_args *args)
>+linux_sendmsg_common(struct thread *td, l_int s, struct l_msghdr *msghdr,
>+    l_uint flags)
> {
> 	struct cmsghdr *cmsg;
> 	struct cmsgcred cmcred;
>@@ -1159,8 +1049,8 @@
> 	void *data;
> 	int error;
> 
>-	error = copyin(PTRIN(args->msg), &linux_msg, sizeof(linux_msg));
>-	if (error)
>+	error = copyin(msghdr, &linux_msg, sizeof(linux_msg));
>+	if (error != 0)
> 		return (error);
> 
> 	/*
>@@ -1174,7 +1064,7 @@
> 		linux_msg.msg_control = PTROUT(NULL);
> 
> 	error = linux_to_bsd_msghdr(&msg, &linux_msg);
>-	if (error)
>+	if (error != 0)
> 		return (error);
> 
> #ifdef COMPAT_LINUX32
>@@ -1183,7 +1073,7 @@
> #else
> 	error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
> #endif
>-	if (error)
>+	if (error != 0)
> 		return (error);
> 
> 	control = NULL;
>@@ -1190,22 +1080,20 @@
> 	cmsg = NULL;
> 
> 	if ((ptr_cmsg = LINUX_CMSG_FIRSTHDR(&linux_msg)) != NULL) {
>-		error = kern_getsockname(td, args->s, &sa, &datalen);
>-		if (error)
>+		error = kern_getsockname(td, s, &sa, &datalen);
>+		if (error != 0)
> 			goto bad;
> 		sa_family = sa->sa_family;
> 		free(sa, M_SONAME);
> 
> 		error = ENOBUFS;
>-		cmsg = malloc(CMSG_HDRSZ, M_TEMP, M_WAITOK | M_ZERO);
>+		cmsg = malloc(CMSG_HDRSZ, M_LINUX, M_WAITOK|M_ZERO);
> 		control = m_get(M_WAITOK, MT_CONTROL);
>-		if (control == NULL)
>-			goto bad;
> 
> 		do {
> 			error = copyin(ptr_cmsg, &linux_cmsg,
> 			    sizeof(struct l_cmsghdr));
>-			if (error)
>+			if (error != 0)
> 				goto bad;
> 
> 			error = EINVAL;
>@@ -1269,28 +1157,60 @@
> 
> 	msg.msg_iov = iov;
> 	msg.msg_flags = 0;
>-	error = linux_sendit(td, args->s, &msg, args->flags, control,
>-	    UIO_USERSPACE);
>+	error = linux_sendit(td, s, &msg, flags, control, UIO_USERSPACE);
> 
> bad:
>+	m_freem(control);
> 	free(iov, M_IOV);
> 	if (cmsg)
>-		free(cmsg, M_TEMP);
>+		free(cmsg, M_LINUX);
> 	return (error);
> }
> 
>-struct linux_recvmsg_args {
>-	int s;
>-	l_uintptr_t msg;
>-	int flags;
>-};
>+int
>+linux_sendmsg(struct thread *td, struct linux_sendmsg_args *args)
>+{
> 
>+	return (linux_sendmsg_common(td, args->s, PTRIN(args->msg),
>+	    args->flags));
>+}
>+
>+int
>+linux_sendmmsg(struct thread *td, struct linux_sendmmsg_args *args)
>+{
>+	struct l_mmsghdr *msg;
>+	l_uint retval;
>+	int error, datagrams;
>+
>+	if (args->vlen > UIO_MAXIOV)
>+		args->vlen = UIO_MAXIOV;
>+
>+	msg = PTRIN(args->msg);
>+	datagrams = 0;
>+	while (datagrams < args->vlen) {
>+		error = linux_sendmsg_common(td, args->s, &msg->msg_hdr,
>+		    args->flags);
>+		if (error != 0)
>+			break;
>+
>+		retval = td->td_retval[0];
>+		error = copyout(&retval, &msg->msg_len, sizeof(msg->msg_len));
>+		if (error != 0)
>+			break;
>+		++msg;
>+		++datagrams;
>+	}
>+	if (error == 0)
>+		td->td_retval[0] = datagrams;
>+	return (error);
>+}
>+
> static int
>-linux_recvmsg(struct thread *td, struct linux_recvmsg_args *args)
>+linux_recvmsg_common(struct thread *td, l_int s, struct l_msghdr *msghdr,
>+    l_uint flags, struct msghdr *msg)
> {
> 	struct cmsghdr *cm;
> 	struct cmsgcred *cmcred;
>-	struct msghdr msg;
> 	struct l_cmsghdr *linux_cmsg = NULL;
> 	struct l_ucred linux_ucred;
> 	socklen_t datalen, outlen;
>@@ -1298,55 +1218,57 @@
> 	struct iovec *iov, *uiov;
> 	struct mbuf *control = NULL;
> 	struct mbuf **controlp;
>+	struct timeval *ftmvl;
>+	l_timeval ltmvl;
> 	caddr_t outbuf;
> 	void *data;
> 	int error, i, fd, fds, *fdp;
> 
>-	error = copyin(PTRIN(args->msg), &linux_msg, sizeof(linux_msg));
>-	if (error)
>+	error = copyin(msghdr, &linux_msg, sizeof(linux_msg));
>+	if (error != 0)
> 		return (error);
> 
>-	error = linux_to_bsd_msghdr(&msg, &linux_msg);
>-	if (error)
>+	error = linux_to_bsd_msghdr(msg, &linux_msg);
>+	if (error != 0)
> 		return (error);
> 
> #ifdef COMPAT_LINUX32
>-	error = linux32_copyiniov(PTRIN(msg.msg_iov), msg.msg_iovlen,
>+	error = linux32_copyiniov(PTRIN(msg->msg_iov), msg->msg_iovlen,
> 	    &iov, EMSGSIZE);
> #else
>-	error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
>+	error = copyiniov(msg->msg_iov, msg->msg_iovlen, &iov, EMSGSIZE);
> #endif
>-	if (error)
>+	if (error != 0)
> 		return (error);
> 
>-	if (msg.msg_name) {
>-		error = linux_to_bsd_sockaddr((struct sockaddr *)msg.msg_name,
>-		    msg.msg_namelen);
>-		if (error)
>+	if (msg->msg_name) {
>+		error = linux_to_bsd_sockaddr((struct sockaddr *)msg->msg_name,
>+		    msg->msg_namelen);
>+		if (error != 0)
> 			goto bad;
> 	}
> 
>-	uiov = msg.msg_iov;
>-	msg.msg_iov = iov;
>-	controlp = (msg.msg_control != NULL) ? &control : NULL;
>-	error = kern_recvit(td, args->s, &msg, UIO_USERSPACE, controlp);
>-	msg.msg_iov = uiov;
>-	if (error)
>+	uiov = msg->msg_iov;
>+	msg->msg_iov = iov;
>+	controlp = (msg->msg_control != NULL) ? &control : NULL;
>+	error = kern_recvit(td, s, msg, UIO_USERSPACE, controlp);
>+	msg->msg_iov = uiov;
>+	if (error != 0)
> 		goto bad;
> 
>-	error = bsd_to_linux_msghdr(&msg, &linux_msg);
>-	if (error)
>+	error = bsd_to_linux_msghdr(msg, &linux_msg);
>+	if (error != 0)
> 		goto bad;
> 
> 	if (linux_msg.msg_name) {
> 		error = bsd_to_linux_sockaddr((struct sockaddr *)
> 		    PTRIN(linux_msg.msg_name));
>-		if (error)
>+		if (error != 0)
> 			goto bad;
> 	}
> 	if (linux_msg.msg_name && linux_msg.msg_namelen > 2) {
> 		error = linux_sa_put(PTRIN(linux_msg.msg_name));
>-		if (error)
>+		if (error != 0)
> 			goto bad;
> 	}
> 
>@@ -1354,12 +1276,12 @@
> 	outlen = 0;
> 
> 	if (control) {
>-		linux_cmsg = malloc(L_CMSG_HDRSZ, M_TEMP, M_WAITOK | M_ZERO);
>+		linux_cmsg = malloc(L_CMSG_HDRSZ, M_LINUX, M_WAITOK | M_ZERO);
> 
>-		msg.msg_control = mtod(control, struct cmsghdr *);
>-		msg.msg_controllen = control->m_len;
>+		msg->msg_control = mtod(control, struct cmsghdr *);
>+		msg->msg_controllen = control->m_len;
> 
>-		cm = CMSG_FIRSTHDR(&msg);
>+		cm = CMSG_FIRSTHDR(msg);
> 
> 		while (cm != NULL) {
> 			linux_cmsg->cmsg_type =
>@@ -1379,7 +1301,7 @@
> 			switch (cm->cmsg_type)
> 			{
> 			case SCM_RIGHTS:
>-				if (args->flags & LINUX_MSG_CMSG_CLOEXEC) {
>+				if (flags & LINUX_MSG_CMSG_CLOEXEC) {
> 					fds = datalen / sizeof(int);
> 					fdp = data;
> 					for (i = 0; i < fds; i++) {
>@@ -1408,6 +1330,18 @@
> 				data = &linux_ucred;
> 				datalen = sizeof(linux_ucred);
> 				break;
>+
>+			case SCM_TIMESTAMP:
>+				if (datalen != sizeof(struct timeval)) {
>+					error = EMSGSIZE;
>+					goto bad;
>+				}
>+				ftmvl = (struct timeval *)data;
>+				ltmvl.tv_sec = ftmvl->tv_sec;
>+				ltmvl.tv_usec = ftmvl->tv_usec;
>+				data = &ltmvl;
>+				datalen = sizeof(ltmvl);
>+				break;
> 			}
> 
> 			if (outlen + LINUX_CMSG_LEN(datalen) >
>@@ -1436,28 +1370,92 @@
> 			outbuf += LINUX_CMSG_ALIGN(datalen);
> 			outlen += LINUX_CMSG_LEN(datalen);
> 
>-			cm = CMSG_NXTHDR(&msg, cm);
>+			cm = CMSG_NXTHDR(msg, cm);
> 		}
> 	}
> 
> out:
> 	linux_msg.msg_controllen = outlen;
>-	error = copyout(&linux_msg, PTRIN(args->msg), sizeof(linux_msg));
>+	error = copyout(&linux_msg, msghdr, sizeof(linux_msg));
> 
> bad:
> 	free(iov, M_IOV);
> 	m_freem(control);
>-	free(linux_cmsg, M_TEMP);
>+	free(linux_cmsg, M_LINUX);
> 
> 	return (error);
> }
> 
>-struct linux_shutdown_args {
>-	int s;
>-	int how;
>-};
>+int
>+linux_recvmsg(struct thread *td, struct linux_recvmsg_args *args)
>+{
>+	struct msghdr bsd_msg;
> 
>-static int
>+	return (linux_recvmsg_common(td, args->s, PTRIN(args->msg),
>+	    args->flags, &bsd_msg));
>+}
>+
>+int
>+linux_recvmmsg(struct thread *td, struct linux_recvmmsg_args *args)
>+{
>+	struct l_mmsghdr *msg;
>+	struct msghdr bsd_msg;
>+	struct l_timespec lts;
>+	struct timespec ts, tts;
>+	l_uint retval;
>+	int error, datagrams;
>+
>+	if (args->timeout) {
>+		error = copyin(args->timeout, &lts, sizeof(struct l_timespec));
>+		if (error != 0)
>+			return (error);
>+		error = linux_to_native_timespec(&ts, &lts);
>+		if (error != 0)
>+			return (error);
>+		getnanotime(&tts);
>+		timespecadd(&tts, &ts);
>+	}
>+
>+	msg = PTRIN(args->msg);
>+	datagrams = 0;
>+	while (datagrams < args->vlen) {
>+		error = linux_recvmsg_common(td, args->s, &msg->msg_hdr,
>+		    args->flags & ~LINUX_MSG_WAITFORONE, &bsd_msg);
>+		if (error != 0)
>+			break;
>+
>+		retval = td->td_retval[0];
>+		error = copyout(&retval, &msg->msg_len, sizeof(msg->msg_len));
>+		if (error != 0)
>+			break;
>+		++msg;
>+		++datagrams;
>+
>+		/*
>+		 * MSG_WAITFORONE turns on MSG_DONTWAIT after one packet.
>+		 */
>+		if (args->flags & LINUX_MSG_WAITFORONE)
>+			args->flags |= LINUX_MSG_DONTWAIT;
>+
>+		/*
>+		 * See BUGS section of recvmmsg(2).
>+		 */
>+		if (args->timeout) {
>+			getnanotime(&ts);
>+			timespecsub(&ts, &tts);
>+			if (!timespecisset(&ts) || ts.tv_sec > 0)
>+				break;
>+		}
>+		/* Out of band data, return right away. */
>+		if (bsd_msg.msg_flags & MSG_OOB)
>+			break;
>+	}
>+	if (error == 0)
>+		td->td_retval[0] = datagrams;
>+	return (error);
>+}
>+
>+int
> linux_shutdown(struct thread *td, struct linux_shutdown_args *args)
> {
> 	struct shutdown_args /* {
>@@ -1470,15 +1468,7 @@
> 	return (sys_shutdown(td, &bsd_args));
> }
> 
>-struct linux_setsockopt_args {
>-	int s;
>-	int level;
>-	int optname;
>-	l_uintptr_t optval;
>-	int optlen;
>-};
>-
>-static int
>+int
> linux_setsockopt(struct thread *td, struct linux_setsockopt_args *args)
> {
> 	struct setsockopt_args /* {
>@@ -1543,15 +1533,7 @@
> 	return (error);
> }
> 
>-struct linux_getsockopt_args {
>-	int s;
>-	int level;
>-	int optname;
>-	l_uintptr_t optval;
>-	l_uintptr_t optlen;
>-};
>-
>-static int
>+int
> linux_getsockopt(struct thread *td, struct linux_getsockopt_args *args)
> {
> 	struct getsockopt_args /* {
>@@ -1635,6 +1617,8 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
>+
> /* Argument list sizes for linux_socketcall */
> 
> #define LINUX_AL(x) ((x) * sizeof(l_ulong))
>@@ -1649,7 +1633,8 @@
> 	LINUX_AL(6) /* recvfrom */,	LINUX_AL(2) /* shutdown */,
> 	LINUX_AL(5) /* setsockopt */,	LINUX_AL(5) /* getsockopt */,
> 	LINUX_AL(3) /* sendmsg */,	LINUX_AL(3) /* recvmsg */,
>-	LINUX_AL(4) /* accept4 */
>+	LINUX_AL(4) /* accept4 */,	LINUX_AL(5) /* recvmmsg */,
>+	LINUX_AL(4) /* sendmmsg */
> };
> 
> #define	LINUX_AL_SIZE	sizeof(lxs_args) / sizeof(lxs_args[0]) - 1
>@@ -1705,8 +1690,13 @@
> 		return (linux_recvmsg(td, arg));
> 	case LINUX_ACCEPT4:
> 		return (linux_accept4(td, arg));
>+	case LINUX_RECVMMSG:
>+		return (linux_recvmmsg(td, arg));
>+	case LINUX_SENDMMSG:
>+		return (linux_sendmmsg(td, arg));
> 	}
> 
> 	uprintf("LINUX: 'socket' typ=%d not implemented\n", args->what);
> 	return (ENOSYS);
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
>Index: sys/compat/linux/linux_socket.h
>===================================================================
>--- sys/compat/linux/linux_socket.h	(revision 285633)
>+++ sys/compat/linux/linux_socket.h	(working copy)
>@@ -48,13 +48,37 @@
> #define LINUX_MSG_RST		0x1000
> #define LINUX_MSG_ERRQUEUE	0x2000
> #define LINUX_MSG_NOSIGNAL	0x4000
>+#define LINUX_MSG_WAITFORONE	0x10000
> #define LINUX_MSG_CMSG_CLOEXEC	0x40000000
> 
> /* Socket-level control message types */
> 
> #define LINUX_SCM_RIGHTS	0x01
>-#define LINUX_SCM_CREDENTIALS   0x02
>+#define LINUX_SCM_CREDENTIALS	0x02
>+#define LINUX_SCM_TIMESTAMP	0x1D
> 
>+struct l_msghdr {
>+	l_uintptr_t	msg_name;
>+	l_int		msg_namelen;
>+	l_uintptr_t	msg_iov;
>+	l_size_t	msg_iovlen;
>+	l_uintptr_t	msg_control;
>+	l_size_t	msg_controllen;
>+	l_uint		msg_flags;
>+};
>+
>+struct l_mmsghdr {
>+	struct l_msghdr	msg_hdr;
>+	l_uint		msg_len;
>+
>+};
>+
>+struct l_cmsghdr {
>+	l_size_t	cmsg_len;
>+	l_int		cmsg_level;
>+	l_int		cmsg_type;
>+};
>+
> /* Ancilliary data object information macros */
> 
> #define LINUX_CMSG_ALIGN(len)	roundup2(len, sizeof(l_ulong))
>@@ -116,6 +140,133 @@
> 	uint32_t	gid;
> };
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
>+
>+struct linux_sendto_args {
>+	int s;
>+	l_uintptr_t msg;
>+	int len;
>+	int flags;
>+	l_uintptr_t to;
>+	int tolen;
>+};
>+
>+struct linux_socket_args {
>+	int domain;
>+	int type;
>+	int protocol;
>+};
>+
>+struct linux_bind_args {
>+	int s;
>+	l_uintptr_t name;
>+	int namelen;
>+};
>+
>+struct linux_connect_args {
>+	int s;
>+	l_uintptr_t name;
>+	int namelen;
>+};
>+
>+struct linux_listen_args {
>+	int s;
>+	int backlog;
>+};
>+
>+struct linux_accept_args {
>+	int s;
>+	l_uintptr_t addr;
>+	l_uintptr_t namelen;
>+};
>+
>+struct linux_accept4_args {
>+	int s;
>+	l_uintptr_t addr;
>+	l_uintptr_t namelen;
>+	int flags;
>+};
>+
>+struct linux_getsockname_args {
>+	int s;
>+	l_uintptr_t addr;
>+	l_uintptr_t namelen;
>+};
>+
>+struct linux_getpeername_args {
>+	int s;
>+	l_uintptr_t addr;
>+	l_uintptr_t namelen;
>+};
>+
>+struct linux_socketpair_args {
>+	int domain;
>+	int type;
>+	int protocol;
>+	l_uintptr_t rsv;
>+};
>+
>+struct linux_recvfrom_args {
>+	int s;
>+	l_uintptr_t buf;
>+	int len;
>+	int flags;
>+	l_uintptr_t from;
>+	l_uintptr_t fromlen;
>+};
>+
>+struct linux_sendmsg_args {
>+	int s;
>+	l_uintptr_t msg;
>+	int flags;
>+};
>+
>+struct linux_recvmsg_args {
>+	int s;
>+	l_uintptr_t msg;
>+	int flags;
>+};
>+
>+struct linux_shutdown_args {
>+	int s;
>+	int how;
>+};
>+
>+struct linux_setsockopt_args {
>+	int s;
>+	int level;
>+	int optname;
>+	l_uintptr_t optval;
>+	int optlen;
>+};
>+
>+struct linux_getsockopt_args {
>+	int s;
>+	int level;
>+	int optname;
>+	l_uintptr_t optval;
>+	l_uintptr_t optlen;
>+};
>+
>+int linux_socket(struct thread *td, struct linux_socket_args *args);
>+int linux_bind(struct thread *td, struct linux_bind_args *args);
>+int linux_connect(struct thread *, struct linux_connect_args *);
>+int linux_listen(struct thread *td, struct linux_listen_args *args);
>+int linux_accept(struct thread *td, struct linux_accept_args *args);
>+int linux_accept4(struct thread *td, struct linux_accept4_args *args);
>+int linux_getsockname(struct thread *td, struct linux_getsockname_args *args);
>+int linux_getpeername(struct thread *td, struct linux_getpeername_args *args);
>+int linux_socketpair(struct thread *td, struct linux_socketpair_args *args);
>+int linux_sendto(struct thread *td, struct linux_sendto_args *args);
>+int linux_recvfrom(struct thread *td, struct linux_recvfrom_args *args);
>+int linux_sendmsg(struct thread *td, struct linux_sendmsg_args *args);
>+int linux_recvmsg(struct thread *td, struct linux_recvmsg_args *args);
>+int linux_shutdown(struct thread *td, struct linux_shutdown_args *args);
>+int linux_setsockopt(struct thread *td, struct linux_setsockopt_args *args);
>+int linux_getsockopt(struct thread *td, struct linux_getsockopt_args *args);
>+
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
>+
> /* Operations for socketcall */
> 
> #define	LINUX_SOCKET 		1
>@@ -136,6 +287,8 @@
> #define	LINUX_SENDMSG		16
> #define	LINUX_RECVMSG		17
> #define	LINUX_ACCEPT4		18
>+#define	LINUX_RECVMMSG		19
>+#define	LINUX_SENDMMSG		20
> 
> /* Socket options */
> #define	LINUX_IP_TOS		1
>Index: sys/compat/linux/linux_stats.c
>===================================================================
>--- sys/compat/linux/linux_stats.c	(revision 285633)
>+++ sys/compat/linux/linux_stats.c	(working copy)
>@@ -32,6 +32,7 @@
> #include "opt_compat.h"
> 
> #include <sys/param.h>
>+#include <sys/capsicum.h>
> #include <sys/dirent.h>
> #include <sys/file.h>
> #include <sys/filedesc.h>
>@@ -58,7 +59,6 @@
> #include <compat/linux/linux_util.h>
> #include <compat/linux/linux_file.h>
> 
>-#define	LINUX_SHMFS_MAGIC 0x01021994
> 
> static void
> translate_vnhook_major_minor(struct vnode *vp, struct stat *sb)
>@@ -251,6 +251,7 @@
> 	return (error);
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> static int
> stat_copyout(struct stat *buf, void *ubuf)
> {
>@@ -325,19 +326,19 @@
> 	LFREEPATH(path);
> 	return(stat_copyout(&buf, args->up));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
>-/* XXX - All fields of type l_int are defined as l_long on i386 */
> struct l_statfs {
>-	l_int		f_type;
>-	l_int		f_bsize;
>-	l_int		f_blocks;
>-	l_int		f_bfree;
>-	l_int		f_bavail;
>-	l_int		f_files;
>-	l_int		f_ffree;
>+	l_long		f_type;
>+	l_long		f_bsize;
>+	l_long		f_blocks;
>+	l_long		f_bfree;
>+	l_long		f_bavail;
>+	l_long		f_files;
>+	l_long		f_ffree;
> 	l_fsid_t	f_fsid;
>-	l_int		f_namelen;
>-	l_int		f_spare[6];
>+	l_long		f_namelen;
>+	l_long		f_spare[6];
> };
> 
> #define	LINUX_CODA_SUPER_MAGIC	0x73757245L
>@@ -351,6 +352,7 @@
> #define	LINUX_PROC_SUPER_MAGIC	0x9fa0L
> #define	LINUX_UFS_SUPER_MAGIC	0x00011954L	/* XXX - UFS_MAGIC in Linux */
> #define LINUX_DEVFS_SUPER_MAGIC	0x1373L
>+#define	LINUX_SHMFS_MAGIC	0x01021994
> 
> static long
> bsd_to_linux_ftype(const char *fstypename)
>@@ -368,6 +370,7 @@
> 		{"hpfs",    LINUX_HPFS_SUPER_MAGIC},
> 		{"coda",    LINUX_CODA_SUPER_MAGIC},
> 		{"devfs",   LINUX_DEVFS_SUPER_MAGIC},
>+		{"tmpfs",   LINUX_SHMFS_MAGIC},
> 		{NULL,      0L}};
> 
> 	for (i = 0; b2l_tbl[i].bsd_name != NULL; i++)
>@@ -399,7 +402,7 @@
> 	struct l_statfs linux_statfs;
> 	struct statfs bsd_statfs;
> 	char *path;
>-	int error, dev_shm;
>+	int error;
> 
> 	LCONVPATHEXIST(td, args->path, &path);
> 
>@@ -407,20 +410,15 @@
> 	if (ldebug(statfs))
> 		printf(ARGS(statfs, "%s, *"), path);
> #endif
>-	dev_shm = 0;
> 	error = kern_statfs(td, path, UIO_SYSSPACE, &bsd_statfs);
>-	if (strncmp(path, "/dev/shm", sizeof("/dev/shm") - 1) == 0)
>-		dev_shm = (path[8] == '\0'
>-		    || (path[8] == '/' && path[9] == '\0'));
> 	LFREEPATH(path);
> 	if (error)
> 		return (error);
> 	bsd_to_linux_statfs(&bsd_statfs, &linux_statfs);
>-	if (dev_shm)
>-		linux_statfs.f_type = LINUX_SHMFS_MAGIC;
> 	return copyout(&linux_statfs, args->buf, sizeof(linux_statfs));
> }
> 
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
> static void
> bsd_to_linux_statfs64(struct statfs *bsd_statfs, struct l_statfs64 *linux_statfs)
> {
>@@ -461,6 +459,7 @@
> 	bsd_to_linux_statfs64(&bsd_statfs, &linux_statfs);
> 	return copyout(&linux_statfs, args->buf, sizeof(linux_statfs));
> }
>+#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
> 
> int
> linux_fstatfs(struct thread *td, struct linux_fstatfs_args *args)
>@@ -493,7 +492,7 @@
> {
> #ifdef DEBUG
> 	if (ldebug(ustat))
>-		printf(ARGS(ustat, "%d, *"), args->dev);
>+		printf(ARGS(ustat, "%ju, *"), (uintmax_t)args->dev);
> #endif
> 
> 	return (EOPNOTSUPP);
>@@ -624,4 +623,74 @@
> 	return (error);
> }
> 
>+#else
>+
>+int
>+linux_newfstatat(struct thread *td, struct linux_newfstatat_args *args)
>+{
>+	char *path;
>+	int error, dfd, flag;
>+	struct stat buf;
>+
>+	if (args->flag & ~LINUX_AT_SYMLINK_NOFOLLOW)
>+		return (EINVAL);
>+	flag = (args->flag & LINUX_AT_SYMLINK_NOFOLLOW) ?
>+	    AT_SYMLINK_NOFOLLOW : 0;
>+
>+	dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
>+	LCONVPATHEXIST_AT(td, args->pathname, &path, dfd);
>+
>+#ifdef DEBUG
>+	if (ldebug(newfstatat))
>+		printf(ARGS(newfstatat, "%i, %s, %i"), args->dfd, path, args->flag);
>+#endif
>+
>+	error = linux_kern_statat(td, flag, dfd, path, UIO_SYSSPACE, &buf);
>+	if (!error)
>+		error = newstat_copyout(&buf, args->statbuf);
>+	LFREEPATH(path);
>+
>+	return (error);
>+}
>+
> #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
>+
>+int
>+linux_syncfs(struct thread *td, struct linux_syncfs_args *args)
>+{
>+	cap_rights_t rights;
>+	struct mount *mp;
>+	struct vnode *vp;
>+	int error, save;
>+
>+	error = fgetvp(td, args->fd, cap_rights_init(&rights, CAP_FSYNC), &vp);
>+	if (error != 0)
>+		/*
>+		 * Linux syncfs() returns only EBADF, however fgetvp()
>+		 * can return EINVAL in case of file descriptor does
>+		 * not represent a vnode. XXX.
>+		 */
>+		return (error);
>+
>+	mp = vp->v_mount;
>+	mtx_lock(&mountlist_mtx);
>+	error = vfs_busy(mp, MBF_MNTLSTLOCK);
>+	if (error != 0) {
>+		/* See comment above. */
>+		mtx_unlock(&mountlist_mtx);
>+		goto out;
>+	}
>+	if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
>+	    vn_start_write(NULL, &mp, V_NOWAIT) == 0) {
>+		save = curthread_pflags_set(TDP_SYNCIO);
>+		vfs_msync(mp, MNT_NOWAIT);
>+		VFS_SYNC(mp, MNT_NOWAIT);
>+		curthread_pflags_restore(save);
>+		vn_finished_write(mp);
>+	}
>+	vfs_unbusy(mp);
>+
>+ out:
>+	vrele(vp);
>+	return (error);
>+}
>Index: sys/compat/linux/linux_sysctl.c
>===================================================================
>--- sys/compat/linux/linux_sysctl.c	(revision 285633)
>+++ sys/compat/linux/linux_sysctl.c	(working copy)
>@@ -141,12 +141,12 @@
> 		return (ENOTDIR);
> 	}
> 
>-	mib = malloc(la.nlen * sizeof(l_int), M_TEMP, M_WAITOK);
>+	mib = malloc(la.nlen * sizeof(l_int), M_LINUX, M_WAITOK);
> 	error = copyin(PTRIN(la.name), mib, la.nlen * sizeof(l_int));
> 	if (error) {
> 		LIN_SDT_PROBE1(sysctl, linux_sysctl, copyin_error, error);
> 		LIN_SDT_PROBE1(sysctl, linux_sysctl, return, error);
>-		free(mib, M_TEMP);
>+		free(mib, M_LINUX);
> 		return (error);
> 	}
> 
>@@ -158,7 +158,7 @@
> 		switch (mib[1]) {
> 		case LINUX_KERN_VERSION:
> 			error = handle_string(&la, version);
>-			free(mib, M_TEMP);
>+			free(mib, M_LINUX);
> 			LIN_SDT_PROBE1(sysctl, linux_sysctl, return, error);
> 			return (error);
> 		default:
>@@ -187,7 +187,7 @@
> 		sbuf_delete(sb);
> 	}
> 
>-	free(mib, M_TEMP);
>+	free(mib, M_LINUX);
> 
> 	LIN_SDT_PROBE1(sysctl, linux_sysctl, return, ENOTDIR);
> 	return (ENOTDIR);
>Index: sys/compat/linux/linux_time.c
>===================================================================
>--- sys/compat/linux/linux_time.c	(revision 285633)
>+++ sys/compat/linux/linux_time.c	(working copy)
>@@ -40,8 +40,11 @@
> 
> #include <sys/param.h>
> #include <sys/kernel.h>
>+#include <sys/lock.h>
> #include <sys/ucred.h>
> #include <sys/mount.h>
>+#include <sys/mutex.h>
>+#include <sys/resourcevar.h>
> #include <sys/sdt.h>
> #include <sys/signal.h>
> #include <sys/stdint.h>
>@@ -60,7 +63,7 @@
> #endif
> 
> #include <compat/linux/linux_dtrace.h>
>-#include <compat/linux/linux_misc.h>
>+#include <compat/linux/linux_timer.h>
> 
> /* DTrace init */
> LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
>@@ -103,7 +106,6 @@
> LIN_SDT_PROBE_DEFINE2(time, linux_nanosleep, entry, "const struct l_timespec *",
>     "struct l_timespec *");
> LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, conversion_error, "int");
>-LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, nanosleep_error, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, copyout_error, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, copyin_error, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, return, "int");
>@@ -110,7 +112,6 @@
> LIN_SDT_PROBE_DEFINE4(time, linux_clock_nanosleep, entry, "clockid_t", "int",
>     "struct l_timespec *", "struct l_timespec *");
> LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, conversion_error, "int");
>-LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, nanosleep_error, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, copyout_error, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, copyin_error, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, unsupported_flags, "int");
>@@ -117,13 +118,8 @@
> LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, unsupported_clockid, "int");
> LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, return, "int");
> 
>-static void native_to_linux_timespec(struct l_timespec *,
>-				     struct timespec *);
>-static int linux_to_native_timespec(struct timespec *,
>-				     struct l_timespec *);
>-static int linux_to_native_clockid(clockid_t *, clockid_t);
> 
>-static void
>+void
> native_to_linux_timespec(struct l_timespec *ltp, struct timespec *ntp)
> {
> 
>@@ -135,7 +131,7 @@
> 	LIN_SDT_PROBE0(time, native_to_linux_timespec, return);
> }
> 
>-static int
>+int
> linux_to_native_timespec(struct timespec *ntp, struct l_timespec *ltp)
> {
> 
>@@ -152,12 +148,26 @@
> 	return (0);
> }
> 
>-static int
>+int
> linux_to_native_clockid(clockid_t *n, clockid_t l)
> {
> 
> 	LIN_SDT_PROBE2(time, linux_to_native_clockid, entry, n, l);
> 
>+	if (l < 0) {
>+		/* cpu-clock */
>+		if ((l & LINUX_CLOCKFD_MASK) == LINUX_CLOCKFD)
>+			return (EINVAL);
>+		if (LINUX_CPUCLOCK_WHICH(l) >= LINUX_CPUCLOCK_MAX)
>+			return (EINVAL);
>+
>+		if (LINUX_CPUCLOCK_PERTHREAD(l))
>+			*n = CLOCK_THREAD_CPUTIME_ID;
>+		else
>+			*n = CLOCK_PROCESS_CPUTIME_ID;
>+		return (0);
>+	}
>+
> 	switch (l) {
> 	case LINUX_CLOCK_REALTIME:
> 		*n = CLOCK_REALTIME;
>@@ -165,10 +175,18 @@
> 	case LINUX_CLOCK_MONOTONIC:
> 		*n = CLOCK_MONOTONIC;
> 		break;
>-	case LINUX_CLOCK_PROCESS_CPUTIME_ID:
>-	case LINUX_CLOCK_THREAD_CPUTIME_ID:
>-	case LINUX_CLOCK_REALTIME_HR:
>-	case LINUX_CLOCK_MONOTONIC_HR:
>+	case LINUX_CLOCK_REALTIME_COARSE:
>+		*n = CLOCK_REALTIME_FAST;
>+		break;
>+	case LINUX_CLOCK_MONOTONIC_COARSE:
>+		*n = CLOCK_MONOTONIC_FAST;
>+		break;
>+	case LINUX_CLOCK_MONOTONIC_RAW:
>+	case LINUX_CLOCK_BOOTTIME:
>+	case LINUX_CLOCK_REALTIME_ALARM:
>+	case LINUX_CLOCK_BOOTTIME_ALARM:
>+	case LINUX_CLOCK_SGI_CYCLE:
>+	case LINUX_CLOCK_TAI:
> 		LIN_SDT_PROBE1(time, linux_to_native_clockid,
> 		    unsupported_clockid, l);
> 		LIN_SDT_PROBE1(time, linux_to_native_clockid, return, EINVAL);
>@@ -190,9 +208,14 @@
> linux_clock_gettime(struct thread *td, struct linux_clock_gettime_args *args)
> {
> 	struct l_timespec lts;
>-	int error;
>+	struct timespec tp;
>+	struct rusage ru;
>+	struct thread *targettd;
>+	struct proc *p;
>+	int error, clockwhich;
> 	clockid_t nwhich = 0;	/* XXX: GCC */
>-	struct timespec tp;
>+	pid_t pid;
>+	lwpid_t tid;
> 
> 	LIN_SDT_PROBE2(time, linux_clock_gettime, entry, args->which, args->tp);
> 
>@@ -203,7 +226,101 @@
> 		LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
> 		return (error);
> 	}
>-	error = kern_clock_gettime(td, nwhich, &tp);
>+
>+	switch (nwhich) {
>+	case CLOCK_PROCESS_CPUTIME_ID:
>+		clockwhich = LINUX_CPUCLOCK_WHICH(args->which);
>+		pid = LINUX_CPUCLOCK_ID(args->which);
>+		if (pid == 0) {
>+			targettd = td;
>+			p = td->td_proc;
>+			PROC_LOCK(p);
>+		} else {
>+			error = pget(pid, PGET_CANSEE, &p);
>+			if (error != 0)
>+				return (EINVAL);
>+		}
>+		switch (clockwhich) {
>+		case LINUX_CPUCLOCK_PROF:
>+			PROC_STATLOCK(p);
>+			calcru(p, &ru.ru_utime, &ru.ru_stime);
>+			PROC_STATUNLOCK(p);
>+			PROC_UNLOCK(p);
>+			timevaladd(&ru.ru_utime, &ru.ru_stime);
>+			TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
>+			break;
>+		case LINUX_CPUCLOCK_VIRT:
>+			PROC_STATLOCK(p);
>+			calcru(p, &ru.ru_utime, &ru.ru_stime);
>+			PROC_STATUNLOCK(p);
>+			PROC_UNLOCK(p);
>+			TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
>+			break;
>+		case LINUX_CPUCLOCK_SCHED:
>+			PROC_UNLOCK(p);
>+			error = kern_clock_getcpuclockid2(td, pid,
>+			    CPUCLOCK_WHICH_PID, &nwhich);
>+			if (error != 0)
>+				return (EINVAL);
>+			error = kern_clock_gettime(td, nwhich, &tp);
>+			break;
>+		default:
>+			PROC_UNLOCK(p);
>+			return (EINVAL);
>+		}
>+
>+		break;
>+
>+	case CLOCK_THREAD_CPUTIME_ID:
>+		clockwhich = LINUX_CPUCLOCK_WHICH(args->which);
>+		p = td->td_proc;
>+		tid = LINUX_CPUCLOCK_ID(args->which);
>+		if (tid == 0) {
>+			targettd = td;
>+			PROC_LOCK(p);
>+		} else {
>+			targettd = tdfind(tid, p->p_pid);
>+			if (targettd == NULL)
>+				return (EINVAL);
>+		}
>+		switch (clockwhich) {
>+		case LINUX_CPUCLOCK_PROF:
>+			PROC_STATLOCK(p);
>+			thread_lock(targettd);
>+			rufetchtd(targettd, &ru);
>+			thread_unlock(targettd);
>+			PROC_STATUNLOCK(p);
>+			PROC_UNLOCK(p);
>+			timevaladd(&ru.ru_utime, &ru.ru_stime);
>+			TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
>+			break;
>+		case LINUX_CPUCLOCK_VIRT:
>+			PROC_STATLOCK(p);
>+			thread_lock(targettd);
>+			rufetchtd(targettd, &ru);
>+			thread_unlock(targettd);
>+			PROC_STATUNLOCK(p);
>+			PROC_UNLOCK(p);
>+			TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
>+			break;
>+		case LINUX_CPUCLOCK_SCHED:
>+			error = kern_clock_getcpuclockid2(td, tid,
>+			    CPUCLOCK_WHICH_TID, &nwhich);
>+			PROC_UNLOCK(p);
>+			if (error != 0)
>+				return (EINVAL);
>+			error = kern_clock_gettime(td, nwhich, &tp);
>+			break;
>+		default:
>+			PROC_UNLOCK(p);
>+			return (EINVAL);
>+		}
>+		break;
>+
>+	default:
>+		error = kern_clock_gettime(td, nwhich, &tp);
>+		break;
>+	}
> 	if (error != 0) {
> 		LIN_SDT_PROBE1(time, linux_clock_gettime, gettime_error, error);
> 		LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
>@@ -261,19 +378,16 @@
> int
> linux_clock_getres(struct thread *td, struct linux_clock_getres_args *args)
> {
>+	struct proc *p;
> 	struct timespec ts;
> 	struct l_timespec lts;
>-	int error;
>+	int error, clockwhich;
> 	clockid_t nwhich = 0;	/* XXX: GCC */
>+	pid_t pid;
>+	lwpid_t tid;
> 
> 	LIN_SDT_PROBE2(time, linux_clock_getres, entry, args->which, args->tp);
> 
>-	if (args->tp == NULL) {
>-		LIN_SDT_PROBE0(time, linux_clock_getres, nullcall);
>-		LIN_SDT_PROBE1(time, linux_clock_getres, return, 0);
>-	  	return (0);
>-	}
>-
> 	error = linux_to_native_clockid(&nwhich, args->which);
> 	if (error != 0) {
> 		LIN_SDT_PROBE1(time, linux_clock_getres, conversion_error,
>@@ -281,6 +395,55 @@
> 		LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
> 		return (error);
> 	}
>+
>+	switch (nwhich) {
>+	case CLOCK_THREAD_CPUTIME_ID:
>+		tid = LINUX_CPUCLOCK_ID(args->which);
>+		if (tid != 0) {
>+			p = td->td_proc;
>+			if (tdfind(tid, p->p_pid) == NULL)
>+				return (ESRCH);
>+			PROC_UNLOCK(p);
>+		}
>+		break;
>+	case CLOCK_PROCESS_CPUTIME_ID:
>+		pid = LINUX_CPUCLOCK_ID(args->which);
>+		if (pid != 0) {
>+			error = pget(pid, PGET_CANSEE, &p);
>+			if (error != 0)
>+				return (EINVAL);
>+			PROC_UNLOCK(p);
>+		}
>+		break;
>+	}
>+
>+	if (args->tp == NULL) {
>+		LIN_SDT_PROBE0(time, linux_clock_getres, nullcall);
>+		LIN_SDT_PROBE1(time, linux_clock_getres, return, 0);
>+	  	return (0);
>+	}
>+
>+	switch (nwhich) {
>+	case CLOCK_THREAD_CPUTIME_ID:
>+	case CLOCK_PROCESS_CPUTIME_ID:
>+		clockwhich = LINUX_CPUCLOCK_WHICH(args->which);
>+		switch (clockwhich) {
>+		case LINUX_CPUCLOCK_PROF:
>+			nwhich = CLOCK_PROF;
>+			break;
>+		case LINUX_CPUCLOCK_VIRT:
>+			nwhich = CLOCK_VIRTUAL;
>+			break;
>+		case LINUX_CPUCLOCK_SCHED:
>+			break;
>+		default:
>+			return (EINVAL);
>+		}
>+		break;
>+
>+	default:
>+		break;
>+	}
> 	error = kern_clock_getres(td, nwhich, &ts);
> 	if (error != 0) {
> 		LIN_SDT_PROBE1(time, linux_clock_getres, getres_error, error);
>@@ -303,7 +466,7 @@
> 	struct timespec *rmtp;
> 	struct l_timespec lrqts, lrmts;
> 	struct timespec rqts, rmts;
>-	int error;
>+	int error, error2;
> 
> 	LIN_SDT_PROBE2(time, linux_nanosleep, entry, args->rqtp, args->rmtp);
> 
>@@ -315,9 +478,9 @@
> 	}
> 
> 	if (args->rmtp != NULL)
>-	   	rmtp = &rmts;
>+		rmtp = &rmts;
> 	else
>-	   	rmtp = NULL;
>+		rmtp = NULL;
> 
> 	error = linux_to_native_timespec(&rqts, &lrqts);
> 	if (error != 0) {
>@@ -326,25 +489,19 @@
> 		return (error);
> 	}
> 	error = kern_nanosleep(td, &rqts, rmtp);
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(time, linux_nanosleep, nanosleep_error, error);
>-		LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
>-		return (error);
>-	}
>-
> 	if (args->rmtp != NULL) {
>-	   	native_to_linux_timespec(&lrmts, rmtp);
>-	   	error = copyout(&lrmts, args->rmtp, sizeof(lrmts));
>-		if (error != 0) {
>+		native_to_linux_timespec(&lrmts, rmtp);
>+		error2 = copyout(&lrmts, args->rmtp, sizeof(lrmts));
>+		if (error2 != 0) {
> 			LIN_SDT_PROBE1(time, linux_nanosleep, copyout_error,
>-			    error);
>-			LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
>-		   	return (error);
>+			    error2);
>+			LIN_SDT_PROBE1(time, linux_nanosleep, return, error2);
>+			return (error2);
> 		}
> 	}
> 
>-	LIN_SDT_PROBE1(time, linux_nanosleep, return, 0);
>-	return (0);
>+	LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
>+	return (error);
> }
> 
> int
>@@ -353,7 +510,7 @@
> 	struct timespec *rmtp;
> 	struct l_timespec lrqts, lrmts;
> 	struct timespec rqts, rmts;
>-	int error;
>+	int error, error2;
> 
> 	LIN_SDT_PROBE4(time, linux_clock_nanosleep, entry, args->which,
> 	    args->flags, args->rqtp, args->rmtp);
>@@ -373,7 +530,7 @@
> 		return (EINVAL);
> 	}
> 
>-	error = copyin(args->rqtp, &lrqts, sizeof lrqts);
>+	error = copyin(args->rqtp, &lrqts, sizeof(lrqts));
> 	if (error != 0) {
> 		LIN_SDT_PROBE1(time, linux_clock_nanosleep, copyin_error,
> 		    error);
>@@ -382,9 +539,9 @@
> 	}
> 
> 	if (args->rmtp != NULL)
>-	   	rmtp = &rmts;
>+		rmtp = &rmts;
> 	else
>-	   	rmtp = NULL;
>+		rmtp = NULL;
> 
> 	error = linux_to_native_timespec(&rqts, &lrqts);
> 	if (error != 0) {
>@@ -394,24 +551,19 @@
> 		return (error);
> 	}
> 	error = kern_nanosleep(td, &rqts, rmtp);
>-	if (error != 0) {
>-		LIN_SDT_PROBE1(time, linux_clock_nanosleep, nanosleep_error,
>-		    error);
>-		LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
>-		return (error);
>-	}
>-
> 	if (args->rmtp != NULL) {
>+		/* XXX. Not for TIMER_ABSTIME */
> 	   	native_to_linux_timespec(&lrmts, rmtp);
>-	   	error = copyout(&lrmts, args->rmtp, sizeof lrmts );
>-		if (error != 0) {
>+		error2 = copyout(&lrmts, args->rmtp, sizeof(lrmts));
>+		if (error2 != 0) {
> 			LIN_SDT_PROBE1(time, linux_clock_nanosleep,
>-			    copyout_error, error);
>-			LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
>-		   	return (error);
>+			    copyout_error, error2);
>+			LIN_SDT_PROBE1(time, linux_clock_nanosleep,
>+			    return, error2);
>+			return (error2);
> 		}
> 	}
> 
>-	LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, 0);
>-	return (0);
>+	LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
>+	return (error);
> }
>Index: sys/compat/linux/linux_timer.c
>===================================================================
>--- sys/compat/linux/linux_timer.c	(revision 285633)
>+++ sys/compat/linux/linux_timer.c	(working copy)
>@@ -49,24 +49,7 @@
> #endif
> #include <compat/linux/linux_timer.h>
> 
>-static int
>-linux_convert_l_clockid(clockid_t *clock_id)
>-{
> 
>-	switch (*clock_id) {
>-	case LINUX_CLOCK_REALTIME:
>-		*clock_id = CLOCK_REALTIME;
>-		break;
>-	case LINUX_CLOCK_MONOTONIC:
>-		*clock_id = CLOCK_MONOTONIC;
>-		break;
>-	default:
>-		return (EINVAL);
>-	}
>-
>-	return (0);
>-}
>-
> static int
> linux_convert_l_sigevent(struct l_sigevent *l_sig, struct sigevent *sig)
> {
>@@ -75,7 +58,7 @@
> 	switch (l_sig->sigev_notify) {
> 	case L_SIGEV_SIGNAL:
> 		sig->sigev_notify = SIGEV_SIGNAL;
>-		CP(*l_sig, *sig, sigev_signo);
>+		sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo);
> 		PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr);
> 		break;
> 	case L_SIGEV_NONE:
>@@ -92,7 +75,7 @@
> 	case L_SIGEV_THREAD_ID:
> 		sig->sigev_notify = SIGEV_THREAD_ID;
> 		CP2(*l_sig, *sig, _l_sigev_un._tid, sigev_notify_thread_id);
>-		CP(*l_sig, *sig, sigev_signo);
>+		sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo);
> 		PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr);
> 		break;
> 	default:
>@@ -106,6 +89,7 @@
> {
> 	struct l_sigevent l_ev;
> 	struct sigevent ev, *evp;
>+	clockid_t nwhich;
> 	int error, id;
> 
> 	if (uap->evp == NULL) {
>@@ -119,10 +103,10 @@
> 			return (error);
> 		evp = &ev;
> 	}
>-	error = linux_convert_l_clockid(&uap->clock_id);
>+	error = linux_to_native_clockid(&nwhich, uap->clock_id);
> 	if (error != 0)
> 		return (error);
>-	error = kern_ktimer_create(td, uap->clock_id, evp, &id, -1);
>+	error = kern_ktimer_create(td, nwhich, evp, &id, -1);
> 	if (error == 0) {
> 		error = copyout(&id, uap->timerid, sizeof(int));
> 		if (error != 0)
>@@ -179,4 +163,3 @@
> 
> 	return (kern_ktimer_delete(td, uap->timerid));
> }
>-
>Index: sys/compat/linux/linux_timer.h
>===================================================================
>--- sys/compat/linux/linux_timer.h	(revision 285633)
>+++ sys/compat/linux/linux_timer.h	(working copy)
>@@ -56,6 +56,23 @@
> #define	LINUX_CLOCK_SGI_CYCLE			10
> #define	LINUX_CLOCK_TAI				11
> 
>+#define	LINUX_CPUCLOCK_PERTHREAD_MASK		4
>+#define	LINUX_CPUCLOCK_MASK			3
>+#define	LINUX_CPUCLOCK_WHICH(clock)		\
>+	((clock) & (clockid_t) LINUX_CPUCLOCK_MASK)
>+#define	LINUX_CPUCLOCK_PROF			0
>+#define	LINUX_CPUCLOCK_VIRT			1
>+#define	LINUX_CPUCLOCK_SCHED			2
>+#define	LINUX_CPUCLOCK_MAX			3
>+#define	LINUX_CLOCKFD				LINUX_CPUCLOCK_MAX
>+#define	LINUX_CLOCKFD_MASK			\
>+	(LINUX_CPUCLOCK_PERTHREAD_MASK|LINUX_CPUCLOCK_MASK)
>+
>+#define	LINUX_CPUCLOCK_ID(clock)		((pid_t) ~((clock) >> 3))
>+#define	LINUX_CPUCLOCK_PERTHREAD(clock)		\
>+	(((clock) & (clockid_t) LINUX_CPUCLOCK_PERTHREAD_MASK) != 0)
>+
>+
> #define	L_SIGEV_SIGNAL				0
> #define	L_SIGEV_NONE				1
> #define	L_SIGEV_THREAD				2
>@@ -94,4 +111,10 @@
> 	struct l_timespec it_value;
> };
> 
>+void native_to_linux_timespec(struct l_timespec *,
>+				     struct timespec *);
>+int linux_to_native_timespec(struct timespec *,
>+				     struct l_timespec *);
>+int linux_to_native_clockid(clockid_t *, clockid_t);
>+
> #endif	/* _LINUX_TIMER_H */
>Index: sys/compat/linux/linux_uid16.c
>===================================================================
>--- sys/compat/linux/linux_uid16.c	(revision 285633)
>+++ sys/compat/linux/linux_uid16.c	(working copy)
>@@ -172,12 +172,12 @@
> 		LIN_SDT_PROBE1(uid16, linux_setgroups16, return, EINVAL);
> 		return (EINVAL);
> 	}
>-	linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_TEMP, M_WAITOK);
>+	linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_LINUX, M_WAITOK);
> 	error = copyin(args->gidset, linux_gidset, ngrp * sizeof(l_gid16_t));
> 	if (error) {
> 		LIN_SDT_PROBE1(uid16, linux_setgroups16, copyin_error, error);
> 		LIN_SDT_PROBE1(uid16, linux_setgroups16, return, error);
>-		free(linux_gidset, M_TEMP);
>+		free(linux_gidset, M_LINUX);
> 		return (error);
> 	}
> 	newcred = crget();
>@@ -219,7 +219,7 @@
> 	crfree(oldcred);
> 	error = 0;
> out:
>-	free(linux_gidset, M_TEMP);
>+	free(linux_gidset, M_LINUX);
> 
> 	LIN_SDT_PROBE1(uid16, linux_setgroups16, return, error);
> 	return (error);
>@@ -260,7 +260,7 @@
> 
> 	ngrp = 0;
> 	linux_gidset = malloc(bsd_gidsetsz * sizeof(*linux_gidset),
>-	    M_TEMP, M_WAITOK);
>+	    M_LINUX, M_WAITOK);
> 	while (ngrp < bsd_gidsetsz) {
> 		linux_gidset[ngrp] = bsd_gidset[ngrp + 1];
> 		ngrp++;
>@@ -267,7 +267,7 @@
> 	}
> 
> 	error = copyout(linux_gidset, args->gidset, ngrp * sizeof(l_gid16_t));
>-	free(linux_gidset, M_TEMP);
>+	free(linux_gidset, M_LINUX);
> 	if (error) {
> 		LIN_SDT_PROBE1(uid16, linux_getgroups16, copyout_error, error);
> 		LIN_SDT_PROBE1(uid16, linux_getgroups16, return, error);
>Index: sys/compat/linux/linux_util.c
>===================================================================
>--- sys/compat/linux/linux_util.c	(revision 285633)
>+++ sys/compat/linux/linux_util.c	(working copy)
>@@ -53,48 +53,14 @@
> #include <machine/stdarg.h>
> 
> #include <compat/linux/linux_util.h>
>-#ifdef COMPAT_LINUX32
>-#include <machine/../linux32/linux.h>
>-#else
>-#include <machine/../linux/linux.h>
>-#endif
> 
>-#include <compat/linux/linux_dtrace.h>
>+MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
>+MALLOC_DEFINE(M_EPOLL, "lepoll", "Linux events structures");
>+MALLOC_DEFINE(M_FUTEX, "futex", "Linux futexes");
>+MALLOC_DEFINE(M_FUTEX_WP, "futex wp", "Linux futex waiting proc");
> 
> const char      linux_emul_path[] = "/compat/linux";
> 
>-/* DTrace init */
>-LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
>-
>-/**
>- * DTrace probes in this module.
>- */
>-LIN_SDT_PROBE_DEFINE5(util, linux_emul_convpath, entry, "const char *",
>-    "enum uio_seg", "char **", "int", "int");
>-LIN_SDT_PROBE_DEFINE1(util, linux_emul_convpath, return, "int");
>-LIN_SDT_PROBE_DEFINE1(util, linux_msg, entry, "const char *");
>-LIN_SDT_PROBE_DEFINE0(util, linux_msg, return);
>-LIN_SDT_PROBE_DEFINE2(util, linux_driver_get_name_dev, entry, "device_t",
>-    "const char *");
>-LIN_SDT_PROBE_DEFINE0(util, linux_driver_get_name_dev, nullcall);
>-LIN_SDT_PROBE_DEFINE1(util, linux_driver_get_name_dev, return, "char *");
>-LIN_SDT_PROBE_DEFINE3(util, linux_driver_get_major_minor, entry, "char *",
>-    "int *", "int *");
>-LIN_SDT_PROBE_DEFINE0(util, linux_driver_get_major_minor, nullcall);
>-LIN_SDT_PROBE_DEFINE1(util, linux_driver_get_major_minor, notfound, "char *");
>-LIN_SDT_PROBE_DEFINE3(util, linux_driver_get_major_minor, return, "int",
>-    "int", "int");
>-LIN_SDT_PROBE_DEFINE0(util, linux_get_char_devices, entry);
>-LIN_SDT_PROBE_DEFINE1(util, linux_get_char_devices, return, "char *");
>-LIN_SDT_PROBE_DEFINE1(util, linux_free_get_char_devices, entry, "char *");
>-LIN_SDT_PROBE_DEFINE0(util, linux_free_get_char_devices, return);
>-LIN_SDT_PROBE_DEFINE1(util, linux_device_register_handler, entry,
>-    "struct linux_device_handler *");
>-LIN_SDT_PROBE_DEFINE1(util, linux_device_register_handler, return, "int");
>-LIN_SDT_PROBE_DEFINE1(util, linux_device_unregister_handler, entry,
>-    "struct linux_device_handler *");
>-LIN_SDT_PROBE_DEFINE1(util, linux_device_unregister_handler, return, "int");
>-
> /*
>  * Search an alternate path before passing pathname arguments on to
>  * system calls. Useful for keeping a separate 'emulation tree'.
>@@ -108,13 +74,9 @@
> {
> 	int retval;
> 
>-	LIN_SDT_PROBE5(util, linux_emul_convpath, entry, path, pathseg, pbuf,
>-	    cflag, dfd);
>-
> 	retval = kern_alternate_path(td, linux_emul_path, path, pathseg, pbuf,
> 	    cflag, dfd);
> 
>-	LIN_SDT_PROBE1(util, linux_emul_convpath, return, retval);
> 	return (retval);
> }
> 
>@@ -124,8 +86,6 @@
> 	va_list ap;
> 	struct proc *p;
> 
>-	LIN_SDT_PROBE1(util, linux_msg, entry, fmt);
>-
> 	p = td->td_proc;
> 	printf("linux: pid %d (%s): ", (int)p->p_pid, p->p_comm);
> 	va_start(ap, fmt);
>@@ -132,8 +92,6 @@
> 	vprintf(fmt, ap);
> 	va_end(ap);
> 	printf("\n");
>-
>-	LIN_SDT_PROBE0(util, linux_msg, return);
> }
> 
> struct device_element
>@@ -156,24 +114,14 @@
> 	struct device_element *de;
> 	const char *device_name = device_get_name(dev);
> 
>-	LIN_SDT_PROBE2(util, linux_driver_get_name_dev, entry, dev,
>-	    device_name);
>-
>-	if (device_name == NULL) {
>-		LIN_SDT_PROBE0(util, linux_driver_get_name_dev, nullcall);
>-		LIN_SDT_PROBE1(util, linux_driver_get_name_dev, return, NULL);
>+	if (device_name == NULL)
> 		return NULL;
>-	}
> 	TAILQ_FOREACH(de, &devices, list) {
>-		if (strcmp(device_name, de->entry.bsd_driver_name) == 0) {
>-			LIN_SDT_PROBE1(util, linux_driver_get_name_dev, return,
>-			    de->entry.linux_driver_name);
>+		if (strcmp(device_name, de->entry.bsd_driver_name) == 0)
> 			return (de->entry.linux_driver_name);
>-		}
> 	}
> 
>-	LIN_SDT_PROBE1(util, linux_driver_get_name_dev, return, NULL);
>-	return NULL;
>+	return (NULL);
> }
> 
> int
>@@ -181,15 +129,8 @@
> {
> 	struct device_element *de;
> 
>-	LIN_SDT_PROBE3(util, linux_driver_get_major_minor, entry, node, major,
>-	    minor);
>-
>-	if (node == NULL || major == NULL || minor == NULL) {
>-		LIN_SDT_PROBE0(util, linux_driver_get_major_minor, nullcall);
>-		LIN_SDT_PROBE3(util, linux_driver_get_major_minor, return, 1,
>-		   0, 0);
>+	if (node == NULL || major == NULL || minor == NULL)
> 		return 1;
>-	}
> 
> 	if (strlen(node) > strlen("pts/") &&
> 	    strncmp(node, "pts/", strlen("pts/")) == 0) {
>@@ -204,9 +145,7 @@
> 		*major = 136 + (devno / 256);
> 		*minor = devno % 256;
> 
>-		LIN_SDT_PROBE3(util, linux_driver_get_major_minor, return, 0,
>-		    *major, *minor);
>-		return 0;
>+		return (0);
> 	}
> 
> 	TAILQ_FOREACH(de, &devices, list) {
>@@ -213,16 +152,11 @@
> 		if (strcmp(node, de->entry.bsd_device_name) == 0) {
> 			*major = de->entry.linux_major;
> 			*minor = de->entry.linux_minor;
>-
>-			LIN_SDT_PROBE3(util, linux_driver_get_major_minor,
>-			    return, 0, *major, *minor);
>-			return 0;
>+			return (0);
> 		}
> 	}
> 
>-	LIN_SDT_PROBE1(util, linux_driver_get_major_minor, notfound, node);
>-	LIN_SDT_PROBE3(util, linux_driver_get_major_minor, return, 1, 0, 0);
>-	return 1;
>+	return (1);
> }
> 
> char *
>@@ -233,8 +167,6 @@
> 	char formated[256];
> 	int current_size = 0, string_size = 1024;
> 
>-	LIN_SDT_PROBE0(util, linux_get_char_devices, entry);
>-
> 	string = malloc(string_size, M_LINUX, M_WAITOK);
> 	string[0] = '\000';
> 	last = "";
>@@ -261,8 +193,7 @@
> 		}
> 	}
> 
>-	LIN_SDT_PROBE1(util, linux_get_char_devices, return, string);
>-	return string;
>+	return (string);
> }
> 
> void
>@@ -269,11 +200,7 @@
> linux_free_get_char_devices(char *string)
> {
> 
>-	LIN_SDT_PROBE1(util, linux_get_char_devices, entry, string);
>-
> 	free(string, M_LINUX);
>-
>-	LIN_SDT_PROBE0(util, linux_get_char_devices, return);
> }
> 
> static int linux_major_starting = 200;
>@@ -283,13 +210,8 @@
> {
> 	struct device_element *de;
> 
>-	LIN_SDT_PROBE1(util, linux_device_register_handler, entry, d);
>-
>-	if (d == NULL) {
>-		LIN_SDT_PROBE1(util, linux_device_register_handler, return,
>-		    EINVAL);
>+	if (d == NULL)
> 		return (EINVAL);
>-	}
> 
> 	de = malloc(sizeof(*de), M_LINUX, M_WAITOK);
> 	if (d->linux_major < 0) {
>@@ -300,7 +222,6 @@
> 	/* Add the element to the list, sorted on span. */
> 	TAILQ_INSERT_TAIL(&devices, de, list);
> 
>-	LIN_SDT_PROBE1(util, linux_device_register_handler, return, 0);
> 	return (0);
> }
> 
>@@ -309,13 +230,8 @@
> {
> 	struct device_element *de;
> 
>-	LIN_SDT_PROBE1(util, linux_device_unregister_handler, entry, d);
>-
>-	if (d == NULL) {
>-		LIN_SDT_PROBE1(util, linux_device_unregister_handler, return,
>-		    EINVAL);
>+	if (d == NULL)
> 		return (EINVAL);
>-	}
> 
> 	TAILQ_FOREACH(de, &devices, list) {
> 		if (bcmp(d, &de->entry, sizeof(*d)) == 0) {
>@@ -322,12 +238,9 @@
> 			TAILQ_REMOVE(&devices, de, list);
> 			free(de, M_LINUX);
> 
>-			LIN_SDT_PROBE1(util, linux_device_unregister_handler,
>-			    return, 0);
> 			return (0);
> 		}
> 	}
> 
>-	LIN_SDT_PROBE1(util, linux_device_unregister_handler, return, EINVAL);
> 	return (EINVAL);
> }
>Index: sys/compat/linux/linux_util.h
>===================================================================
>--- sys/compat/linux/linux_util.h	(revision 285633)
>+++ sys/compat/linux/linux_util.h	(working copy)
>@@ -44,6 +44,11 @@
> #include <sys/cdefs.h>
> #include <sys/uio.h>
> 
>+MALLOC_DECLARE(M_LINUX);
>+MALLOC_DECLARE(M_EPOLL);
>+MALLOC_DECLARE(M_FUTEX);
>+MALLOC_DECLARE(M_FUTEX_WP);
>+
> extern const char linux_emul_path[];
> 
> int linux_emul_convpath(struct thread *, const char *, enum uio_seg, char **, int, int);
>@@ -115,7 +120,6 @@
> #define	LINUX_CTRFMT(nm, fmt)	#nm"("fmt")"
> 
> #define	LINUX_CTR6(f, m, p1, p2, p3, p4, p5, p6) do {			\
>-	if (ldebug(f))							\
> 		CTR6(KTR_LINUX, LINUX_CTRFMT(f, m),			\
> 		    p1, p2, p3, p4, p5, p6);				\
> } while (0)
>Index: sys/compat/linux/linux_vdso.c
>===================================================================
>--- sys/compat/linux/linux_vdso.c	(revision 0)
>+++ sys/compat/linux/linux_vdso.c	(working copy)
>@@ -0,0 +1,244 @@
>+/*-
>+ * Copyright (c) 2013 Dmitry Chagin
>+ * 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
>+ *    in this position and unchanged.
>+ * 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>
>+__FBSDID("$FreeBSD$");
>+
>+#include "opt_compat.h"
>+
>+#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
>+#define	__ELF_WORD_SIZE	32
>+#else
>+#define	__ELF_WORD_SIZE	64
>+#endif
>+
>+#include <sys/param.h>
>+#include <sys/systm.h>
>+#include <sys/elf.h>
>+#include <sys/kernel.h>
>+#include <sys/lock.h>
>+#include <sys/rwlock.h>
>+#include <sys/queue.h>
>+#include <sys/sysent.h>
>+
>+#include <vm/vm.h>
>+#include <vm/vm_param.h>
>+#include <vm/pmap.h>
>+#include <vm/vm_extern.h>
>+#include <vm/vm_kern.h>
>+#include <vm/vm_map.h>
>+#include <vm/vm_object.h>
>+#include <vm/vm_page.h>
>+#include <vm/vm_pager.h>
>+
>+#include <compat/linux/linux_vdso.h>
>+
>+SLIST_HEAD(, linux_vdso_sym) __elfN(linux_vdso_syms) =
>+    SLIST_HEAD_INITIALIZER(__elfN(linux_vdso_syms));
>+
>+static int __elfN(symtabindex);
>+static int __elfN(symstrindex);
>+
>+static void
>+__elfN(linux_vdso_lookup)(Elf_Ehdr *, struct linux_vdso_sym *);
>+
>+
>+void
>+__elfN(linux_vdso_sym_init)(struct linux_vdso_sym *s)
>+{
>+
>+	SLIST_INSERT_HEAD(&__elfN(linux_vdso_syms), s, sym);
>+}
>+
>+vm_object_t
>+__elfN(linux_shared_page_init)(char **mapping)
>+{
>+	vm_page_t m;
>+	vm_object_t obj;
>+	vm_offset_t addr;
>+
>+	obj = vm_pager_allocate(OBJT_PHYS, 0, PAGE_SIZE,
>+	    VM_PROT_DEFAULT, 0, NULL);
>+	VM_OBJECT_WLOCK(obj);
>+	m = vm_page_grab(obj, 0, VM_ALLOC_NOBUSY | VM_ALLOC_ZERO);
>+	m->valid = VM_PAGE_BITS_ALL;
>+	VM_OBJECT_WUNLOCK(obj);
>+	addr = kva_alloc(PAGE_SIZE);
>+	pmap_qenter(addr, &m, 1);
>+	*mapping = (char *)addr;
>+	return (obj);
>+}
>+
>+void
>+__elfN(linux_shared_page_fini)(vm_object_t obj)
>+{
>+
>+	vm_object_deallocate(obj);
>+}
>+
>+void
>+__elfN(linux_vdso_fixup)(struct sysentvec *sv)
>+{
>+	Elf_Ehdr *ehdr;
>+	Elf_Shdr *shdr;
>+	int i;
>+
>+	ehdr = (Elf_Ehdr *) sv->sv_sigcode;
>+
>+	if (!IS_ELF(*ehdr) ||
>+	    ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
>+	    ehdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
>+	    ehdr->e_ident[EI_VERSION] != EV_CURRENT ||
>+	    ehdr->e_shoff == 0 ||
>+	    ehdr->e_shentsize != sizeof(Elf_Shdr))
>+		panic("Linux invalid vdso header.\n");
>+
>+	if (ehdr->e_type != ET_DYN)
>+		panic("Linux invalid vdso header.\n");
>+
>+	shdr = (Elf_Shdr *) ((caddr_t)ehdr + ehdr->e_shoff);
>+
>+	__elfN(symtabindex) = -1;
>+	__elfN(symstrindex) = -1;
>+	for (i = 0; i < ehdr->e_shnum; i++) {
>+		if (shdr[i].sh_size == 0)
>+			continue;
>+		if (shdr[i].sh_type == SHT_DYNSYM) {
>+			__elfN(symtabindex) = i;
>+			__elfN(symstrindex) = shdr[i].sh_link;
>+		}
>+	}
>+
>+	if (__elfN(symtabindex) == -1 || __elfN(symstrindex) == -1)
>+		panic("Linux invalid vdso header.\n");
>+
>+	ehdr->e_ident[EI_OSABI] = ELFOSABI_LINUX;
>+}
>+
>+void
>+__elfN(linux_vdso_reloc)(struct sysentvec *sv, long vdso_adjust)
>+{
>+	struct linux_vdso_sym *lsym;
>+	Elf_Ehdr *ehdr;
>+	Elf_Phdr *phdr;
>+	Elf_Shdr *shdr;
>+	Elf_Dyn *dyn;
>+	Elf_Sym *sym;
>+	int i, symcnt;
>+
>+	ehdr = (Elf_Ehdr *) sv->sv_sigcode;
>+
>+	/* Adjust our so relative to the sigcode_base */
>+	if (vdso_adjust != 0) {
>+		ehdr->e_entry += vdso_adjust;
>+		phdr = (Elf_Phdr *)((caddr_t)ehdr + ehdr->e_phoff);
>+
>+		/* phdrs */
>+		for (i = 0; i < ehdr->e_phnum; i++) {
>+			phdr[i].p_vaddr += vdso_adjust;
>+			if (phdr[i].p_type != PT_DYNAMIC)
>+				continue;
>+			dyn = (Elf_Dyn *)((caddr_t)ehdr + phdr[i].p_offset);
>+			for(; dyn->d_tag != DT_NULL; dyn++) {
>+				switch (dyn->d_tag) {
>+				case DT_PLTGOT:
>+				case DT_HASH:
>+				case DT_STRTAB:
>+				case DT_SYMTAB:
>+				case DT_RELA:
>+				case DT_INIT:
>+				case DT_FINI:
>+				case DT_REL:
>+				case DT_DEBUG:
>+				case DT_JMPREL:
>+				case DT_VERSYM:
>+				case DT_VERDEF:
>+				case DT_VERNEED:
>+				case DT_ADDRRNGLO ... DT_ADDRRNGHI:
>+					dyn->d_un.d_ptr += vdso_adjust;
>+					break;
>+				case DT_ENCODING ... DT_LOOS-1:
>+				case DT_LOOS ... DT_HIOS:
>+					if (dyn->d_tag >= DT_ENCODING &&
>+					    (dyn->d_tag & 1) == 0)
>+						dyn->d_un.d_ptr += vdso_adjust;
>+					break;
>+				default:
>+					break;
>+				}
>+			}
>+		}
>+
>+		/* sections */
>+		shdr = (Elf_Shdr *)((caddr_t)ehdr + ehdr->e_shoff);
>+		for(i = 0; i < ehdr->e_shnum; i++) {
>+			if (!(shdr[i].sh_flags & SHF_ALLOC))
>+				continue;
>+			shdr[i].sh_addr += vdso_adjust;
>+			if (shdr[i].sh_type != SHT_SYMTAB &&
>+			    shdr[i].sh_type != SHT_DYNSYM)
>+				continue;
>+
>+			sym = (Elf_Sym *)((caddr_t)ehdr + shdr[i].sh_offset);
>+			symcnt = shdr[i].sh_size / sizeof(*sym);
>+
>+			for(i = 0; i < symcnt; i++, sym++) {
>+				if (sym->st_shndx == SHN_UNDEF ||
>+				    sym->st_shndx == SHN_ABS)
>+					continue;
>+				sym->st_value += vdso_adjust;
>+			}
>+		}
>+	}
>+
>+	SLIST_FOREACH(lsym, &__elfN(linux_vdso_syms), sym)
>+		__elfN(linux_vdso_lookup)(ehdr, lsym);
>+}
>+
>+static void
>+__elfN(linux_vdso_lookup)(Elf_Ehdr *ehdr, struct linux_vdso_sym *vsym)
>+{
>+	vm_offset_t strtab, symname;
>+	uint32_t symcnt;
>+	Elf_Shdr *shdr;
>+	int i;
>+
>+	shdr = (Elf_Shdr *) ((caddr_t)ehdr + ehdr->e_shoff);
>+
>+	strtab = (vm_offset_t)((caddr_t)ehdr +
>+	    shdr[__elfN(symstrindex)].sh_offset);
>+	Elf_Sym *sym = (Elf_Sym *)((caddr_t)ehdr +
>+	    shdr[__elfN(symtabindex)].sh_offset);
>+	symcnt = shdr[__elfN(symtabindex)].sh_size / sizeof(*sym);
>+
>+	for (i = 0; i < symcnt; ++i, ++sym) {
>+		symname = strtab + sym->st_name;
>+		if (strncmp(vsym->symname, (char *)symname, vsym->size) == 0) {
>+			*vsym->ptr = (uintptr_t)sym->st_value;
>+			break;
>+		}
>+	}
>+}
>Index: sys/compat/linux/linux_vdso.h
>===================================================================
>--- sys/compat/linux/linux_vdso.h	(revision 0)
>+++ sys/compat/linux/linux_vdso.h	(working copy)
>@@ -0,0 +1,65 @@
>+/*-
>+ * Copyright (c) 2013 Dmitry Chagin
>+ * 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
>+ *    in this position and unchanged.
>+ * 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.
>+ *
>+ * $FreeBSD$
>+ */
>+
>+#ifndef _LINUX_VDSO_H_
>+#define	_LINUX_VDSO_H_
>+
>+#include <sys/types.h>
>+
>+struct linux_vdso_sym {
>+	SLIST_ENTRY(linux_vdso_sym) sym;
>+	uint32_t	size;
>+	uintptr_t *	ptr;
>+	char		symname[];
>+};
>+
>+vm_object_t __elfN(linux_shared_page_init)(char **);
>+void	__elfN(linux_shared_page_fini)(vm_object_t);
>+void	__elfN(linux_vdso_fixup)(struct sysentvec *);
>+void	__elfN(linux_vdso_reloc)(struct sysentvec *, long);
>+void	__elfN(linux_vdso_sym_init)(struct linux_vdso_sym *);
>+
>+#define	LINUX_VDSO_SYM_INTPTR(name)				\
>+uintptr_t name;							\
>+LINUX_VDSO_SYM_DEFINE(name)
>+
>+#define	LINUX_VDSO_SYM_CHAR(name)				\
>+const char * name;						\
>+LINUX_VDSO_SYM_DEFINE(name)
>+
>+#define	LINUX_VDSO_SYM_DEFINE(name)				\
>+static struct linux_vdso_sym name ## sym = {			\
>+	.symname	= #name,				\
>+	.size		= sizeof(#name),			\
>+	.ptr		= (uintptr_t *)&name			\
>+};								\
>+SYSINIT(__elfN(name ## _sym_init), SI_SUB_EXEC,			\
>+    SI_ORDER_FIRST, __elfN(linux_vdso_sym_init), &name ## sym);	\
>+struct __hack
>+
>+#endif	/* _LINUX_VDSO_H_ */
>Index: sys/compat/linux/stats_timing.d
>===================================================================
>--- sys/compat/linux/stats_timing.d	(revision 285633)
>+++ sys/compat/linux/stats_timing.d	(working copy)
>@@ -39,7 +39,6 @@
>  *      possible for a given application
>  *  - graph of longest running (CPU-time!) function in total
>  *    - may help finding problem cases in the kernel code
>- * - timing statistics for the emul_lock
>  * - graph of longest held (CPU-time!) locks
>  */
> 
>Index: sys/compat/svr4/svr4_misc.c
>===================================================================
>--- sys/compat/svr4/svr4_misc.c	(revision 285633)
>+++ sys/compat/svr4/svr4_misc.c	(working copy)
>@@ -875,9 +875,9 @@
> 
> 	p = td->td_proc;
> 	PROC_LOCK(p);
>-	PROC_SLOCK(p);
>+	PROC_STATLOCK(p);
> 	calcru(p, &utime, &stime);
>-	PROC_SUNLOCK(p);
>+	PROC_STATUNLOCK(p);
> 	calccru(p, &cutime, &cstime);
> 	PROC_UNLOCK(p);
> 
>@@ -1288,9 +1288,9 @@
> 			pid = p->p_pid;
> 			status = p->p_xstat;
> 			ru = p->p_ru;
>-			PROC_SLOCK(p);
>+			PROC_STATLOCK(p);
> 			calcru(p, &ru.ru_utime, &ru.ru_stime);
>-			PROC_SUNLOCK(p);
>+			PROC_STATUNLOCK(p);
> 			PROC_UNLOCK(p);
> 			sx_sunlock(&proctree_lock);
> 
>@@ -1315,9 +1315,9 @@
> 			pid = p->p_pid;
> 			status = W_STOPCODE(p->p_xstat);
> 			ru = p->p_ru;
>-			PROC_SLOCK(p);
>+			PROC_STATLOCK(p);
> 			calcru(p, &ru.ru_utime, &ru.ru_stime);
>-			PROC_SUNLOCK(p);
>+			PROC_STATUNLOCK(p);
> 			PROC_UNLOCK(p);
> 
> 		        if (((uap->options & SVR4_WNOWAIT)) == 0) {
>@@ -1339,9 +1339,9 @@
> 			pid = p->p_pid;
> 			ru = p->p_ru;
> 			status = SIGCONT;
>-			PROC_SLOCK(p);
>+			PROC_STATLOCK(p);
> 			calcru(p, &ru.ru_utime, &ru.ru_stime);
>-			PROC_SUNLOCK(p);
>+			PROC_STATUNLOCK(p);
> 			PROC_UNLOCK(p);
> 
> 		        if (((uap->options & SVR4_WNOWAIT)) == 0) {
>Index: sys/compat/svr4/svr4_sysvec.c
>===================================================================
>--- sys/compat/svr4/svr4_sysvec.c	(revision 285633)
>+++ sys/compat/svr4/svr4_sysvec.c	(working copy)
>@@ -196,6 +196,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = NULL,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> const char      svr4_emul_path[] = "/compat/svr4";
>Index: sys/conf/files
>===================================================================
>--- sys/conf/files	(revision 285633)
>+++ sys/conf/files	(working copy)
>@@ -2684,6 +2684,7 @@
> fs/procfs/procfs.c		optional procfs
> fs/procfs/procfs_ctl.c		optional procfs
> fs/procfs/procfs_dbregs.c	optional procfs
>+fs/procfs/procfs_fdlink.c	optional procfs
> fs/procfs/procfs_fpregs.c	optional procfs
> fs/procfs/procfs_ioctl.c	optional procfs
> fs/procfs/procfs_map.c		optional procfs
>Index: sys/conf/files.amd64
>===================================================================
>--- sys/conf/files.amd64	(revision 285633)
>+++ sys/conf/files.amd64	(working copy)
>@@ -20,6 +20,18 @@
> 	no-obj no-implicit-rule before-depend				\
> 	clean		"linux32_assym.h"
> #
>+linux32_locore.o	optional	compat_linux32		\
>+	dependency 	"linux32_assym.h $S/amd64/linux32/linux32_locore.s"	\
>+	compile-with	"${CC} -x assembler-with-cpp -DLOCORE -m32 -shared -s -pipe -I. -I$S -Werror -Wall -fno-common -nostdinc -nostdlib -Wl,-T$S/amd64/linux32/linux32_vdso.lds.s -Wl,-soname=linux32_vdso.so,--eh-frame-hdr,-fPIC,-warn-common ${.IMPSRC} -o ${.TARGET}" \
>+	no-obj no-implicit-rule						\
>+	clean		"linux32_locore.o"
>+#
>+linux32_vdso.so		optional	compat_linux32			\
>+	dependency 	"linux32_locore.o"				\
>+	compile-with	"${OBJCOPY} --input binary --output elf64-x86-64-freebsd --binary-architecture i386 linux32_locore.o ${.TARGET}" \
>+	no-implicit-rule						\
>+	clean		"linux32_vdso.so"
>+#
> ia32_genassym.o			standard				\
> 	dependency 	"$S/compat/ia32/ia32_genassym.c"		\
> 	compile-with	"${CC} ${CFLAGS:N-fno-common} -c ${.IMPSRC}"	\
>@@ -505,8 +517,6 @@
> # Linux/i386 binary support
> #
> amd64/linux32/linux32_dummy.c	optional	compat_linux32
>-amd64/linux32/linux32_locore.s	optional	compat_linux32		\
>-	dependency 	"linux32_assym.h"
> amd64/linux32/linux32_machdep.c	optional	compat_linux32
> amd64/linux32/linux32_support.s	optional	compat_linux32		\
> 	dependency 	"linux32_assym.h"
>@@ -513,6 +523,7 @@
> amd64/linux32/linux32_sysent.c	optional	compat_linux32
> amd64/linux32/linux32_sysvec.c	optional	compat_linux32
> compat/linux/linux_emul.c	optional	compat_linux32
>+compat/linux/linux_event.c	optional	compat_linux32
> compat/linux/linux_file.c	optional	compat_linux32
> compat/linux/linux_fork.c	optional	compat_linux32
> compat/linux/linux_futex.c	optional	compat_linux32
>@@ -529,6 +540,8 @@
> compat/linux/linux_timer.c	optional	compat_linux32
> compat/linux/linux_uid16.c	optional	compat_linux32
> compat/linux/linux_util.c	optional	compat_linux32
>+compat/linux/linux_vdso.c	optional	compat_linux32
>+compat/linux/linux_common.c	optional	compat_linux32
> dev/amr/amr_linux.c		optional	compat_linux32 amr
> dev/mfi/mfi_linux.c		optional	compat_linux32 mfi
> #
>Index: sys/conf/files.i386
>===================================================================
>--- sys/conf/files.i386	(revision 285633)
>+++ sys/conf/files.i386	(working copy)
>@@ -19,6 +19,18 @@
> 	no-obj no-implicit-rule before-depend				\
> 	clean		"linux_assym.h"
> #
>+linux_locore.o			optional	compat_linux		\
>+	dependency 	"linux_assym.h $S/i386/linux/linux_locore.s"	\
>+	compile-with	"${CC} -x assembler-with-cpp -DLOCORE -shared -s -pipe -I. -I$S -Werror -Wall -fno-common -nostdinc -nostdlib -Wl,-T$S/i386/linux/linux_vdso.lds.s -Wl,-soname=linux_vdso.so,--eh-frame-hdr,-fPIC,-warn-common ${.IMPSRC} -o ${.TARGET}" \
>+	no-obj no-implicit-rule						\
>+	clean		"linux_locore.o"
>+#
>+linux_vdso.so			optional	compat_linux		\
>+	dependency 	"linux_locore.o"				\
>+	compile-with	"${OBJCOPY} --input binary --output elf32-i386-freebsd --binary-architecture i386 linux_locore.o ${.TARGET}" \
>+	no-implicit-rule						\
>+	clean		"linux_vdso.so"
>+#
> svr4_genassym.o			optional	compat_svr4		\
> 	dependency 	"$S/i386/svr4/svr4_genassym.c"			\
> 	compile-with	"${CC} ${CFLAGS:N-fno-common} -c ${.IMPSRC}"	\
>@@ -80,6 +92,7 @@
> cddl/contrib/opensolaris/common/atomic/i386/opensolaris_atomic.S	optional zfs compile-with "${ZFS_S}"
> compat/linprocfs/linprocfs.c	optional linprocfs
> compat/linsysfs/linsysfs.c	optional linsysfs
>+compat/linux/linux_event.c	optional compat_linux
> compat/linux/linux_emul.c	optional compat_linux
> compat/linux/linux_file.c	optional compat_linux
> compat/linux/linux_fork.c	optional compat_linux
>@@ -97,6 +110,7 @@
> compat/linux/linux_timer.c	optional compat_linux
> compat/linux/linux_uid16.c	optional compat_linux
> compat/linux/linux_util.c	optional compat_linux
>+compat/linux/linux_vdso.c	optional compat_linux
> compat/ndis/kern_ndis.c		optional ndisapi pci
> compat/ndis/kern_windrv.c	optional ndisapi pci
> compat/ndis/subr_hal.c		optional ndisapi pci
>@@ -516,8 +530,6 @@
> i386/isa/spic.c			optional spic
> i386/linux/imgact_linux.c	optional compat_linux
> i386/linux/linux_dummy.c	optional compat_linux
>-i386/linux/linux_locore.s	optional compat_linux	\
>-	dependency 	"linux_assym.h"
> i386/linux/linux_machdep.c	optional compat_linux
> i386/linux/linux_ptrace.c	optional compat_linux
> i386/linux/linux_support.s	optional compat_linux	\
>Index: sys/conf/files.pc98
>===================================================================
>--- sys/conf/files.pc98	(revision 285633)
>+++ sys/conf/files.pc98	(working copy)
>@@ -41,6 +41,7 @@
> cddl/contrib/opensolaris/common/atomic/i386/opensolaris_atomic.S	optional zfs compile-with "${ZFS_S}"
> compat/linprocfs/linprocfs.c	optional linprocfs
> compat/linsysfs/linsysfs.c	optional linsysfs
>+compat/linux/linux_event.c	optional compat_linux
> compat/linux/linux_emul.c	optional compat_linux
> compat/linux/linux_file.c	optional compat_linux
> compat/linux/linux_fork.c	optional compat_linux
>Index: sys/ddb/db_ps.c
>===================================================================
>--- sys/ddb/db_ps.c	(revision 285633)
>+++ sys/ddb/db_ps.c	(working copy)
>@@ -392,17 +392,18 @@
> 	db_printf(" state: ");
> 	switch (p->p_state) {
> 	case PRS_NEW:
>-		db_printf("NEW\n");
>+		db_printf("NEW");
> 		break;
> 	case PRS_NORMAL:
>-		db_printf("NORMAL\n");
>+		db_printf("NORMAL");
> 		break;
> 	case PRS_ZOMBIE:
>-		db_printf("ZOMBIE\n");
>+		db_printf("ZOMBIE");
> 		break;
> 	default:
>-		db_printf("??? (%#x)\n", p->p_state);
>+		db_printf("??? (%#x)", p->p_state);
> 	}
>+	db_printf(" (p_flag 0x%x)\n", p->p_flag);
> 	if (p->p_ucred != NULL) {
> 		db_printf(" uid: %d  gids: ", p->p_ucred->cr_uid);
> 		for (i = 0; i < p->p_ucred->cr_ngroups; i++) {
>Index: sys/fs/procfs/procfs_status.c
>===================================================================
>--- sys/fs/procfs/procfs_status.c	(revision 285633)
>+++ sys/fs/procfs/procfs_status.c	(working copy)
>@@ -125,9 +125,9 @@
> 	if (p->p_flag & P_INMEM) {
> 		struct timeval start, ut, st;
> 
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 		calcru(p, &ut, &st);
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> 		start = p->p_stats->p_start;
> 		timevaladd(&start, &boottime);
> 		sbuf_printf(sb, " %jd,%ld %jd,%ld %jd,%ld",
>Index: sys/fs/pseudofs/pseudofs.c
>===================================================================
>--- sys/fs/pseudofs/pseudofs.c	(revision 285633)
>+++ sys/fs/pseudofs/pseudofs.c	(working copy)
>@@ -52,9 +52,11 @@
> SYSCTL_NODE(_vfs, OID_AUTO, pfs, CTLFLAG_RW, 0,
>     "pseudofs");
> 
>+#ifdef PSEUDOFS_TRACE
> int pfs_trace;
> SYSCTL_INT(_vfs_pfs, OID_AUTO, trace, CTLFLAG_RW, &pfs_trace, 0,
>     "enable tracing of pseudofs vnode operations");
>+#endif
> 
> #if PFS_FSNAMELEN != MFSNAMELEN
> #error "PFS_FSNAMELEN is not equal to MFSNAMELEN"
>Index: sys/i386/i386/elf_machdep.c
>===================================================================
>--- sys/i386/i386/elf_machdep.c	(revision 285633)
>+++ sys/i386/i386/elf_machdep.c	(working copy)
>@@ -88,6 +88,7 @@
> 	.sv_shared_page_base = SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(elf32_sysvec, &elf32_freebsd_sysvec);
> 
>Index: sys/i386/i386/machdep.c
>===================================================================
>--- sys/i386/i386/machdep.c	(revision 285633)
>+++ sys/i386/i386/machdep.c	(working copy)
>@@ -400,10 +400,6 @@
> 	} else
> 		fp = (struct osigframe *)regs->tf_esp - 1;
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	sf.sf_signum = sig;
> 	sf.sf_scp = (register_t)&fp->sf_siginfo.si_sc;
>@@ -551,10 +547,6 @@
> 	} else
> 		sfp = (struct sigframe4 *)regs->tf_esp - 1;
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	sf.sf_signum = sig;
> 	sf.sf_ucontext = (register_t)&sfp->sf_uc;
>Index: sys/i386/ibcs2/ibcs2_sysvec.c
>===================================================================
>--- sys/i386/ibcs2/ibcs2_sysvec.c	(revision 285633)
>+++ sys/i386/ibcs2/ibcs2_sysvec.c	(working copy)
>@@ -89,6 +89,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = NULL,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> static int
>Index: sys/i386/linux/linux.h
>===================================================================
>--- sys/i386/linux/linux.h	(revision 285633)
>+++ sys/i386/linux/linux.h	(working copy)
>@@ -33,6 +33,7 @@
> 
> #include <sys/signal.h>	/* for sigval union */
> 
>+#include <compat/linux/linux.h>
> #include <i386/linux/linux_syscall.h>
> 
> /*
>@@ -40,14 +41,12 @@
>  */
> extern u_char linux_debug_map[];
> #define	ldebug(name)	isclr(linux_debug_map, LINUX_SYS_linux_ ## name)
>-#define	ARGS(nm, fmt)	"linux(%ld): "#nm"("fmt")\n", (long)td->td_proc->p_pid
>-#define	LMSG(fmt)	"linux(%ld): "fmt"\n", (long)td->td_proc->p_pid
>+#define	ARGS(nm, fmt)	"linux(%ld/%ld): "#nm"("fmt")\n",			\
>+			(long)td->td_proc->p_pid, (long)td->td_tid
>+#define	LMSG(fmt)	"linux(%ld/%ld): "fmt"\n",				\
>+			(long)td->td_proc->p_pid, (long)td->td_tid
> #define	LINUX_DTRACE	linuxulator
> 
>-#ifdef MALLOC_DECLARE
>-MALLOC_DECLARE(M_LINUX);
>-#endif
>-
> #define	LINUX_SHAREDPAGE	(VM_MAXUSER_ADDRESS - PAGE_SIZE)
> #define	LINUX_USRSTACK		LINUX_SHAREDPAGE
> 
>@@ -91,6 +90,7 @@
> typedef l_ushort	l_uid16_t;
> typedef l_int		l_timer_t;
> typedef l_int		l_mqd_t;
>+typedef	l_ulong		l_fd_mask;
> 
> typedef struct {
> 	l_int		val[2];
>@@ -106,7 +106,7 @@
> /*
>  * Miscellaneous
>  */
>-#define LINUX_AT_COUNT		16	/* Count of used aux entry types.
>+#define LINUX_AT_COUNT		20	/* Count of used aux entry types.
> 					 * Keep this synchronized with
> 					 * elf_linux_fixup() code.
> 					 */
>@@ -235,48 +235,7 @@
>         l_int           f_spare[6];
> };
> 
>-/*
>- * Signalling
>- */
>-#define	LINUX_SIGHUP		1
>-#define	LINUX_SIGINT		2
>-#define	LINUX_SIGQUIT		3
>-#define	LINUX_SIGILL		4
>-#define	LINUX_SIGTRAP		5
>-#define	LINUX_SIGABRT		6
>-#define	LINUX_SIGIOT		LINUX_SIGABRT
>-#define	LINUX_SIGBUS		7
>-#define	LINUX_SIGFPE		8
>-#define	LINUX_SIGKILL		9
>-#define	LINUX_SIGUSR1		10
>-#define	LINUX_SIGSEGV		11
>-#define	LINUX_SIGUSR2		12
>-#define	LINUX_SIGPIPE		13
>-#define	LINUX_SIGALRM		14
>-#define	LINUX_SIGTERM		15
>-#define	LINUX_SIGSTKFLT		16
>-#define	LINUX_SIGCHLD		17
>-#define	LINUX_SIGCONT		18
>-#define	LINUX_SIGSTOP		19
>-#define	LINUX_SIGTSTP		20
>-#define	LINUX_SIGTTIN		21
>-#define	LINUX_SIGTTOU		22
>-#define	LINUX_SIGURG		23
>-#define	LINUX_SIGXCPU		24
>-#define	LINUX_SIGXFSZ		25
>-#define	LINUX_SIGVTALRM		26
>-#define	LINUX_SIGPROF		27
>-#define	LINUX_SIGWINCH		28
>-#define	LINUX_SIGIO		29
>-#define	LINUX_SIGPOLL		LINUX_SIGIO
>-#define	LINUX_SIGPWR		30
>-#define	LINUX_SIGSYS		31
>-#define	LINUX_SIGRTMIN		32
>-
>-#define	LINUX_SIGTBLSZ		31
> #define	LINUX_NSIG_WORDS	2
>-#define	LINUX_NBPW		32
>-#define	LINUX_NSIG		(LINUX_NBPW * LINUX_NSIG_WORDS)
> 
> /* sigaction flags */
> #define	LINUX_SA_NOCLDSTOP	0x00000001
>@@ -294,27 +253,13 @@
> #define	LINUX_SIG_UNBLOCK	1
> #define	LINUX_SIG_SETMASK	2
> 
>-/* sigset_t macros */
>-#define	LINUX_SIGEMPTYSET(set)		(set).__bits[0] = (set).__bits[1] = 0
>-#define	LINUX_SIGISMEMBER(set, sig)	SIGISMEMBER(set, sig)
>-#define	LINUX_SIGADDSET(set, sig)	SIGADDSET(set, sig)
>-
> /* sigaltstack */
> #define	LINUX_MINSIGSTKSZ	2048
>-#define	LINUX_SS_ONSTACK	1
>-#define	LINUX_SS_DISABLE	2
> 
>-int linux_to_bsd_sigaltstack(int lsa);
>-int bsd_to_linux_sigaltstack(int bsa);
>-
> typedef void	(*l_handler_t)(l_int);
> typedef l_ulong	l_osigset_t;
> 
> typedef struct {
>-	l_uint	__bits[LINUX_NSIG_WORDS];
>-} l_sigset_t;
>-
>-typedef struct {
> 	l_handler_t	lsa_handler;
> 	l_osigset_t	lsa_mask;
> 	l_ulong		lsa_flags;
>@@ -497,50 +442,14 @@
> };
> 
> extern struct sysentvec linux_sysvec;
>-extern struct sysentvec elf_linux_sysvec;
> 
> /*
>- * open/fcntl flags
>+ * arch specific open/fcntl flags
>  */
>-#define	LINUX_O_RDONLY		00000000
>-#define	LINUX_O_WRONLY		00000001
>-#define	LINUX_O_RDWR		00000002
>-#define	LINUX_O_ACCMODE		00000003
>-#define	LINUX_O_CREAT		00000100
>-#define	LINUX_O_EXCL		00000200
>-#define	LINUX_O_NOCTTY		00000400
>-#define	LINUX_O_TRUNC		00001000
>-#define	LINUX_O_APPEND		00002000
>-#define	LINUX_O_NONBLOCK	00004000
>-#define	LINUX_O_NDELAY		LINUX_O_NONBLOCK
>-#define	LINUX_O_SYNC		00010000
>-#define	LINUX_FASYNC		00020000
>-#define	LINUX_O_DIRECT		00040000	/* Direct disk access hint */
>-#define	LINUX_O_LARGEFILE	00100000
>-#define	LINUX_O_DIRECTORY	00200000	/* Must be a directory */
>-#define	LINUX_O_NOFOLLOW	00400000	/* Do not follow links */
>-#define	LINUX_O_NOATIME		01000000
>-#define	LINUX_O_CLOEXEC		02000000
>-
>-#define	LINUX_F_DUPFD		0
>-#define	LINUX_F_GETFD		1
>-#define	LINUX_F_SETFD		2
>-#define	LINUX_F_GETFL		3
>-#define	LINUX_F_SETFL		4
>-#define	LINUX_F_GETLK		5
>-#define	LINUX_F_SETLK		6
>-#define	LINUX_F_SETLKW		7
>-#define	LINUX_F_SETOWN		8
>-#define	LINUX_F_GETOWN		9
>-
> #define	LINUX_F_GETLK64		12
> #define	LINUX_F_SETLK64		13
> #define	LINUX_F_SETLKW64	14
> 
>-#define	LINUX_F_RDLCK		0
>-#define	LINUX_F_WRLCK		1
>-#define	LINUX_F_UNLCK		2
>-
> union l_semun {
> 	l_int		val;
> 	struct l_semid_ds	*buf;
>@@ -549,6 +458,16 @@
> 	void		*__pad;
> };
> 
>+struct l_ipc_perm {
>+	l_key_t		key;
>+	l_uid16_t	uid;
>+	l_gid16_t	gid;
>+	l_uid16_t	cuid;
>+	l_gid16_t	cgid;
>+	l_ushort	mode;
>+	l_ushort	seq;
>+};
>+
> /*
>  * Socket defines
>  */
>@@ -585,22 +504,6 @@
> 	char		sa_data[14];
> };
> 
>-struct l_msghdr {
>-	l_uintptr_t	msg_name;
>-	l_int		msg_namelen;
>-	l_uintptr_t	msg_iov;
>-	l_size_t	msg_iovlen;
>-	l_uintptr_t	msg_control;
>-	l_size_t	msg_controllen;
>-	l_uint		msg_flags;
>-};
>-
>-struct l_cmsghdr {
>-	l_size_t	cmsg_len;
>-	l_int		cmsg_level;
>-	l_int		cmsg_type;
>-};
>-
> struct l_ifmap {
> 	l_ulong		mem_start;
> 	l_ulong		mem_end;
>Index: sys/i386/linux/linux_dummy.c
>===================================================================
>--- sys/i386/linux/linux_dummy.c	(revision 285633)
>+++ sys/i386/linux/linux_dummy.c	(working copy)
>@@ -65,7 +65,6 @@
> DUMMY(vm86);
> DUMMY(query_module);
> DUMMY(nfsservctl);
>-DUMMY(rt_sigqueueinfo);
> DUMMY(sendfile);		/* different semantics */
> DUMMY(setfsuid);
> DUMMY(setfsgid);
>@@ -72,9 +71,6 @@
> DUMMY(pivot_root);
> DUMMY(mincore);
> DUMMY(lookup_dcookie);
>-DUMMY(epoll_create);
>-DUMMY(epoll_ctl);
>-DUMMY(epoll_wait);
> DUMMY(remap_file_pages);
> DUMMY(fstatfs64);
> DUMMY(mbind);
>@@ -81,7 +77,6 @@
> DUMMY(get_mempolicy);
> DUMMY(set_mempolicy);
> DUMMY(kexec_load);
>-DUMMY(waitid);
> /* linux 2.6.11: */
> DUMMY(add_key);
> DUMMY(request_key);
>@@ -94,8 +89,6 @@
> DUMMY(inotify_rm_watch);
> /* linux 2.6.16: */
> DUMMY(migrate_pages);
>-DUMMY(pselect6);
>-DUMMY(ppoll);
> DUMMY(unshare);
> /* linux 2.6.17: */
> DUMMY(splice);
>@@ -106,22 +99,14 @@
> DUMMY(move_pages);
> /* linux 2.6.19: */
> DUMMY(getcpu);
>-DUMMY(epoll_pwait);
> /* linux 2.6.22: */
>-DUMMY(utimensat);
> DUMMY(signalfd);
> DUMMY(timerfd_create);
>-DUMMY(eventfd);
>-/* linux 2.6.23: */
>-DUMMY(fallocate);
> /* linux 2.6.25: */
> DUMMY(timerfd_settime);
> DUMMY(timerfd_gettime);
> /* linux 2.6.27: */
> DUMMY(signalfd4);
>-DUMMY(eventfd2);
>-DUMMY(epoll_create1);
>-DUMMY(dup3);
> DUMMY(inotify_init1);
> /* linux 2.6.30: */
> DUMMY(preadv);
>@@ -130,17 +115,12 @@
> DUMMY(rt_tsigqueueinfo);
> DUMMY(perf_event_open);
> /* linux 2.6.33: */
>-DUMMY(recvmmsg);
> DUMMY(fanotify_init);
> DUMMY(fanotify_mark);
>-/* linux 2.6.36: */
>-DUMMY(prlimit64);
> /* later: */
> DUMMY(name_to_handle_at);
> DUMMY(open_by_handle_at);
> DUMMY(clock_adjtime);
>-DUMMY(syncfs);
>-DUMMY(sendmmsg);
> DUMMY(setns);
> DUMMY(process_vm_readv);
> DUMMY(process_vm_writev);
>Index: sys/i386/linux/linux_genassym.c
>===================================================================
>--- sys/i386/linux/linux_genassym.c	(revision 285633)
>+++ sys/i386/linux/linux_genassym.c	(working copy)
>@@ -6,6 +6,7 @@
> #include <sys/systm.h>
> 
> #include <i386/linux/linux.h>
>+#include <compat/linux/linux_mib.h>
> 
> ASSYM(LINUX_SIGF_HANDLER, offsetof(struct l_sigframe, sf_handler));
> ASSYM(LINUX_SIGF_SC, offsetof(struct l_sigframe, sf_sc));
>@@ -14,3 +15,5 @@
> ASSYM(LINUX_RT_SIGF_HANDLER, offsetof(struct l_rt_sigframe, sf_handler));
> ASSYM(LINUX_RT_SIGF_UC, offsetof(struct l_rt_sigframe, sf_sc));
> ASSYM(LINUX_RT_SIGF_SC, offsetof(struct l_ucontext, uc_mcontext));
>+ASSYM(LINUX_SC_ESP, offsetof(struct l_sigcontext, sc_esp));
>+ASSYM(LINUX_VERSION_CODE, LINUX_VERSION_CODE);
>Index: sys/i386/linux/linux_locore.s
>===================================================================
>--- sys/i386/linux/linux_locore.s	(revision 285633)
>+++ sys/i386/linux/linux_locore.s	(working copy)
>@@ -5,33 +5,145 @@
> 
> #include <i386/linux/linux_syscall.h>		/* system call numbers */
> 
>+#include "assym.s"
>+
>+/*
>+ * To avoid excess stack frame the signal trampoline code emulates
>+ * the 'call' instruction.
>+ */
> NON_GPROF_ENTRY(linux_sigcode)
>-	call	*LINUX_SIGF_HANDLER(%esp)
>-	leal	LINUX_SIGF_SC(%esp),%ebx	/* linux scp */
>-	mov	LINUX_SC_GS(%ebx),%gs
>-	movl	%esp, %ebx			/* pass sigframe */
>-	push	%eax				/* fake ret addr */
>+	movl	%esp, %ebx			/* preserve sigframe */
>+	call .getip0
>+.getip0:
>+	popl	%eax
>+	add	$.startsigcode-.getip0, %eax	/* ret address */
>+	push	%eax
>+	jmp	*LINUX_SIGF_HANDLER(%ebx)
>+.startsigcode:
>+	popl	%eax				/* gcc unwind code need this */
> 	movl	$LINUX_SYS_linux_sigreturn,%eax	/* linux_sigreturn() */
> 	int	$0x80				/* enter kernel with args */
>+.endsigcode:
> 0:	jmp	0b
>-	ALIGN_TEXT
>-/* XXXXX */
>-linux_rt_sigcode:
>-	call	*LINUX_RT_SIGF_HANDLER(%esp)
>+
>+NON_GPROF_ENTRY(linux_rt_sigcode)
> 	leal	LINUX_RT_SIGF_UC(%esp),%ebx	/* linux ucp */
> 	leal	LINUX_RT_SIGF_SC(%ebx),%ecx	/* linux sigcontext */
>-	mov	LINUX_SC_GS(%ecx),%gs
>-	push	%eax				/* fake ret addr */
>+	movl	%esp, %edi
>+	call	.getip1
>+.getip1:
>+	popl	%eax
>+	add	$.startrtsigcode-.getip1, %eax	/* ret address */
>+	push	%eax
>+	jmp	*LINUX_RT_SIGF_HANDLER(%edi)
>+.startrtsigcode:
> 	movl	$LINUX_SYS_linux_rt_sigreturn,%eax   /* linux_rt_sigreturn() */
> 	int	$0x80				/* enter kernel with args */
>+.endrtsigcode:
> 0:	jmp	0b
>-	ALIGN_TEXT
>-/* XXXXX */
>-linux_esigcode:
> 
>-	.data
>-	.globl	linux_szsigcode, linux_sznonrtsigcode
>-linux_szsigcode:
>-	.long	linux_esigcode-linux_sigcode
>-linux_sznonrtsigcode:
>-	.long	linux_rt_sigcode-linux_sigcode
>+NON_GPROF_ENTRY(linux_vsyscall)
>+.startvsyscall:
>+	int $0x80
>+	ret
>+.endvsyscall:
>+
>+#if 0
>+	.section .note.Linux, "a",@note
>+	.long 2f - 1f		/* namesz */
>+	.balign 4
>+	.long 4f - 3f		/* descsz */
>+	.long 0
>+1:
>+	.asciz "Linux"
>+2:
>+	.balign 4
>+3:
>+	.long LINUX_VERSION_CODE
>+4:
>+	.balign 4
>+	.previous
>+#endif
>+
>+#define do_cfa_expr(offset)                                             \
>+	.byte 0x0f;			/* DW_CFA_def_cfa_expression */ \
>+	.uleb128 11f-10f;		/*   length */                  \
>+10:	.byte 0x74;			/*     DW_OP_breg4 */           \
>+	.sleb128 offset;		/*      offset */               \
>+	.byte 0x06;			/*     DW_OP_deref */           \
>+11:
>+
>+
>+	/* CIE */
>+	.section .eh_frame,"a",@progbits
>+.LSTARTFRAMEDLSI1:
>+	.long .LENDCIEDLSI1-.LSTARTCIEDLSI1
>+.LSTARTCIEDLSI1:
>+	.long 0					/* CIE ID */
>+	.byte 1					/* Version number */
>+	.string "zRS"				/* NULL-terminated
>+						 * augmentation string
>+						 */
>+	.uleb128 1				/* Code alignment factor */
>+	.sleb128 -4				/* Data alignment factor */
>+	.byte 8					/* Return address
>+						 * register column
>+						 */
>+	.uleb128 1				/* Augmentation value length */
>+	.byte 0x1b				/* DW_EH_PE_pcrel|DW_EH_PE_sdata4. */
>+	.byte 0					/* DW_CFA_nop */
>+	.align 4
>+.LENDCIEDLSI1:
>+
>+	/* FDE */
>+	.long .LENDFDEDLSI1-.LSTARTFDEDLSI1	/* Length FDE */
>+.LSTARTFDEDLSI1:
>+	.long .LSTARTFDEDLSI1-.LSTARTFRAMEDLSI1 /* CIE pointer */
>+	.long .startsigcode-.			/* PC-relative start address */
>+	.long .endsigcode-.startsigcode
>+	.uleb128 0				/* Augmentation */
>+	do_cfa_expr(LINUX_SIGF_SC-8)
>+	.align 4
>+.LENDFDEDLSI1:
>+
>+	.long .LENDFDEDLSI2-.LSTARTFDEDLSI2	/* Length FDE */
>+.LSTARTFDEDLSI2:
>+	.long .LSTARTFDEDLSI2-.LSTARTFRAMEDLSI1	/* CIE pointer */
>+	.long .startrtsigcode-.			/* PC-relative start address */
>+	.long .endrtsigcode-.startrtsigcode
>+	.uleb128 0				/* Augmentation */
>+	do_cfa_expr(LINUX_RT_SIGF_SC-4+LINUX_SC_ESP)
>+	.align 4
>+.LENDFDEDLSI2:
>+	.previous
>+
>+	.section .eh_frame,"a",@progbits
>+.LSTARTFRAMEDLSI2:
>+	.long .LENDCIEDLSI2-.LSTARTCIEDLSI2
>+.LSTARTCIEDLSI2:
>+	.long 0					/* CIE ID */
>+	.byte 1					/* Version number */
>+	.string "zR"				/* NULL-terminated
>+						 * augmentation string
>+						 */
>+	.uleb128 1				/* Code alignment factor */
>+	.sleb128 -4				/* Data alignment factor */
>+	.byte 8					/* Return address register column */
>+	.uleb128 1				/* Augmentation value length */
>+	.byte 0x1b				/* DW_EH_PE_pcrel|DW_EH_PE_sdata4. */
>+	.byte 0x0c				/* DW_CFA_def_cfa */
>+	.uleb128 4
>+	.uleb128 4
>+	.byte 0x88				/* DW_CFA_offset, column 0x8 */
>+	.uleb128 1
>+	.align 4
>+.LENDCIEDLSI2:
>+	.long .LENDFDEDLSI3-.LSTARTFDEDLSI3 /* Length FDE */
>+.LSTARTFDEDLSI3:
>+	.long .LSTARTFDEDLSI3-.LSTARTFRAMEDLSI2 /* CIE pointer */
>+	.long .startvsyscall-.			/* PC-relative start address */
>+	.long .endvsyscall-.startvsyscall
>+	.uleb128 0
>+	.align 4
>+.LENDFDEDLSI3:
>+	.previous
>Index: sys/i386/linux/linux_machdep.c
>===================================================================
>--- sys/i386/linux/linux_machdep.c	(revision 285633)
>+++ sys/i386/linux/linux_machdep.c	(working copy)
>@@ -99,35 +99,11 @@
> 		    l_size_t len, l_int prot, l_int flags, l_int fd,
> 		    l_loff_t pos);
> 
>-int
>-linux_to_bsd_sigaltstack(int lsa)
>-{
>-	int bsa = 0;
> 
>-	if (lsa & LINUX_SS_DISABLE)
>-		bsa |= SS_DISABLE;
>-	if (lsa & LINUX_SS_ONSTACK)
>-		bsa |= SS_ONSTACK;
>-	return (bsa);
>-}
>-
> int
>-bsd_to_linux_sigaltstack(int bsa)
>-{
>-	int lsa = 0;
>-
>-	if (bsa & SS_DISABLE)
>-		lsa |= LINUX_SS_DISABLE;
>-	if (bsa & SS_ONSTACK)
>-		lsa |= LINUX_SS_ONSTACK;
>-	return (lsa);
>-}
>-
>-int
> linux_execve(struct thread *td, struct linux_execve_args *args)
> {
> 	struct image_args eargs;
>-	struct vmspace *oldvmspace;
> 	char *newpath;
> 	int error;
> 
>@@ -138,26 +114,11 @@
> 		printf(ARGS(execve, "%s"), newpath);
> #endif
> 
>-	error = pre_execve(td, &oldvmspace);
>-	if (error != 0) {
>-		free(newpath, M_TEMP);
>-		return (error);
>-	}
> 	error = exec_copyin_args(&eargs, newpath, UIO_SYSSPACE,
> 	    args->argp, args->envp);
> 	free(newpath, M_TEMP);
> 	if (error == 0)
>-		error = kern_execve(td, &eargs, NULL);
>-	if (error == 0) {
>-	   	/* linux process can exec fbsd one, dont attempt
>-		 * to create emuldata for such process using
>-		 * linux_proc_init, this leads to a panic on KASSERT
>-		 * because such process has p->p_emuldata == NULL
>-		 */
>-		if (SV_PROC_ABI(td->td_proc) == SV_ABI_LINUX)
>-   			error = linux_proc_init(td, 0, 0);
>-	}
>-	post_execve(td, error, oldvmspace);
>+		error = linux_common_execve(td, &eargs);
> 	return (error);
> }
> 
>@@ -368,8 +329,14 @@
> linux_set_upcall_kse(struct thread *td, register_t stack)
> {
> 
>-	td->td_frame->tf_esp = stack;
>+	if (stack)
>+		td->td_frame->tf_esp = stack;
> 
>+	/*
>+	 * The newly created Linux thread returns
>+	 * to the user space by the same path that a parent do.
>+	 */
>+	td->td_frame->tf_eax = 0;
> 	return (0);
> }
> 
>@@ -710,7 +677,7 @@
> 		act.lsa_flags = osa.lsa_flags;
> 		act.lsa_restorer = osa.lsa_restorer;
> 		LINUX_SIGEMPTYSET(act.lsa_mask);
>-		act.lsa_mask.__bits[0] = osa.lsa_mask;
>+		act.lsa_mask.__mask = osa.lsa_mask;
> 	}
> 
> 	error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL,
>@@ -720,7 +687,7 @@
> 		osa.lsa_handler = oact.lsa_handler;
> 		osa.lsa_flags = oact.lsa_flags;
> 		osa.lsa_restorer = oact.lsa_restorer;
>-		osa.lsa_mask = oact.lsa_mask.__bits[0];
>+		osa.lsa_mask = oact.lsa_mask.__mask;
> 		error = copyout(&osa, args->osa, sizeof(l_osigaction_t));
> 	}
> 
>@@ -744,7 +711,7 @@
> #endif
> 
> 	LINUX_SIGEMPTYSET(mask);
>-	mask.__bits[0] = args->mask;
>+	mask.__mask = args->mask;
> 	linux_to_bsd_sigset(&mask, &sigmask);
> 	return (kern_sigsuspend(td, sigmask));
> }
>@@ -1061,11 +1028,12 @@
> 		    args->pid, (void *)args->status, args->options,
> 		    (void *)args->rusage);
> #endif
>+	if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |
>+	    LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))
>+		return (EINVAL);
> 
>-	options = (args->options & (WNOHANG | WUNTRACED));
>-	/* WLINUXCLONE should be equal to __WCLONE, but we make sure */
>-	if (args->options & __WCLONE)
>-		options |= WLINUXCLONE;
>+	options = WEXITED;
>+	linux_to_bsd_waitopts(args->options, &options);
> 
> 	if (args->rusage != NULL)
> 		rup = &ru;
>@@ -1079,3 +1047,65 @@
> 
> 	return (error);
> }
>+
>+int
>+linux_waitid(struct thread *td, struct linux_waitid_args *args)
>+{
>+	int status, options, sig;
>+	struct __wrusage wru;
>+	siginfo_t siginfo;
>+	l_siginfo_t lsi;
>+	idtype_t idtype;
>+	struct proc *p;
>+	int error;
>+
>+	options = 0;
>+	linux_to_bsd_waitopts(args->options, &options);
>+
>+	if (options & ~(WNOHANG | WNOWAIT | WEXITED | WUNTRACED | WCONTINUED))
>+		return (EINVAL);
>+	if (!(options & (WEXITED | WUNTRACED | WCONTINUED)))
>+		return (EINVAL);
>+
>+	switch (args->idtype) {
>+	case LINUX_P_ALL:
>+		idtype = P_ALL;
>+		break;
>+	case LINUX_P_PID:
>+		if (args->id <= 0)
>+			return (EINVAL);
>+		idtype = P_PID;
>+		break;
>+	case LINUX_P_PGID:
>+		if (args->id <= 0)
>+			return (EINVAL);
>+		idtype = P_PGID;
>+		break;
>+	default:
>+		return (EINVAL);
>+	}
>+
>+	error = kern_wait6(td, idtype, args->id, &status, options,
>+	    &wru, &siginfo);
>+	if (error)
>+		return (error);
>+	if (args->rusage != NULL) {
>+		error = copyout(&wru.wru_children, args->rusage,
>+		    sizeof(wru.wru_children));
>+		if (error)
>+			return (error);
>+	}
>+	if (args->info != NULL) {
>+		p = td->td_proc;
>+		if (td->td_retval[0] == 0)
>+			bzero(&lsi, sizeof(lsi));
>+		else {
>+			sig = bsd_to_linux_signal(siginfo.si_signo);
>+			siginfo_to_lsiginfo(&siginfo, &lsi, sig);
>+		}
>+		error = copyout(&lsi, args->info, sizeof(lsi));
>+	}
>+	td->td_retval[0] = 0;
>+
>+	return (error);
>+}
>Index: sys/i386/linux/linux_proto.h
>===================================================================
>--- sys/i386/linux/linux_proto.h	(revision 285633)
>+++ sys/i386/linux/linux_proto.h	(working copy)
>@@ -35,6 +35,9 @@
> #endif
> 
> #define	nosys	linux_nosys
>+struct linux_exit_args {
>+	char rval_l_[PADL_(int)]; int rval; char rval_r_[PADR_(int)];
>+};
> struct linux_fork_args {
> 	register_t dummy;
> };
>@@ -473,6 +476,14 @@
> struct linux_sysctl_args {
> 	char args_l_[PADL_(struct l___sysctl_args *)]; struct l___sysctl_args * args; char args_r_[PADR_(struct l___sysctl_args *)];
> };
>+struct linux_sched_setparam_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
>+struct linux_sched_getparam_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)];
>+};
> struct linux_sched_setscheduler_args {
> 	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
> 	char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)];
>@@ -487,6 +498,10 @@
> struct linux_sched_get_priority_min_args {
> 	char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)];
> };
>+struct linux_sched_rr_get_interval_args {
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char interval_l_[PADL_(struct l_timespec *)]; struct l_timespec * interval; char interval_r_[PADR_(struct l_timespec *)];
>+};
> struct linux_nanosleep_args {
> 	char rqtp_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * rqtp; char rqtp_r_[PADR_(const struct l_timespec *)];
> 	char rmtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rmtp; char rmtp_r_[PADR_(struct l_timespec *)];
>@@ -560,7 +575,9 @@
> 	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];
> };
> struct linux_rt_sigqueueinfo_args {
>-	register_t dummy;
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)];
>+	char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)];
> };
> struct linux_rt_sigsuspend_args {
> 	char newset_l_[PADL_(l_sigset_t *)]; l_sigset_t * newset; char newset_r_[PADR_(l_sigset_t *)];
>@@ -766,13 +783,19 @@
> 	register_t dummy;
> };
> struct linux_epoll_create_args {
>-	register_t dummy;
>+	char size_l_[PADL_(l_int)]; l_int size; char size_r_[PADR_(l_int)];
> };
> struct linux_epoll_ctl_args {
>-	register_t dummy;
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char op_l_[PADL_(l_int)]; l_int op; char op_r_[PADR_(l_int)];
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char event_l_[PADL_(struct epoll_event *)]; struct epoll_event * event; char event_r_[PADR_(struct epoll_event *)];
> };
> struct linux_epoll_wait_args {
>-	register_t dummy;
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)];
>+	char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)];
>+	char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)];
> };
> struct linux_remap_file_pages_args {
> 	register_t dummy;
>@@ -887,7 +910,11 @@
> 	register_t dummy;
> };
> struct linux_waitid_args {
>-	register_t dummy;
>+	char idtype_l_[PADL_(int)]; int idtype; char idtype_r_[PADR_(int)];
>+	char id_l_[PADL_(l_pid_t)]; l_pid_t id; char id_r_[PADR_(l_pid_t)];
>+	char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)];
>+	char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)];
>+	char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)];
> };
> struct linux_add_key_args {
> 	register_t dummy;
>@@ -989,13 +1016,21 @@
> 	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
> 	char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)];
> 	char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)];
>-	char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)];
> };
> struct linux_pselect6_args {
>-	register_t dummy;
>+	char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)];
>+	char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)];
>+	char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)];
>+	char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)];
>+	char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)];
>+	char sig_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * sig; char sig_r_[PADR_(l_uintptr_t *)];
> };
> struct linux_ppoll_args {
>-	register_t dummy;
>+	char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)];
>+	char nfds_l_[PADL_(uint32_t)]; uint32_t nfds; char nfds_r_[PADR_(uint32_t)];
>+	char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)];
>+	char sset_l_[PADL_(l_sigset_t *)]; l_sigset_t * sset; char sset_r_[PADR_(l_sigset_t *)];
>+	char ssize_l_[PADL_(l_size_t)]; l_size_t ssize; char ssize_r_[PADR_(l_size_t)];
> };
> struct linux_unshare_args {
> 	register_t dummy;
>@@ -1028,10 +1063,17 @@
> 	register_t dummy;
> };
> struct linux_epoll_pwait_args {
>-	register_t dummy;
>+	char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)];
>+	char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)];
>+	char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)];
>+	char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)];
>+	char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)];
> };
> struct linux_utimensat_args {
>-	register_t dummy;
>+	char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)];
>+	char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)];
>+	char times_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * times; char times_r_[PADR_(const struct l_timespec *)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_signalfd_args {
> 	register_t dummy;
>@@ -1040,10 +1082,13 @@
> 	register_t dummy;
> };
> struct linux_eventfd_args {
>-	register_t dummy;
>+	char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)];
> };
> struct linux_fallocate_args {
>-	register_t dummy;
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
>+	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];
>+	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];
>+	char len_l_[PADL_(l_loff_t)]; l_loff_t len; char len_r_[PADR_(l_loff_t)];
> };
> struct linux_timerfd_settime_args {
> 	register_t dummy;
>@@ -1055,13 +1100,16 @@
> 	register_t dummy;
> };
> struct linux_eventfd2_args {
>-	register_t dummy;
>+	char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_epoll_create1_args {
>-	register_t dummy;
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_dup3_args {
>-	register_t dummy;
>+	char oldfd_l_[PADL_(l_int)]; l_int oldfd; char oldfd_r_[PADR_(l_int)];
>+	char newfd_l_[PADL_(l_int)]; l_int newfd; char newfd_r_[PADR_(l_int)];
>+	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];
> };
> struct linux_pipe2_args {
> 	char pipefds_l_[PADL_(l_int *)]; l_int * pipefds; char pipefds_r_[PADR_(l_int *)];
>@@ -1083,7 +1131,11 @@
> 	register_t dummy;
> };
> struct linux_recvmmsg_args {
>-	register_t dummy;
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)];
>+	char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)];
>+	char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)];
> };
> struct linux_fanotify_init_args {
> 	register_t dummy;
>@@ -1092,7 +1144,10 @@
> 	register_t dummy;
> };
> struct linux_prlimit64_args {
>-	register_t dummy;
>+	char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)];
>+	char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)];
>+	char new_l_[PADL_(struct rlimit *)]; struct rlimit * new; char new_r_[PADR_(struct rlimit *)];
>+	char old_l_[PADL_(struct rlimit *)]; struct rlimit * old; char old_r_[PADR_(struct rlimit *)];
> };
> struct linux_name_to_handle_at_args {
> 	register_t dummy;
>@@ -1104,10 +1159,13 @@
> 	register_t dummy;
> };
> struct linux_syncfs_args {
>-	register_t dummy;
>+	char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)];
> };
> struct linux_sendmmsg_args {
>-	register_t dummy;
>+	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];
>+	char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)];
>+	char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)];
>+	char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)];
> };
> struct linux_setns_args {
> 	register_t dummy;
>@@ -1119,6 +1177,7 @@
> 	register_t dummy;
> };
> #define	nosys	linux_nosys
>+int	linux_exit(struct thread *, struct linux_exit_args *);
> int	linux_fork(struct thread *, struct linux_fork_args *);
> int	linux_open(struct thread *, struct linux_open_args *);
> int	linux_waitpid(struct thread *, struct linux_waitpid_args *);
>@@ -1230,10 +1289,13 @@
> int	linux_getsid(struct thread *, struct linux_getsid_args *);
> int	linux_fdatasync(struct thread *, struct linux_fdatasync_args *);
> int	linux_sysctl(struct thread *, struct linux_sysctl_args *);
>+int	linux_sched_setparam(struct thread *, struct linux_sched_setparam_args *);
>+int	linux_sched_getparam(struct thread *, struct linux_sched_getparam_args *);
> int	linux_sched_setscheduler(struct thread *, struct linux_sched_setscheduler_args *);
> int	linux_sched_getscheduler(struct thread *, struct linux_sched_getscheduler_args *);
> int	linux_sched_get_priority_max(struct thread *, struct linux_sched_get_priority_max_args *);
> int	linux_sched_get_priority_min(struct thread *, struct linux_sched_get_priority_min_args *);
>+int	linux_sched_rr_get_interval(struct thread *, struct linux_sched_rr_get_interval_args *);
> int	linux_nanosleep(struct thread *, struct linux_nanosleep_args *);
> int	linux_mremap(struct thread *, struct linux_mremap_args *);
> int	linux_setresuid16(struct thread *, struct linux_setresuid16_args *);
>@@ -1422,6 +1484,7 @@
> 
> #endif /* COMPAT_FREEBSD7 */
> 
>+#define	LINUX_SYS_AUE_linux_exit	AUE_EXIT
> #define	LINUX_SYS_AUE_linux_fork	AUE_FORK
> #define	LINUX_SYS_AUE_linux_open	AUE_OPEN_RWTC
> #define	LINUX_SYS_AUE_linux_waitpid	AUE_WAIT4
>@@ -1533,10 +1596,13 @@
> #define	LINUX_SYS_AUE_linux_getsid	AUE_GETSID
> #define	LINUX_SYS_AUE_linux_fdatasync	AUE_NULL
> #define	LINUX_SYS_AUE_linux_sysctl	AUE_SYSCTL
>+#define	LINUX_SYS_AUE_linux_sched_setparam	AUE_SCHED_SETPARAM
>+#define	LINUX_SYS_AUE_linux_sched_getparam	AUE_SCHED_GETPARAM
> #define	LINUX_SYS_AUE_linux_sched_setscheduler	AUE_SCHED_SETSCHEDULER
> #define	LINUX_SYS_AUE_linux_sched_getscheduler	AUE_SCHED_GETSCHEDULER
> #define	LINUX_SYS_AUE_linux_sched_get_priority_max	AUE_SCHED_GET_PRIORITY_MAX
> #define	LINUX_SYS_AUE_linux_sched_get_priority_min	AUE_SCHED_GET_PRIORITY_MIN
>+#define	LINUX_SYS_AUE_linux_sched_rr_get_interval	AUE_SCHED_RR_GET_INTERVAL
> #define	LINUX_SYS_AUE_linux_nanosleep	AUE_NULL
> #define	LINUX_SYS_AUE_linux_mremap	AUE_NULL
> #define	LINUX_SYS_AUE_linux_setresuid16	AUE_SETRESUID
>@@ -1633,7 +1699,7 @@
> #define	LINUX_SYS_AUE_linux_mq_notify	AUE_NULL
> #define	LINUX_SYS_AUE_linux_mq_getsetattr	AUE_NULL
> #define	LINUX_SYS_AUE_linux_kexec_load	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_waitid	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_waitid	AUE_WAIT6
> #define	LINUX_SYS_AUE_linux_add_key	AUE_NULL
> #define	LINUX_SYS_AUE_linux_request_key	AUE_NULL
> #define	LINUX_SYS_AUE_linux_keyctl	AUE_NULL
>@@ -1656,8 +1722,8 @@
> #define	LINUX_SYS_AUE_linux_readlinkat	AUE_READLINKAT
> #define	LINUX_SYS_AUE_linux_fchmodat	AUE_FCHMODAT
> #define	LINUX_SYS_AUE_linux_faccessat	AUE_FACCESSAT
>-#define	LINUX_SYS_AUE_linux_pselect6	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_ppoll	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_pselect6	AUE_SELECT
>+#define	LINUX_SYS_AUE_linux_ppoll	AUE_POLL
> #define	LINUX_SYS_AUE_linux_unshare	AUE_NULL
> #define	LINUX_SYS_AUE_linux_set_robust_list	AUE_NULL
> #define	LINUX_SYS_AUE_linux_get_robust_list	AUE_NULL
>@@ -1668,7 +1734,7 @@
> #define	LINUX_SYS_AUE_linux_move_pages	AUE_NULL
> #define	LINUX_SYS_AUE_linux_getcpu	AUE_NULL
> #define	LINUX_SYS_AUE_linux_epoll_pwait	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_utimensat	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_utimensat	AUE_FUTIMESAT
> #define	LINUX_SYS_AUE_linux_signalfd	AUE_NULL
> #define	LINUX_SYS_AUE_linux_timerfd_create	AUE_NULL
> #define	LINUX_SYS_AUE_linux_eventfd	AUE_NULL
>@@ -1692,7 +1758,7 @@
> #define	LINUX_SYS_AUE_linux_name_to_handle_at	AUE_NULL
> #define	LINUX_SYS_AUE_linux_open_by_handle_at	AUE_NULL
> #define	LINUX_SYS_AUE_linux_clock_adjtime	AUE_NULL
>-#define	LINUX_SYS_AUE_linux_syncfs	AUE_NULL
>+#define	LINUX_SYS_AUE_linux_syncfs	AUE_SYNC
> #define	LINUX_SYS_AUE_linux_sendmmsg	AUE_NULL
> #define	LINUX_SYS_AUE_linux_setns	AUE_NULL
> #define	LINUX_SYS_AUE_linux_process_vm_readv	AUE_NULL
>Index: sys/i386/linux/linux_ptrace.c
>===================================================================
>--- sys/i386/linux/linux_ptrace.c	(revision 285633)
>+++ sys/i386/linux/linux_ptrace.c	(working copy)
>@@ -91,8 +91,7 @@
> map_signum(int signum)
> {
> 
>-	if (signum > 0 && signum <= LINUX_SIGTBLSZ)
>-		signum = linux_to_bsd_signal[_SIG_IDX(signum)];
>+	signum = linux_to_bsd_signal(signum);
> 	return ((signum == SIGSTOP)? 0 : signum);
> }
> 
>Index: sys/i386/linux/linux_syscall.h
>===================================================================
>--- sys/i386/linux/linux_syscall.h	(revision 285633)
>+++ sys/i386/linux/linux_syscall.h	(working copy)
>@@ -6,7 +6,7 @@
>  * created from FreeBSD: stable/10/sys/i386/linux/syscalls.master 276810 2015-01-08 06:23:11Z dchagin 
>  */
> 
>-#define	LINUX_SYS_exit	1
>+#define	LINUX_SYS_linux_exit	1
> #define	LINUX_SYS_linux_fork	2
> #define	LINUX_SYS_read	3
> #define	LINUX_SYS_write	4
>@@ -148,14 +148,14 @@
> #define	LINUX_SYS_munlock	151
> #define	LINUX_SYS_mlockall	152
> #define	LINUX_SYS_munlockall	153
>-#define	LINUX_SYS_sched_setparam	154
>-#define	LINUX_SYS_sched_getparam	155
>+#define	LINUX_SYS_linux_sched_setparam	154
>+#define	LINUX_SYS_linux_sched_getparam	155
> #define	LINUX_SYS_linux_sched_setscheduler	156
> #define	LINUX_SYS_linux_sched_getscheduler	157
> #define	LINUX_SYS_sched_yield	158
> #define	LINUX_SYS_linux_sched_get_priority_max	159
> #define	LINUX_SYS_linux_sched_get_priority_min	160
>-#define	LINUX_SYS_sched_rr_get_interval	161
>+#define	LINUX_SYS_linux_sched_rr_get_interval	161
> #define	LINUX_SYS_linux_nanosleep	162
> #define	LINUX_SYS_linux_mremap	163
> #define	LINUX_SYS_linux_setresuid16	164
>@@ -328,4 +328,4 @@
> #define	LINUX_SYS_linux_setns	346
> #define	LINUX_SYS_linux_process_vm_readv	347
> #define	LINUX_SYS_linux_process_vm_writev	348
>-#define	LINUX_SYS_MAXSYSCALL	349
>+#define	LINUX_SYS_MAXSYSCALL	350
>Index: sys/i386/linux/linux_syscalls.c
>===================================================================
>--- sys/i386/linux/linux_syscalls.c	(revision 285633)
>+++ sys/i386/linux/linux_syscalls.c	(working copy)
>@@ -9,7 +9,7 @@
> const char *linux_syscallnames[] = {
> #define	nosys	linux_nosys
> 	"#0",			/* 0 = setup */
>-	"exit",			/* 1 = exit */
>+	"linux_exit",			/* 1 = exit */
> 	"linux_fork",			/* 2 = linux_fork */
> 	"read",			/* 3 = read */
> 	"write",			/* 4 = write */
>@@ -162,14 +162,14 @@
> 	"munlock",			/* 151 = munlock */
> 	"mlockall",			/* 152 = mlockall */
> 	"munlockall",			/* 153 = munlockall */
>-	"sched_setparam",			/* 154 = sched_setparam */
>-	"sched_getparam",			/* 155 = sched_getparam */
>+	"linux_sched_setparam",			/* 154 = linux_sched_setparam */
>+	"linux_sched_getparam",			/* 155 = linux_sched_getparam */
> 	"linux_sched_setscheduler",			/* 156 = linux_sched_setscheduler */
> 	"linux_sched_getscheduler",			/* 157 = linux_sched_getscheduler */
> 	"sched_yield",			/* 158 = sched_yield */
> 	"linux_sched_get_priority_max",			/* 159 = linux_sched_get_priority_max */
> 	"linux_sched_get_priority_min",			/* 160 = linux_sched_get_priority_min */
>-	"sched_rr_get_interval",			/* 161 = sched_rr_get_interval */
>+	"linux_sched_rr_get_interval",			/* 161 = linux_sched_rr_get_interval */
> 	"linux_nanosleep",			/* 162 = linux_nanosleep */
> 	"linux_mremap",			/* 163 = linux_mremap */
> 	"linux_setresuid16",			/* 164 = linux_setresuid16 */
>@@ -357,4 +357,5 @@
> 	"linux_setns",			/* 346 = linux_setns */
> 	"linux_process_vm_readv",			/* 347 = linux_process_vm_readv */
> 	"linux_process_vm_writev",			/* 348 = linux_process_vm_writev */
>+	"#349",			/* 349 = nosys */
> };
>Index: sys/i386/linux/linux_sysent.c
>===================================================================
>--- sys/i386/linux/linux_sysent.c	(revision 285633)
>+++ sys/i386/linux/linux_sysent.c	(working copy)
>@@ -19,7 +19,7 @@
> struct sysent linux_sysent[] = {
> #define	nosys	linux_nosys
> 	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 0 = setup */
>-	{ AS(sys_exit_args), (sy_call_t *)sys_sys_exit, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 1 = exit */
>+	{ AS(linux_exit_args), (sy_call_t *)linux_exit, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 1 = linux_exit */
> 	{ 0, (sy_call_t *)linux_fork, AUE_FORK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 2 = linux_fork */
> 	{ AS(read_args), (sy_call_t *)sys_read, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 3 = read */
> 	{ AS(write_args), (sy_call_t *)sys_write, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 4 = write */
>@@ -172,14 +172,14 @@
> 	{ AS(munlock_args), (sy_call_t *)sys_munlock, AUE_MUNLOCK, NULL, 0, 0, 0, SY_THR_STATIC },	/* 151 = munlock */
> 	{ AS(mlockall_args), (sy_call_t *)sys_mlockall, AUE_MLOCKALL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 152 = mlockall */
> 	{ 0, (sy_call_t *)sys_munlockall, AUE_MUNLOCKALL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 153 = munlockall */
>-	{ AS(sched_setparam_args), (sy_call_t *)sys_sched_setparam, AUE_SCHED_SETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 154 = sched_setparam */
>-	{ AS(sched_getparam_args), (sy_call_t *)sys_sched_getparam, AUE_SCHED_GETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 155 = sched_getparam */
>+	{ AS(linux_sched_setparam_args), (sy_call_t *)linux_sched_setparam, AUE_SCHED_SETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 154 = linux_sched_setparam */
>+	{ AS(linux_sched_getparam_args), (sy_call_t *)linux_sched_getparam, AUE_SCHED_GETPARAM, NULL, 0, 0, 0, SY_THR_STATIC },	/* 155 = linux_sched_getparam */
> 	{ AS(linux_sched_setscheduler_args), (sy_call_t *)linux_sched_setscheduler, AUE_SCHED_SETSCHEDULER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 156 = linux_sched_setscheduler */
> 	{ AS(linux_sched_getscheduler_args), (sy_call_t *)linux_sched_getscheduler, AUE_SCHED_GETSCHEDULER, NULL, 0, 0, 0, SY_THR_STATIC },	/* 157 = linux_sched_getscheduler */
> 	{ 0, (sy_call_t *)sys_sched_yield, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 158 = sched_yield */
> 	{ AS(linux_sched_get_priority_max_args), (sy_call_t *)linux_sched_get_priority_max, AUE_SCHED_GET_PRIORITY_MAX, NULL, 0, 0, 0, SY_THR_STATIC },	/* 159 = linux_sched_get_priority_max */
> 	{ AS(linux_sched_get_priority_min_args), (sy_call_t *)linux_sched_get_priority_min, AUE_SCHED_GET_PRIORITY_MIN, NULL, 0, 0, 0, SY_THR_STATIC },	/* 160 = linux_sched_get_priority_min */
>-	{ AS(sched_rr_get_interval_args), (sy_call_t *)sys_sched_rr_get_interval, AUE_SCHED_RR_GET_INTERVAL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 161 = sched_rr_get_interval */
>+	{ AS(linux_sched_rr_get_interval_args), (sy_call_t *)linux_sched_rr_get_interval, AUE_SCHED_RR_GET_INTERVAL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 161 = linux_sched_rr_get_interval */
> 	{ AS(linux_nanosleep_args), (sy_call_t *)linux_nanosleep, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 162 = linux_nanosleep */
> 	{ AS(linux_mremap_args), (sy_call_t *)linux_mremap, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 163 = linux_mremap */
> 	{ AS(linux_setresuid16_args), (sy_call_t *)linux_setresuid16, AUE_SETRESUID, NULL, 0, 0, 0, SY_THR_STATIC },	/* 164 = linux_setresuid16 */
>@@ -196,7 +196,7 @@
> 	{ AS(linux_rt_sigprocmask_args), (sy_call_t *)linux_rt_sigprocmask, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 175 = linux_rt_sigprocmask */
> 	{ AS(linux_rt_sigpending_args), (sy_call_t *)linux_rt_sigpending, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 176 = linux_rt_sigpending */
> 	{ AS(linux_rt_sigtimedwait_args), (sy_call_t *)linux_rt_sigtimedwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 177 = linux_rt_sigtimedwait */
>-	{ 0, (sy_call_t *)linux_rt_sigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 178 = linux_rt_sigqueueinfo */
>+	{ AS(linux_rt_sigqueueinfo_args), (sy_call_t *)linux_rt_sigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 178 = linux_rt_sigqueueinfo */
> 	{ AS(linux_rt_sigsuspend_args), (sy_call_t *)linux_rt_sigsuspend, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 179 = linux_rt_sigsuspend */
> 	{ AS(linux_pread_args), (sy_call_t *)linux_pread, AUE_PREAD, NULL, 0, 0, 0, SY_THR_STATIC },	/* 180 = linux_pread */
> 	{ AS(linux_pwrite_args), (sy_call_t *)linux_pwrite, AUE_PWRITE, NULL, 0, 0, 0, SY_THR_STATIC },	/* 181 = linux_pwrite */
>@@ -272,9 +272,9 @@
> 	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 251 =  */
> 	{ AS(linux_exit_group_args), (sy_call_t *)linux_exit_group, AUE_EXIT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 252 = linux_exit_group */
> 	{ 0, (sy_call_t *)linux_lookup_dcookie, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 253 = linux_lookup_dcookie */
>-	{ 0, (sy_call_t *)linux_epoll_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 254 = linux_epoll_create */
>-	{ 0, (sy_call_t *)linux_epoll_ctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 255 = linux_epoll_ctl */
>-	{ 0, (sy_call_t *)linux_epoll_wait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 256 = linux_epoll_wait */
>+	{ AS(linux_epoll_create_args), (sy_call_t *)linux_epoll_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 254 = linux_epoll_create */
>+	{ AS(linux_epoll_ctl_args), (sy_call_t *)linux_epoll_ctl, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 255 = linux_epoll_ctl */
>+	{ AS(linux_epoll_wait_args), (sy_call_t *)linux_epoll_wait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 256 = linux_epoll_wait */
> 	{ 0, (sy_call_t *)linux_remap_file_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 257 = linux_remap_file_pages */
> 	{ AS(linux_set_tid_address_args), (sy_call_t *)linux_set_tid_address, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 258 = linux_set_tid_address */
> 	{ AS(linux_timer_create_args), (sy_call_t *)linux_timer_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 259 = linux_timer_create */
>@@ -302,7 +302,7 @@
> 	{ AS(linux_mq_notify_args), (sy_call_t *)linux_mq_notify, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 281 = linux_mq_notify */
> 	{ AS(linux_mq_getsetattr_args), (sy_call_t *)linux_mq_getsetattr, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 282 = linux_mq_getsetattr */
> 	{ 0, (sy_call_t *)linux_kexec_load, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 283 = linux_kexec_load */
>-	{ 0, (sy_call_t *)linux_waitid, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 284 = linux_waitid */
>+	{ AS(linux_waitid_args), (sy_call_t *)linux_waitid, AUE_WAIT6, NULL, 0, 0, 0, SY_THR_STATIC },	/* 284 = linux_waitid */
> 	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 285 =  */
> 	{ 0, (sy_call_t *)linux_add_key, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 286 = linux_add_key */
> 	{ 0, (sy_call_t *)linux_request_key, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 287 = linux_request_key */
>@@ -326,8 +326,8 @@
> 	{ AS(linux_readlinkat_args), (sy_call_t *)linux_readlinkat, AUE_READLINKAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 305 = linux_readlinkat */
> 	{ AS(linux_fchmodat_args), (sy_call_t *)linux_fchmodat, AUE_FCHMODAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 306 = linux_fchmodat */
> 	{ AS(linux_faccessat_args), (sy_call_t *)linux_faccessat, AUE_FACCESSAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 307 = linux_faccessat */
>-	{ 0, (sy_call_t *)linux_pselect6, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 308 = linux_pselect6 */
>-	{ 0, (sy_call_t *)linux_ppoll, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 309 = linux_ppoll */
>+	{ AS(linux_pselect6_args), (sy_call_t *)linux_pselect6, AUE_SELECT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 308 = linux_pselect6 */
>+	{ AS(linux_ppoll_args), (sy_call_t *)linux_ppoll, AUE_POLL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 309 = linux_ppoll */
> 	{ 0, (sy_call_t *)linux_unshare, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 310 = linux_unshare */
> 	{ AS(linux_set_robust_list_args), (sy_call_t *)linux_set_robust_list, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 311 = linux_set_robust_list */
> 	{ AS(linux_get_robust_list_args), (sy_call_t *)linux_get_robust_list, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 312 = linux_get_robust_list */
>@@ -337,18 +337,18 @@
> 	{ 0, (sy_call_t *)linux_vmsplice, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 316 = linux_vmsplice */
> 	{ 0, (sy_call_t *)linux_move_pages, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 317 = linux_move_pages */
> 	{ 0, (sy_call_t *)linux_getcpu, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 318 = linux_getcpu */
>-	{ 0, (sy_call_t *)linux_epoll_pwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 319 = linux_epoll_pwait */
>-	{ 0, (sy_call_t *)linux_utimensat, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 320 = linux_utimensat */
>+	{ AS(linux_epoll_pwait_args), (sy_call_t *)linux_epoll_pwait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 319 = linux_epoll_pwait */
>+	{ AS(linux_utimensat_args), (sy_call_t *)linux_utimensat, AUE_FUTIMESAT, NULL, 0, 0, 0, SY_THR_STATIC },	/* 320 = linux_utimensat */
> 	{ 0, (sy_call_t *)linux_signalfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 321 = linux_signalfd */
> 	{ 0, (sy_call_t *)linux_timerfd_create, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 322 = linux_timerfd_create */
>-	{ 0, (sy_call_t *)linux_eventfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 323 = linux_eventfd */
>-	{ 0, (sy_call_t *)linux_fallocate, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 324 = linux_fallocate */
>+	{ AS(linux_eventfd_args), (sy_call_t *)linux_eventfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 323 = linux_eventfd */
>+	{ AS(linux_fallocate_args), (sy_call_t *)linux_fallocate, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 324 = linux_fallocate */
> 	{ 0, (sy_call_t *)linux_timerfd_settime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 325 = linux_timerfd_settime */
> 	{ 0, (sy_call_t *)linux_timerfd_gettime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 326 = linux_timerfd_gettime */
> 	{ 0, (sy_call_t *)linux_signalfd4, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 327 = linux_signalfd4 */
>-	{ 0, (sy_call_t *)linux_eventfd2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 328 = linux_eventfd2 */
>-	{ 0, (sy_call_t *)linux_epoll_create1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 329 = linux_epoll_create1 */
>-	{ 0, (sy_call_t *)linux_dup3, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 330 = linux_dup3 */
>+	{ AS(linux_eventfd2_args), (sy_call_t *)linux_eventfd2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 328 = linux_eventfd2 */
>+	{ AS(linux_epoll_create1_args), (sy_call_t *)linux_epoll_create1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 329 = linux_epoll_create1 */
>+	{ AS(linux_dup3_args), (sy_call_t *)linux_dup3, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 330 = linux_dup3 */
> 	{ AS(linux_pipe2_args), (sy_call_t *)linux_pipe2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 331 = linux_pipe2 */
> 	{ 0, (sy_call_t *)linux_inotify_init1, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 332 = linux_inotify_init1 */
> 	{ 0, (sy_call_t *)linux_preadv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 333 = linux_preadv */
>@@ -355,16 +355,17 @@
> 	{ 0, (sy_call_t *)linux_pwritev, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 334 = linux_pwritev */
> 	{ 0, (sy_call_t *)linux_rt_tsigqueueinfo, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 335 = linux_rt_tsigqueueinfo */
> 	{ 0, (sy_call_t *)linux_perf_event_open, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 336 = linux_perf_event_open */
>-	{ 0, (sy_call_t *)linux_recvmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 337 = linux_recvmmsg */
>+	{ AS(linux_recvmmsg_args), (sy_call_t *)linux_recvmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 337 = linux_recvmmsg */
> 	{ 0, (sy_call_t *)linux_fanotify_init, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 338 = linux_fanotify_init */
> 	{ 0, (sy_call_t *)linux_fanotify_mark, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 339 = linux_fanotify_mark */
>-	{ 0, (sy_call_t *)linux_prlimit64, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 340 = linux_prlimit64 */
>+	{ AS(linux_prlimit64_args), (sy_call_t *)linux_prlimit64, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 340 = linux_prlimit64 */
> 	{ 0, (sy_call_t *)linux_name_to_handle_at, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 341 = linux_name_to_handle_at */
> 	{ 0, (sy_call_t *)linux_open_by_handle_at, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 342 = linux_open_by_handle_at */
> 	{ 0, (sy_call_t *)linux_clock_adjtime, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 343 = linux_clock_adjtime */
>-	{ 0, (sy_call_t *)linux_syncfs, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 344 = linux_syncfs */
>-	{ 0, (sy_call_t *)linux_sendmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 345 = linux_sendmmsg */
>+	{ AS(linux_syncfs_args), (sy_call_t *)linux_syncfs, AUE_SYNC, NULL, 0, 0, 0, SY_THR_STATIC },	/* 344 = linux_syncfs */
>+	{ AS(linux_sendmmsg_args), (sy_call_t *)linux_sendmmsg, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 345 = linux_sendmmsg */
> 	{ 0, (sy_call_t *)linux_setns, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 346 = linux_setns */
> 	{ 0, (sy_call_t *)linux_process_vm_readv, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 347 = linux_process_vm_readv */
> 	{ 0, (sy_call_t *)linux_process_vm_writev, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },	/* 348 = linux_process_vm_writev */
>+	{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT },			/* 349 = nosys */
> };
>Index: sys/i386/linux/linux_systrace_args.c
>===================================================================
>--- sys/i386/linux/linux_systrace_args.c	(revision 285633)
>+++ sys/i386/linux/linux_systrace_args.c	(working copy)
>@@ -12,9 +12,9 @@
> 	int64_t *iarg  = (int64_t *) uarg;
> 	switch (sysnum) {
> #define	nosys	linux_nosys
>-	/* sys_exit */
>+	/* linux_exit */
> 	case 1: {
>-		struct sys_exit_args *p = params;
>+		struct linux_exit_args *p = params;
> 		iarg[0] = p->rval; /* int */
> 		*n_args = 1;
> 		break;
>@@ -1081,19 +1081,19 @@
> 		*n_args = 0;
> 		break;
> 	}
>-	/* sched_setparam */
>+	/* linux_sched_setparam */
> 	case 154: {
>-		struct sched_setparam_args *p = params;
>-		iarg[0] = p->pid; /* pid_t */
>-		uarg[1] = (intptr_t) p->param; /* const struct sched_param * */
>+		struct linux_sched_setparam_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->param; /* struct l_sched_param * */
> 		*n_args = 2;
> 		break;
> 	}
>-	/* sched_getparam */
>+	/* linux_sched_getparam */
> 	case 155: {
>-		struct sched_getparam_args *p = params;
>-		iarg[0] = p->pid; /* pid_t */
>-		uarg[1] = (intptr_t) p->param; /* struct sched_param * */
>+		struct linux_sched_getparam_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		uarg[1] = (intptr_t) p->param; /* struct l_sched_param * */
> 		*n_args = 2;
> 		break;
> 	}
>@@ -1132,9 +1132,9 @@
> 		*n_args = 1;
> 		break;
> 	}
>-	/* sched_rr_get_interval */
>+	/* linux_sched_rr_get_interval */
> 	case 161: {
>-		struct sched_rr_get_interval_args *p = params;
>+		struct linux_sched_rr_get_interval_args *p = params;
> 		iarg[0] = p->pid; /* l_pid_t */
> 		uarg[1] = (intptr_t) p->interval; /* struct l_timespec * */
> 		*n_args = 2;
>@@ -1277,7 +1277,11 @@
> 	}
> 	/* linux_rt_sigqueueinfo */
> 	case 178: {
>-		*n_args = 0;
>+		struct linux_rt_sigqueueinfo_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->sig; /* l_int */
>+		uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */
>+		*n_args = 3;
> 		break;
> 	}
> 	/* linux_rt_sigsuspend */
>@@ -1743,17 +1747,29 @@
> 	}
> 	/* linux_epoll_create */
> 	case 254: {
>-		*n_args = 0;
>+		struct linux_epoll_create_args *p = params;
>+		iarg[0] = p->size; /* l_int */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_epoll_ctl */
> 	case 255: {
>-		*n_args = 0;
>+		struct linux_epoll_ctl_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		iarg[1] = p->op; /* l_int */
>+		iarg[2] = p->fd; /* l_int */
>+		uarg[3] = (intptr_t) p->event; /* struct epoll_event * */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_epoll_wait */
> 	case 256: {
>-		*n_args = 0;
>+		struct linux_epoll_wait_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		uarg[1] = (intptr_t) p->events; /* struct epoll_event * */
>+		iarg[2] = p->maxevents; /* l_int */
>+		iarg[3] = p->timeout; /* l_int */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_remap_file_pages */
>@@ -1962,7 +1978,13 @@
> 	}
> 	/* linux_waitid */
> 	case 284: {
>-		*n_args = 0;
>+		struct linux_waitid_args *p = params;
>+		iarg[0] = p->idtype; /* int */
>+		iarg[1] = p->id; /* l_pid_t */
>+		uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */
>+		iarg[3] = p->options; /* int */
>+		uarg[4] = (intptr_t) p->rusage; /* struct l_rusage * */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_add_key */
>@@ -2133,18 +2155,30 @@
> 		iarg[0] = p->dfd; /* l_int */
> 		uarg[1] = (intptr_t) p->filename; /* const char * */
> 		iarg[2] = p->amode; /* l_int */
>-		iarg[3] = p->flag; /* l_int */
>-		*n_args = 4;
>+		*n_args = 3;
> 		break;
> 	}
> 	/* linux_pselect6 */
> 	case 308: {
>-		*n_args = 0;
>+		struct linux_pselect6_args *p = params;
>+		iarg[0] = p->nfds; /* l_int */
>+		uarg[1] = (intptr_t) p->readfds; /* l_fd_set * */
>+		uarg[2] = (intptr_t) p->writefds; /* l_fd_set * */
>+		uarg[3] = (intptr_t) p->exceptfds; /* l_fd_set * */
>+		uarg[4] = (intptr_t) p->tsp; /* struct l_timespec * */
>+		uarg[5] = (intptr_t) p->sig; /* l_uintptr_t * */
>+		*n_args = 6;
> 		break;
> 	}
> 	/* linux_ppoll */
> 	case 309: {
>-		*n_args = 0;
>+		struct linux_ppoll_args *p = params;
>+		uarg[0] = (intptr_t) p->fds; /* struct pollfd * */
>+		uarg[1] = p->nfds; /* uint32_t */
>+		uarg[2] = (intptr_t) p->tsp; /* struct l_timespec * */
>+		uarg[3] = (intptr_t) p->sset; /* l_sigset_t * */
>+		iarg[4] = p->ssize; /* l_size_t */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_unshare */
>@@ -2201,12 +2235,23 @@
> 	}
> 	/* linux_epoll_pwait */
> 	case 319: {
>-		*n_args = 0;
>+		struct linux_epoll_pwait_args *p = params;
>+		iarg[0] = p->epfd; /* l_int */
>+		uarg[1] = (intptr_t) p->events; /* struct epoll_event * */
>+		iarg[2] = p->maxevents; /* l_int */
>+		iarg[3] = p->timeout; /* l_int */
>+		uarg[4] = (intptr_t) p->mask; /* l_sigset_t * */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_utimensat */
> 	case 320: {
>-		*n_args = 0;
>+		struct linux_utimensat_args *p = params;
>+		iarg[0] = p->dfd; /* l_int */
>+		uarg[1] = (intptr_t) p->pathname; /* const char * */
>+		uarg[2] = (intptr_t) p->times; /* const struct l_timespec * */
>+		iarg[3] = p->flags; /* l_int */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_signalfd */
>@@ -2221,12 +2266,19 @@
> 	}
> 	/* linux_eventfd */
> 	case 323: {
>-		*n_args = 0;
>+		struct linux_eventfd_args *p = params;
>+		iarg[0] = p->initval; /* l_uint */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_fallocate */
> 	case 324: {
>-		*n_args = 0;
>+		struct linux_fallocate_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		iarg[1] = p->mode; /* l_int */
>+		iarg[2] = p->offset; /* l_loff_t */
>+		iarg[3] = p->len; /* l_loff_t */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_timerfd_settime */
>@@ -2246,17 +2298,26 @@
> 	}
> 	/* linux_eventfd2 */
> 	case 328: {
>-		*n_args = 0;
>+		struct linux_eventfd2_args *p = params;
>+		iarg[0] = p->initval; /* l_uint */
>+		iarg[1] = p->flags; /* l_int */
>+		*n_args = 2;
> 		break;
> 	}
> 	/* linux_epoll_create1 */
> 	case 329: {
>-		*n_args = 0;
>+		struct linux_epoll_create1_args *p = params;
>+		iarg[0] = p->flags; /* l_int */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_dup3 */
> 	case 330: {
>-		*n_args = 0;
>+		struct linux_dup3_args *p = params;
>+		iarg[0] = p->oldfd; /* l_int */
>+		iarg[1] = p->newfd; /* l_int */
>+		iarg[2] = p->flags; /* l_int */
>+		*n_args = 3;
> 		break;
> 	}
> 	/* linux_pipe2 */
>@@ -2294,7 +2355,13 @@
> 	}
> 	/* linux_recvmmsg */
> 	case 337: {
>-		*n_args = 0;
>+		struct linux_recvmmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */
>+		iarg[2] = p->vlen; /* l_uint */
>+		iarg[3] = p->flags; /* l_uint */
>+		uarg[4] = (intptr_t) p->timeout; /* struct l_timespec * */
>+		*n_args = 5;
> 		break;
> 	}
> 	/* linux_fanotify_init */
>@@ -2309,7 +2376,12 @@
> 	}
> 	/* linux_prlimit64 */
> 	case 340: {
>-		*n_args = 0;
>+		struct linux_prlimit64_args *p = params;
>+		iarg[0] = p->pid; /* l_pid_t */
>+		iarg[1] = p->resource; /* l_uint */
>+		uarg[2] = (intptr_t) p->new; /* struct rlimit * */
>+		uarg[3] = (intptr_t) p->old; /* struct rlimit * */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_name_to_handle_at */
>@@ -2329,12 +2401,19 @@
> 	}
> 	/* linux_syncfs */
> 	case 344: {
>-		*n_args = 0;
>+		struct linux_syncfs_args *p = params;
>+		iarg[0] = p->fd; /* l_int */
>+		*n_args = 1;
> 		break;
> 	}
> 	/* linux_sendmmsg */
> 	case 345: {
>-		*n_args = 0;
>+		struct linux_sendmmsg_args *p = params;
>+		iarg[0] = p->s; /* l_int */
>+		uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */
>+		iarg[2] = p->vlen; /* l_uint */
>+		iarg[3] = p->flags; /* l_uint */
>+		*n_args = 4;
> 		break;
> 	}
> 	/* linux_setns */
>@@ -2363,7 +2442,7 @@
> 	const char *p = NULL;
> 	switch (sysnum) {
> #define	nosys	linux_nosys
>-	/* sys_exit */
>+	/* linux_exit */
> 	case 1:
> 		switch(ndx) {
> 		case 0:
>@@ -3982,27 +4061,27 @@
> 	/* munlockall */
> 	case 153:
> 		break;
>-	/* sched_setparam */
>+	/* linux_sched_setparam */
> 	case 154:
> 		switch(ndx) {
> 		case 0:
>-			p = "pid_t";
>+			p = "l_pid_t";
> 			break;
> 		case 1:
>-			p = "const struct sched_param *";
>+			p = "struct l_sched_param *";
> 			break;
> 		default:
> 			break;
> 		};
> 		break;
>-	/* sched_getparam */
>+	/* linux_sched_getparam */
> 	case 155:
> 		switch(ndx) {
> 		case 0:
>-			p = "pid_t";
>+			p = "l_pid_t";
> 			break;
> 		case 1:
>-			p = "struct sched_param *";
>+			p = "struct l_sched_param *";
> 			break;
> 		default:
> 			break;
>@@ -4057,7 +4136,7 @@
> 			break;
> 		};
> 		break;
>-	/* sched_rr_get_interval */
>+	/* linux_sched_rr_get_interval */
> 	case 161:
> 		switch(ndx) {
> 		case 0:
>@@ -4298,6 +4377,19 @@
> 		break;
> 	/* linux_rt_sigqueueinfo */
> 	case 178:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_siginfo_t *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_rt_sigsuspend */
> 	case 179:
>@@ -4970,12 +5062,51 @@
> 		break;
> 	/* linux_epoll_create */
> 	case 254:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_epoll_ctl */
> 	case 255:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "struct epoll_event *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_epoll_wait */
> 	case 256:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct epoll_event *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_remap_file_pages */
> 	case 257:
>@@ -5299,6 +5430,25 @@
> 		break;
> 	/* linux_waitid */
> 	case 284:
>+		switch(ndx) {
>+		case 0:
>+			p = "int";
>+			break;
>+		case 1:
>+			p = "l_pid_t";
>+			break;
>+		case 2:
>+			p = "l_siginfo_t *";
>+			break;
>+		case 3:
>+			p = "int";
>+			break;
>+		case 4:
>+			p = "struct l_rusage *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_add_key */
> 	case 286:
>@@ -5558,9 +5708,6 @@
> 		case 2:
> 			p = "l_int";
> 			break;
>-		case 3:
>-			p = "l_int";
>-			break;
> 		default:
> 			break;
> 		};
>@@ -5567,9 +5714,50 @@
> 		break;
> 	/* linux_pselect6 */
> 	case 308:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_fd_set *";
>+			break;
>+		case 2:
>+			p = "l_fd_set *";
>+			break;
>+		case 3:
>+			p = "l_fd_set *";
>+			break;
>+		case 4:
>+			p = "struct l_timespec *";
>+			break;
>+		case 5:
>+			p = "l_uintptr_t *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_ppoll */
> 	case 309:
>+		switch(ndx) {
>+		case 0:
>+			p = "struct pollfd *";
>+			break;
>+		case 1:
>+			p = "uint32_t";
>+			break;
>+		case 2:
>+			p = "struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "l_sigset_t *";
>+			break;
>+		case 4:
>+			p = "l_size_t";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_unshare */
> 	case 310:
>@@ -5623,9 +5811,44 @@
> 		break;
> 	/* linux_epoll_pwait */
> 	case 319:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct epoll_event *";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		case 4:
>+			p = "l_sigset_t *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_utimensat */
> 	case 320:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "const char *";
>+			break;
>+		case 2:
>+			p = "const struct l_timespec *";
>+			break;
>+		case 3:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_signalfd */
> 	case 321:
>@@ -5635,9 +5858,32 @@
> 		break;
> 	/* linux_eventfd */
> 	case 323:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_fallocate */
> 	case 324:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_loff_t";
>+			break;
>+		case 3:
>+			p = "l_loff_t";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_timerfd_settime */
> 	case 325:
>@@ -5650,12 +5896,42 @@
> 		break;
> 	/* linux_eventfd2 */
> 	case 328:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_uint";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_epoll_create1 */
> 	case 329:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_dup3 */
> 	case 330:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "l_int";
>+			break;
>+		case 2:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_pipe2 */
> 	case 331:
>@@ -5687,6 +5963,25 @@
> 		break;
> 	/* linux_recvmmsg */
> 	case 337:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_mmsghdr *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		case 4:
>+			p = "struct l_timespec *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_fanotify_init */
> 	case 338:
>@@ -5696,6 +5991,22 @@
> 		break;
> 	/* linux_prlimit64 */
> 	case 340:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_pid_t";
>+			break;
>+		case 1:
>+			p = "l_uint";
>+			break;
>+		case 2:
>+			p = "struct rlimit *";
>+			break;
>+		case 3:
>+			p = "struct rlimit *";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_name_to_handle_at */
> 	case 341:
>@@ -5708,9 +6019,32 @@
> 		break;
> 	/* linux_syncfs */
> 	case 344:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_sendmmsg */
> 	case 345:
>+		switch(ndx) {
>+		case 0:
>+			p = "l_int";
>+			break;
>+		case 1:
>+			p = "struct l_mmsghdr *";
>+			break;
>+		case 2:
>+			p = "l_uint";
>+			break;
>+		case 3:
>+			p = "l_uint";
>+			break;
>+		default:
>+			break;
>+		};
> 		break;
> 	/* linux_setns */
> 	case 346:
>@@ -5733,7 +6067,7 @@
> 	const char *p = NULL;
> 	switch (sysnum) {
> #define	nosys	linux_nosys
>-	/* sys_exit */
>+	/* linux_exit */
> 	case 1:
> 		if (ndx == 0 || ndx == 1)
> 			p = "void";
>@@ -6365,12 +6699,12 @@
> 		break;
> 	/* munlockall */
> 	case 153:
>-	/* sched_setparam */
>+	/* linux_sched_setparam */
> 	case 154:
> 		if (ndx == 0 || ndx == 1)
> 			p = "int";
> 		break;
>-	/* sched_getparam */
>+	/* linux_sched_getparam */
> 	case 155:
> 		if (ndx == 0 || ndx == 1)
> 			p = "int";
>@@ -6397,7 +6731,7 @@
> 		if (ndx == 0 || ndx == 1)
> 			p = "int";
> 		break;
>-	/* sched_rr_get_interval */
>+	/* linux_sched_rr_get_interval */
> 	case 161:
> 		if (ndx == 0 || ndx == 1)
> 			p = "int";
>@@ -6475,6 +6809,9 @@
> 		break;
> 	/* linux_rt_sigqueueinfo */
> 	case 178:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_rt_sigsuspend */
> 	case 179:
> 		if (ndx == 0 || ndx == 1)
>@@ -6729,10 +7066,19 @@
> 	case 253:
> 	/* linux_epoll_create */
> 	case 254:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_epoll_ctl */
> 	case 255:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_epoll_wait */
> 	case 256:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_remap_file_pages */
> 	case 257:
> 	/* linux_set_tid_address */
>@@ -6847,6 +7193,9 @@
> 	case 283:
> 	/* linux_waitid */
> 	case 284:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_add_key */
> 	case 286:
> 	/* linux_request_key */
>@@ -6932,8 +7281,14 @@
> 		break;
> 	/* linux_pselect6 */
> 	case 308:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_ppoll */
> 	case 309:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_unshare */
> 	case 310:
> 	/* linux_set_robust_list */
>@@ -6960,8 +7315,14 @@
> 	case 318:
> 	/* linux_epoll_pwait */
> 	case 319:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_utimensat */
> 	case 320:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_signalfd */
> 	case 321:
> 	/* linux_timerfd_create */
>@@ -6968,8 +7329,14 @@
> 	case 322:
> 	/* linux_eventfd */
> 	case 323:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_fallocate */
> 	case 324:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_timerfd_settime */
> 	case 325:
> 	/* linux_timerfd_gettime */
>@@ -6978,10 +7345,19 @@
> 	case 327:
> 	/* linux_eventfd2 */
> 	case 328:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_epoll_create1 */
> 	case 329:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_dup3 */
> 	case 330:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_pipe2 */
> 	case 331:
> 		if (ndx == 0 || ndx == 1)
>@@ -6999,6 +7375,9 @@
> 	case 336:
> 	/* linux_recvmmsg */
> 	case 337:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_fanotify_init */
> 	case 338:
> 	/* linux_fanotify_mark */
>@@ -7005,6 +7384,9 @@
> 	case 339:
> 	/* linux_prlimit64 */
> 	case 340:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_name_to_handle_at */
> 	case 341:
> 	/* linux_open_by_handle_at */
>@@ -7013,8 +7395,14 @@
> 	case 343:
> 	/* linux_syncfs */
> 	case 344:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_sendmmsg */
> 	case 345:
>+		if (ndx == 0 || ndx == 1)
>+			p = "int";
>+		break;
> 	/* linux_setns */
> 	case 346:
> 	/* linux_process_vm_readv */
>Index: sys/i386/linux/linux_sysvec.c
>===================================================================
>--- sys/i386/linux/linux_sysvec.c	(revision 285633)
>+++ sys/i386/linux/linux_sysvec.c	(working copy)
>@@ -44,6 +44,7 @@
> #include <sys/proc.h>
> #include <sys/signalvar.h>
> #include <sys/syscallsubr.h>
>+#include <sys/sysctl.h>
> #include <sys/sysent.h>
> #include <sys/sysproto.h>
> #include <sys/vnode.h>
>@@ -71,11 +72,10 @@
> #include <compat/linux/linux_misc.h>
> #include <compat/linux/linux_signal.h>
> #include <compat/linux/linux_util.h>
>+#include <compat/linux/linux_vdso.h>
> 
> MODULE_VERSION(linux, 1);
> 
>-MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
>-
> #if BYTE_ORDER == LITTLE_ENDIAN
> #define SHELLMAGIC      0x2123 /* #! */
> #else
>@@ -82,6 +82,13 @@
> #define SHELLMAGIC      0x2321
> #endif
> 
>+#if defined(DEBUG)
>+SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
>+            CTLTYPE_STRING | CTLFLAG_RW,
>+            0, 0, linux_sysctl_debug, "A",
>+            "Linux debugging control");
>+#endif
>+
> /*
>  * Allow the sendsig functions to use the ldebug() facility
>  * even though they are not syscalls themselves. Map them
>@@ -93,13 +100,15 @@
> 
> #define	LINUX_PS_STRINGS	(LINUX_USRSTACK - sizeof(struct ps_strings))
> 
>-extern char linux_sigcode[];
>-extern int linux_szsigcode;
>+static int linux_szsigcode;
>+static vm_object_t linux_shared_page_obj;
>+static char *linux_shared_page_mapping;
>+extern char _binary_linux_locore_o_start;
>+extern char _binary_linux_locore_o_end;
> 
> extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
> 
> SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
>-SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
> 
> static int	linux_fixup(register_t **stack_base,
> 		    struct image_params *iparams);
>@@ -110,12 +119,15 @@
> 		    struct image_params *imgp, u_long stack);
> static register_t *linux_copyout_strings(struct image_params *imgp);
> static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
>+static void	linux_vdso_install(void *param);
>+static void	linux_vdso_deinstall(void *param);
> 
> static int linux_szplatform;
>-const char *linux_platform;
>+const char *linux_kplatform;
> 
> static eventhandler_tag linux_exit_tag;
> static eventhandler_tag linux_exec_tag;
>+static eventhandler_tag linux_thread_dtor_tag;
> 
> /*
>  * Linux syscalls return negative errno's, we do positive and map them
>@@ -137,28 +149,6 @@
> 	 -72, -67, -71
> };
> 
>-int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
>-	LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
>-	LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
>-	LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
>-	LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
>-	LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
>-	LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
>-	LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
>-	0, LINUX_SIGUSR1, LINUX_SIGUSR2
>-};
>-
>-int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
>-	SIGHUP, SIGINT, SIGQUIT, SIGILL,
>-	SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
>-	SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
>-	SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
>-	SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
>-	SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
>-	SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
>-	SIGIO, SIGURG, SIGSYS
>-};
>-
> #define LINUX_T_UNKNOWN  255
> static int _bsd_to_linux_trapcode[] = {
> 	LINUX_T_UNKNOWN,	/* 0 */
>@@ -198,6 +188,10 @@
>      _bsd_to_linux_trapcode[(code)]: \
>      LINUX_T_UNKNOWN)
> 
>+LINUX_VDSO_SYM_INTPTR(linux_sigcode);
>+LINUX_VDSO_SYM_INTPTR(linux_rt_sigcode);
>+LINUX_VDSO_SYM_INTPTR(linux_vsyscall);
>+
> /*
>  * If FreeBSD & Linux have a difference of opinion about what a trap
>  * means, deal with it here.
>@@ -208,15 +202,15 @@
> translate_traps(int signal, int trap_code)
> {
> 	if (signal != SIGBUS)
>-		return signal;
>+		return (signal);
> 	switch (trap_code) {
> 	case T_PROTFLT:
> 	case T_TSSFLT:
> 	case T_DOUBLEFLT:
> 	case T_PAGEFLT:
>-		return SIGSEGV;
>+		return (SIGSEGV);
> 	default:
>-		return signal;
>+		return (signal);
> 	}
> }
> 
>@@ -254,6 +248,9 @@
> 	args = (Elf32_Auxargs *)imgp->auxargs;
> 	pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
> 
>+	AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO_EHDR,
>+	    imgp->proc->p_sysent->sv_shared_page_base);
>+	AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO, linux_vsyscall);
> 	AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, cpu_feature);
> 
> 	/*
>@@ -279,6 +276,9 @@
> 	AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
> 	AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
> 	AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
>+	AUXARGS_ENTRY(pos, LINUX_AT_RANDOM, imgp->canary);
>+	if (imgp->execpathp != 0)
>+		AUXARGS_ENTRY(pos, LINUX_AT_EXECFN, imgp->execpathp);
> 	if (args->execfd != -1)
> 		AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
> 	AUXARGS_ENTRY(pos, AT_NULL, 0);
>@@ -302,24 +302,46 @@
> 	char *stringp, *destp;
> 	register_t *stack_base;
> 	struct ps_strings *arginfo;
>+	char canary[LINUX_AT_RANDOM_LEN];
>+	size_t execpath_len;
> 	struct proc *p;
> 
> 	/*
> 	 * Calculate string base and vector table pointers.
>-	 * Also deal with signal trampoline code for this exec type.
> 	 */
> 	p = imgp->proc;
>+	if (imgp->execpath != NULL && imgp->auxargs != NULL)
>+		execpath_len = strlen(imgp->execpath) + 1;
>+	else
>+		execpath_len = 0;
> 	arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
> 	destp = (caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
>+	    roundup(sizeof(canary), sizeof(char *)) -
>+	    roundup(execpath_len, sizeof(char *)) -
> 	    roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
> 
> 	/*
> 	 * install LINUX_PLATFORM
> 	 */
>-	copyout(linux_platform, ((caddr_t)arginfo - linux_szplatform),
>+	copyout(linux_kplatform, ((caddr_t)arginfo - linux_szplatform),
> 	    linux_szplatform);
> 
>+	if (execpath_len != 0) {
>+		imgp->execpathp = (uintptr_t)arginfo -
>+		linux_szplatform - execpath_len;
>+		copyout(imgp->execpath, (void *)imgp->execpathp, execpath_len);
>+	}
>+
> 	/*
>+	 * Prepare the canary for SSP.
>+	 */
>+	arc4rand(canary, sizeof(canary), 0);
>+	imgp->canary = (uintptr_t)arginfo - linux_szplatform -
>+	    roundup(execpath_len, sizeof(char *)) -
>+	    roundup(sizeof(canary), sizeof(char *));
>+	copyout(canary, (void *)imgp->canary, sizeof(canary));
>+
>+	/*
> 	 * If we have a valid auxargs ptr, prepare some room
> 	 * on the stack.
> 	 */
>@@ -398,10 +420,6 @@
> 	return (stack_base);
> }
> 
>-
>-
>-extern unsigned long linux_sznonrtsigcode;
>-
> static void
> linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
> {
>@@ -440,9 +458,7 @@
> 	/*
> 	 * Build the argument list for the signal handler.
> 	 */
>-	if (p->p_sysent->sv_sigtbl)
>-		if (sig <= p->p_sysent->sv_sigsize)
>-			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>+	sig = bsd_to_linux_signal(sig);
> 
> 	bzero(&frame, sizeof(frame));
> 
>@@ -468,7 +484,7 @@
> 
> 	bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
> 
>-	frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
>+	frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__mask;
> 	frame.sf_sc.uc_mcontext.sc_gs     = rgs();
> 	frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
> 	frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
>@@ -477,6 +493,7 @@
> 	frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
> 	frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
> 	frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
>+	frame.sf_sc.uc_mcontext.sc_esp    = regs->tf_esp;
> 	frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
> 	frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
> 	frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
>@@ -514,7 +531,7 @@
> 	 * Build context to run handler in.
> 	 */
> 	regs->tf_esp = (int)fp;
>-	regs->tf_eip = p->p_sysent->sv_sigcode_base + linux_sznonrtsigcode;
>+	regs->tf_eip = linux_rt_sigcode;
> 	regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
> 	regs->tf_cs = _ucodesel;
> 	regs->tf_ds = _udatasel;
>@@ -546,7 +563,7 @@
> 	struct l_sigframe *fp, frame;
> 	l_sigset_t lmask;
> 	int sig, code;
>-	int oonstack, i;
>+	int oonstack;
> 
> 	PROC_LOCK_ASSERT(p, MA_OWNED);
> 	psp = p->p_sigacts;
>@@ -582,9 +599,7 @@
> 	/*
> 	 * Build the argument list for the signal handler.
> 	 */
>-	if (p->p_sysent->sv_sigtbl)
>-		if (sig <= p->p_sysent->sv_sigsize)
>-			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>+	sig = bsd_to_linux_signal(sig);
> 
> 	bzero(&frame, sizeof(frame));
> 
>@@ -596,7 +611,7 @@
> 	/*
> 	 * Build the signal context to be used by sigreturn.
> 	 */
>-	frame.sf_sc.sc_mask   = lmask.__bits[0];
>+	frame.sf_sc.sc_mask   = lmask.__mask;
> 	frame.sf_sc.sc_gs     = rgs();
> 	frame.sf_sc.sc_fs     = regs->tf_fs;
> 	frame.sf_sc.sc_es     = regs->tf_es;
>@@ -605,6 +620,7 @@
> 	frame.sf_sc.sc_esi    = regs->tf_esi;
> 	frame.sf_sc.sc_ebp    = regs->tf_ebp;
> 	frame.sf_sc.sc_ebx    = regs->tf_ebx;
>+	frame.sf_sc.sc_esp    = regs->tf_esp;
> 	frame.sf_sc.sc_edx    = regs->tf_edx;
> 	frame.sf_sc.sc_ecx    = regs->tf_ecx;
> 	frame.sf_sc.sc_eax    = regs->tf_eax;
>@@ -617,8 +633,7 @@
> 	frame.sf_sc.sc_cr2    = (register_t)ksi->ksi_addr;
> 	frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(ksi->ksi_trapno);
> 
>-	for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
>-		frame.sf_extramask[i] = lmask.__bits[i+1];
>+	frame.sf_extramask[0] = lmask.__mask;
> 
> 	if (copyout(&frame, fp, sizeof(frame)) != 0) {
> 		/*
>@@ -633,7 +648,7 @@
> 	 * Build context to run handler in.
> 	 */
> 	regs->tf_esp = (int)fp;
>-	regs->tf_eip = p->p_sysent->sv_sigcode_base;
>+	regs->tf_eip = linux_sigcode;
> 	regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
> 	regs->tf_cs = _ucodesel;
> 	regs->tf_ds = _udatasel;
>@@ -661,7 +676,7 @@
> 	struct trapframe *regs;
> 	l_sigset_t lmask;
> 	sigset_t bmask;
>-	int eflags, i;
>+	int eflags;
> 	ksiginfo_t ksi;
> 
> 	regs = td->td_frame;
>@@ -684,7 +699,7 @@
> #define	EFLAGS_SECURE(ef, oef)	((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
> 	eflags = frame.sf_sc.sc_eflags;
> 	if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
>-		return(EINVAL);
>+		return (EINVAL);
> 
> 	/*
> 	 * Don't allow users to load a valid privileged %cs.  Let the
>@@ -699,12 +714,10 @@
> 		ksi.ksi_trapno = T_PROTFLT;
> 		ksi.ksi_addr = (void *)regs->tf_eip;
> 		trapsignal(td, &ksi);
>-		return(EINVAL);
>+		return (EINVAL);
> 	}
> 
>-	lmask.__bits[0] = frame.sf_sc.sc_mask;
>-	for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
>-		lmask.__bits[i+1] = frame.sf_extramask[i];
>+	lmask.__mask = frame.sf_sc.sc_mask;
> 	linux_to_bsd_sigset(&lmask, &bmask);
> 	kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
> 
>@@ -775,7 +788,7 @@
> #define	EFLAGS_SECURE(ef, oef)	((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
> 	eflags = context->sc_eflags;
> 	if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
>-		return(EINVAL);
>+		return (EINVAL);
> 
> 	/*
> 	 * Don't allow users to load a valid privileged %cs.  Let the
>@@ -790,7 +803,7 @@
> 		ksi.ksi_trapno = T_PROTFLT;
> 		ksi.ksi_addr = (void *)regs->tf_eip;
> 		trapsignal(td, &ksi);
>-		return(EINVAL);
>+		return (EINVAL);
> 	}
> 
> 	linux_to_bsd_sigset(&uc.uc_sigmask, &bmask);
>@@ -852,7 +865,8 @@
> 	sa->args[5] = frame->tf_ebp;	/* Unconfirmed */
> 
> 	if (sa->code >= p->p_sysent->sv_size)
>-		sa->callp = &p->p_sysent->sv_table[0];
>+		/* nosys */
>+		sa->callp = &p->p_sysent->sv_table[LINUX_SYS_MAXSYSCALL];
>  	else
>  		sa->callp = &p->p_sysent->sv_table[sa->code];
> 	sa->narg = sa->callp->sy_narg;
>@@ -942,14 +956,14 @@
> 	.sv_size	= LINUX_SYS_MAXSYSCALL,
> 	.sv_table	= linux_sysent,
> 	.sv_mask	= 0,
>-	.sv_sigsize	= LINUX_SIGTBLSZ,
>-	.sv_sigtbl	= bsd_to_linux_signal,
>+	.sv_sigsize	= 0,
>+	.sv_sigtbl	= NULL,
> 	.sv_errsize	= ELAST + 1,
> 	.sv_errtbl	= bsd_to_linux_errno,
> 	.sv_transtrap	= translate_traps,
> 	.sv_fixup	= linux_fixup,
> 	.sv_sendsig	= linux_sendsig,
>-	.sv_sigcode	= linux_sigcode,
>+	.sv_sigcode	= &_binary_linux_locore_o_start,
> 	.sv_szsigcode	= &linux_szsigcode,
> 	.sv_prepsyscall	= NULL,
> 	.sv_name	= "Linux a.out",
>@@ -973,6 +987,8 @@
> 	.sv_shared_page_base = LINUX_SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= linux_schedtail,
>+	.sv_thread_detach = linux_thread_detach,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(aout_sysvec, &linux_sysvec);
> 
>@@ -980,14 +996,14 @@
> 	.sv_size	= LINUX_SYS_MAXSYSCALL,
> 	.sv_table	= linux_sysent,
> 	.sv_mask	= 0,
>-	.sv_sigsize	= LINUX_SIGTBLSZ,
>-	.sv_sigtbl	= bsd_to_linux_signal,
>+	.sv_sigsize	= 0,
>+	.sv_sigtbl	= NULL,
> 	.sv_errsize	= ELAST + 1,
> 	.sv_errtbl	= bsd_to_linux_errno,
> 	.sv_transtrap	= translate_traps,
> 	.sv_fixup	= elf_linux_fixup,
> 	.sv_sendsig	= linux_sendsig,
>-	.sv_sigcode	= linux_sigcode,
>+	.sv_sigcode	= &_binary_linux_locore_o_start,
> 	.sv_szsigcode	= &linux_szsigcode,
> 	.sv_prepsyscall	= NULL,
> 	.sv_name	= "Linux ELF",
>@@ -1011,9 +1027,43 @@
> 	.sv_shared_page_base = LINUX_SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= linux_schedtail,
>+	.sv_thread_detach = linux_thread_detach,
>+	.sv_trap	= NULL,
> };
>-INIT_SYSENTVEC(elf_sysvec, &elf_linux_sysvec);
> 
>+static void
>+linux_vdso_install(void *param)
>+{
>+
>+	linux_szsigcode = (&_binary_linux_locore_o_end - 
>+	    &_binary_linux_locore_o_start);
>+
>+	if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
>+		panic("Linux invalid vdso size\n");
>+
>+	__elfN(linux_vdso_fixup)(&elf_linux_sysvec);
>+
>+	linux_shared_page_obj = __elfN(linux_shared_page_init)
>+	    (&linux_shared_page_mapping);
>+
>+	__elfN(linux_vdso_reloc)(&elf_linux_sysvec, LINUX_SHAREDPAGE);
>+
>+	bcopy(elf_linux_sysvec.sv_sigcode, linux_shared_page_mapping,
>+	    linux_szsigcode);
>+	elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
>+}
>+SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
>+    (sysinit_cfunc_t)linux_vdso_install, NULL);
>+
>+static void
>+linux_vdso_deinstall(void *param)
>+{
>+
>+	__elfN(linux_shared_page_fini)(linux_shared_page_obj);
>+};
>+SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
>+    (sysinit_cfunc_t)linux_vdso_deinstall, NULL);
>+
> static char GNU_ABI_VENDOR[] = "GNU";
> static int GNULINUX_ABI_DESC = 0;
> 
>@@ -1084,7 +1134,6 @@
> 	Elf32_Brandinfo **brandinfo;
> 	int error;
> 	struct linux_ioctl_handler **lihp;
>-	struct linux_device_handler **ldhp;
> 
> 	error = 0;
> 
>@@ -1097,10 +1146,6 @@
> 		if (error == 0) {
> 			SET_FOREACH(lihp, linux_ioctl_handler_set)
> 				linux_ioctl_register_handler(*lihp);
>-			SET_FOREACH(ldhp, linux_device_handler_set)
>-				linux_device_register_handler(*ldhp);
>-			mtx_init(&emul_lock, "emuldata lock", NULL, MTX_DEF);
>-			sx_init(&emul_shared_lock, "emuldata->shared lock");
> 			LIST_INIT(&futex_list);
> 			mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF);
> 			linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, linux_proc_exit,
>@@ -1107,8 +1152,10 @@
> 			      NULL, 1000);
> 			linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_exec,
> 			      NULL, 1000);
>-			linux_get_machine(&linux_platform);
>-			linux_szplatform = roundup(strlen(linux_platform) + 1,
>+			linux_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor,
>+			    linux_thread_dtor, NULL, EVENTHANDLER_PRI_ANY);
>+			linux_get_machine(&linux_kplatform);
>+			linux_szplatform = roundup(strlen(linux_kplatform) + 1,
> 			    sizeof(char *));
> 			linux_osd_jail_register();
> 			stclohz = (stathz ? stathz : hz);
>@@ -1131,13 +1178,10 @@
> 		if (error == 0) {
> 			SET_FOREACH(lihp, linux_ioctl_handler_set)
> 				linux_ioctl_unregister_handler(*lihp);
>-			SET_FOREACH(ldhp, linux_device_handler_set)
>-				linux_device_unregister_handler(*ldhp);
>-			mtx_destroy(&emul_lock);
>-			sx_destroy(&emul_shared_lock);
> 			mtx_destroy(&futex_mtx);
> 			EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
> 			EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
>+			EVENTHANDLER_DEREGISTER(thread_dtor, linux_thread_dtor_tag);
> 			linux_osd_jail_deregister();
> 			if (bootverbose)
> 				printf("Linux ELF exec handler removed\n");
>@@ -1145,9 +1189,9 @@
> 			printf("Could not deinstall ELF interpreter entry\n");
> 		break;
> 	default:
>-		return EOPNOTSUPP;
>+		return (EOPNOTSUPP);
> 	}
>-	return error;
>+	return (error);
> }
> 
> static moduledata_t linux_elf_mod = {
>Index: sys/i386/linux/linux_vdso.lds.s
>===================================================================
>--- sys/i386/linux/linux_vdso.lds.s	(revision 0)
>+++ sys/i386/linux/linux_vdso.lds.s	(working copy)
>@@ -0,0 +1,65 @@
>+/*
>+ * Linker script for 32-bit vDSO.
>+ * Copied from Linux kernel arch/x86/vdso/vdso-layout.lds.S
>+ * and arch/x86/vdso/vdso32/vdso32.lds.S
>+ *
>+ * $FreeBSD$
>+ */
>+
>+SECTIONS
>+{
>+	. = . + SIZEOF_HEADERS;
>+
>+	.hash		: { *(.hash) }			:text
>+	.gnu.hash	: { *(.gnu.hash) }
>+	.dynsym		: { *(.dynsym) }
>+	.dynstr		: { *(.dynstr) }
>+	.gnu.version	: { *(.gnu.version) }
>+	.gnu.version_d	: { *(.gnu.version_d) }
>+	.gnu.version_r	: { *(.gnu.version_r) }
>+
>+	.note		: { *(.note.*) }		:text	:note
>+
>+	.eh_frame_hdr	: { *(.eh_frame_hdr) }		:text	:eh_frame_hdr
>+	.eh_frame	: { KEEP (*(.eh_frame)) }	:text
>+
>+	.dynamic	: { *(.dynamic) }		:text	:dynamic
>+
>+	.rodata		: { *(.rodata*) }		:text
>+	.data		: {
>+	      *(.data*)
>+	      *(.sdata*)
>+	      *(.got.plt) *(.got)
>+	      *(.gnu.linkonce.d.*)
>+	      *(.bss*)
>+	      *(.dynbss*)
>+	      *(.gnu.linkonce.b.*)
>+	}
>+
>+	.altinstructions	: { *(.altinstructions) }
>+	.altinstr_replacement	: { *(.altinstr_replacement) }
>+
>+	. = ALIGN(0x100);
>+	.text		: { *(.text*) }			:text	=0x90909090
>+}
>+
>+PHDRS
>+{
>+	text		PT_LOAD		FLAGS(5) FILEHDR PHDRS; /* PF_R|PF_X */
>+	dynamic		PT_DYNAMIC	FLAGS(4);		/* PF_R */
>+	note		PT_NOTE		FLAGS(4);		/* PF_R */
>+	eh_frame_hdr	PT_GNU_EH_FRAME;
>+}
>+
>+ENTRY(linux_vsyscall);
>+
>+VERSION
>+{
>+	LINUX_2.5 {
>+	global:
>+		linux_vsyscall;
>+		linux_sigcode;
>+		linux_rt_sigcode;
>+	local: *;
>+	};
>+}
>Index: sys/i386/linux/syscalls.master
>===================================================================
>--- sys/i386/linux/syscalls.master	(revision 285633)
>+++ sys/i386/linux/syscalls.master	(working copy)
>@@ -37,8 +37,7 @@
> ; #ifdef's, etc. may be included, and are copied to the output files.
> 
> 0	AUE_NULL	UNIMPL	setup
>-1	AUE_EXIT	NOPROTO	{ void sys_exit(int rval); } exit \
>-				    sys_exit_args void
>+1	AUE_EXIT	STD	{ void linux_exit(int rval); }
> 2	AUE_FORK	STD	{ int linux_fork(void); }
> 3	AUE_NULL	NOPROTO	{ int read(int fd, char *buf, \
> 				    u_int nbyte); }
>@@ -270,10 +269,10 @@
> 151	AUE_MUNLOCK	NOPROTO	{ int munlock(const void *addr, size_t len); }
> 152	AUE_MLOCKALL	NOPROTO	{ int mlockall(int how); }
> 153	AUE_MUNLOCKALL	NOPROTO	{ int munlockall(void); }
>-154	AUE_SCHED_SETPARAM	NOPROTO	{ int sched_setparam(pid_t pid, \
>-				    const struct sched_param *param); }
>-155	AUE_SCHED_GETPARAM	NOPROTO	{ int sched_getparam(pid_t pid, \
>-				    struct sched_param *param); }
>+154	AUE_SCHED_SETPARAM	STD	{ int linux_sched_setparam(l_pid_t pid, \
>+				    struct l_sched_param *param); }
>+155	AUE_SCHED_GETPARAM	STD	{ int linux_sched_getparam(l_pid_t pid, \
>+				    struct l_sched_param *param); }
> 156	AUE_SCHED_SETSCHEDULER	STD { int linux_sched_setscheduler( \
> 				    l_pid_t pid, l_int policy, \
> 				    struct l_sched_param *param); }
>@@ -284,8 +283,8 @@
> 				    l_int policy); }
> 160	AUE_SCHED_GET_PRIORITY_MIN	STD { int linux_sched_get_priority_min( \
> 				    l_int policy); }
>-161	AUE_SCHED_RR_GET_INTERVAL	NOPROTO	{ int sched_rr_get_interval(l_pid_t pid, \
>-				    struct l_timespec *interval); }
>+161	AUE_SCHED_RR_GET_INTERVAL	STD	{ int linux_sched_rr_get_interval( \
>+				    l_pid_t pid, struct l_timespec *interval); }
> 162	AUE_NULL	STD	{ int linux_nanosleep( \
> 				    const struct l_timespec *rqtp, \
> 				    struct l_timespec *rmtp); }
>@@ -321,7 +320,8 @@
> 				    l_siginfo_t *ptr, \
> 				    struct l_timeval *timeout, \
> 				    l_size_t sigsetsize); }
>-178	AUE_NULL	STD	{ int linux_rt_sigqueueinfo(void); }
>+178	AUE_NULL	STD	{ int linux_rt_sigqueueinfo(l_pid_t pid, l_int sig, \
>+				    l_siginfo_t *info); }
> 179	AUE_NULL	STD	{ int linux_rt_sigsuspend( \
> 				    l_sigset_t *newset, \
> 				    l_size_t sigsetsize); }
>@@ -432,9 +432,11 @@
> 251	AUE_NULL	UNIMPL
> 252	AUE_EXIT	STD	{ int linux_exit_group(int error_code); }
> 253	AUE_NULL	STD	{ int linux_lookup_dcookie(void); }
>-254	AUE_NULL	STD	{ int linux_epoll_create(void); }
>-255	AUE_NULL	STD	{ int linux_epoll_ctl(void); }
>-256	AUE_NULL	STD	{ int linux_epoll_wait(void); }
>+254	AUE_NULL	STD	{ int linux_epoll_create(l_int size); }
>+255	AUE_NULL	STD	{ int linux_epoll_ctl(l_int epfd, l_int op, l_int fd, \
>+					struct epoll_event *event); }
>+256	AUE_NULL	STD	{ int linux_epoll_wait(l_int epfd, struct epoll_event *events, \
>+					l_int maxevents, l_int timeout); }
> 257	AUE_NULL	STD	{ int linux_remap_file_pages(void); }
> 258	AUE_NULL	STD	{ int linux_set_tid_address(int *tidptr); }
> 259	AUE_NULL	STD	{ int linux_timer_create(clockid_t clock_id, \
>@@ -475,7 +477,8 @@
> 282	AUE_NULL	STD	{ int linux_mq_getsetattr(l_mqd_t mqd, const struct mq_attr *attr, \
> 					struct mq_attr *oattr); }
> 283	AUE_NULL	STD	{ int linux_kexec_load(void); }
>-284	AUE_NULL	STD	{ int linux_waitid(void); }
>+284	AUE_WAIT6	STD	{ int linux_waitid(int idtype, l_pid_t id, l_siginfo_t *info, \
>+					int options, struct l_rusage *rusage); }
> 285	AUE_NULL	UNIMPL
> ; linux 2.6.11:
> 286	AUE_NULL	STD	{ int linux_add_key(void); }
>@@ -513,9 +516,12 @@
> 					char *buf, l_int bufsiz); }
> 306	AUE_FCHMODAT	STD	{ int linux_fchmodat(l_int dfd, const char *filename, \
> 					l_mode_t mode); }
>-307	AUE_FACCESSAT	STD	{ int linux_faccessat(l_int dfd, const char *filename, l_int amode, l_int flag); }
>-308	AUE_NULL	STD	{ int linux_pselect6(void); }
>-309	AUE_NULL	STD	{ int linux_ppoll(void); }
>+307	AUE_FACCESSAT	STD	{ int linux_faccessat(l_int dfd, const char *filename, l_int amode); }
>+308	AUE_SELECT	STD	{ int linux_pselect6(l_int nfds, l_fd_set *readfds,	\
>+					l_fd_set *writefds, l_fd_set *exceptfds,	\
>+					struct l_timespec *tsp, l_uintptr_t *sig); }
>+309	AUE_POLL	STD	{ int linux_ppoll(struct pollfd *fds, uint32_t nfds,	\
>+				    struct l_timespec *tsp, l_sigset_t *sset, l_size_t ssize); }
> 310	AUE_NULL	STD	{ int linux_unshare(void); }
> ; linux 2.6.17:
> 311	AUE_NULL	STD	{ int linux_set_robust_list(struct linux_robust_list_head *head, \
>@@ -530,22 +536,26 @@
> 317	AUE_NULL	STD	{ int linux_move_pages(void); }
> ; linux 2.6.19:
> 318	AUE_NULL	STD	{ int linux_getcpu(void); }
>-319	AUE_NULL	STD	{ int linux_epoll_pwait(void); }
>+319	AUE_NULL	STD	{ int linux_epoll_pwait(l_int epfd, struct epoll_event *events, \
>+					l_int maxevents, l_int timeout, l_sigset_t *mask); }
> ; linux 2.6.22:
>-320	AUE_NULL	STD	{ int linux_utimensat(void); }
>+320	AUE_FUTIMESAT	STD	{ int linux_utimensat(l_int dfd, const char *pathname, \
>+					const struct l_timespec *times, l_int flags); }
> 321	AUE_NULL	STD	{ int linux_signalfd(void); }
> 322	AUE_NULL	STD	{ int linux_timerfd_create(void); }
>-323	AUE_NULL	STD	{ int linux_eventfd(void); }
>+323	AUE_NULL	STD	{ int linux_eventfd(l_uint initval); }
> ; linux 2.6.23:
>-324	AUE_NULL	STD	{ int linux_fallocate(void); }
>+324	AUE_NULL	STD	{ int linux_fallocate(l_int fd, l_int mode, \
>+				    l_loff_t offset, l_loff_t len); }
> ; linux 2.6.25:
> 325	AUE_NULL	STD	{ int linux_timerfd_settime(void); }
> 326	AUE_NULL	STD	{ int linux_timerfd_gettime(void); }
> ; linux 2.6.27:
> 327	AUE_NULL	STD	{ int linux_signalfd4(void); }
>-328	AUE_NULL	STD	{ int linux_eventfd2(void); }
>-329	AUE_NULL	STD	{ int linux_epoll_create1(void); }
>-330	AUE_NULL	STD	{ int linux_dup3(void); }
>+328	AUE_NULL	STD	{ int linux_eventfd2(l_uint initval, l_int flags); }
>+329	AUE_NULL	STD	{ int linux_epoll_create1(l_int flags); }
>+330	AUE_NULL	STD	{ int linux_dup3(l_int oldfd,		\
>+					l_int newfd, l_int flags); }
> 331	AUE_NULL	STD	{ int linux_pipe2(l_int *pipefds, l_int flags); }
> 332	AUE_NULL	STD	{ int linux_inotify_init1(void); }
> ; linux 2.6.30:
>@@ -555,17 +565,26 @@
> 335	AUE_NULL	STD	{ int linux_rt_tsigqueueinfo(void); }
> 336	AUE_NULL	STD	{ int linux_perf_event_open(void); }
> ; linux 2.6.33:
>-337	AUE_NULL	STD	{ int linux_recvmmsg(void); }
>+337	AUE_NULL	STD	{ int linux_recvmmsg(l_int s,			\
>+				    struct l_mmsghdr *msg, l_uint vlen,		\
>+				    l_uint flags, struct l_timespec *timeout); }
> 338	AUE_NULL	STD	{ int linux_fanotify_init(void); }
> 339	AUE_NULL	STD	{ int linux_fanotify_mark(void); }
> ; linux 2.6.36:
>-340	AUE_NULL	STD	{ int linux_prlimit64(void); }
>+340	AUE_NULL	STD	{ int linux_prlimit64(l_pid_t pid,	\
>+					l_uint resource,		\
>+					struct rlimit *new,		\
>+					struct rlimit *old); }
> ; later:
> 341	AUE_NULL	STD	{ int linux_name_to_handle_at(void); }
> 342	AUE_NULL	STD	{ int linux_open_by_handle_at(void); }
> 343	AUE_NULL	STD	{ int linux_clock_adjtime(void); }
>-344	AUE_NULL	STD	{ int linux_syncfs(void); }
>-345	AUE_NULL	STD	{ int linux_sendmmsg(void); }
>+344	AUE_SYNC	STD	{ int linux_syncfs(l_int fd); }
>+345	AUE_NULL	STD	{ int linux_sendmmsg(l_int s,			\
>+				    struct l_mmsghdr *msg, l_uint vlen,		\
>+				    l_uint flags); }
> 346	AUE_NULL	STD	{ int linux_setns(void); }
> 347	AUE_NULL	STD	{ int linux_process_vm_readv(void); }
> 348	AUE_NULL	STD	{ int linux_process_vm_writev(void); }
>+; please, keep this line at the end.
>+349	AUE_NULL	UNIMPL	nosys
>Index: sys/kern/imgact_aout.c
>===================================================================
>--- sys/kern/imgact_aout.c	(revision 285633)
>+++ sys/kern/imgact_aout.c	(working copy)
>@@ -99,6 +99,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = syscallnames,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> #elif defined(__amd64__)
>Index: sys/kern/init_main.c
>===================================================================
>--- sys/kern/init_main.c	(revision 285633)
>+++ sys/kern/init_main.c	(working copy)
>@@ -410,6 +410,7 @@
> 	.sv_fetch_syscall_args = null_fetch_syscall_args,
> 	.sv_syscallnames = NULL,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> /*
>@@ -604,9 +605,9 @@
> 	sx_slock(&allproc_lock);
> 	FOREACH_PROC_IN_SYSTEM(p) {
> 		microuptime(&p->p_stats->p_start);
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 		rufetch(p, &ru);	/* Clears thread stats */
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> 		p->p_rux.rux_runtime = 0;
> 		p->p_rux.rux_uticks = 0;
> 		p->p_rux.rux_sticks = 0;
>Index: sys/kern/kern_clock.c
>===================================================================
>--- sys/kern/kern_clock.c	(revision 285633)
>+++ sys/kern/kern_clock.c	(working copy)
>@@ -433,16 +433,16 @@
> 	flags = 0;
> 	if (usermode &&
> 	    timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value)) {
>-		PROC_SLOCK(p);
>+		PROC_ITIMLOCK(p);
> 		if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0)
> 			flags |= TDF_ALRMPEND | TDF_ASTPENDING;
>-		PROC_SUNLOCK(p);
>+		PROC_ITIMUNLOCK(p);
> 	}
> 	if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
>-		PROC_SLOCK(p);
>+		PROC_ITIMLOCK(p);
> 		if (itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0)
> 			flags |= TDF_PROFPEND | TDF_ASTPENDING;
>-		PROC_SUNLOCK(p);
>+		PROC_ITIMUNLOCK(p);
> 	}
> 	thread_lock(td);
> 	sched_tick(1);
>@@ -521,18 +521,18 @@
> 	flags = 0;
> 	if (usermode &&
> 	    timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value)) {
>-		PROC_SLOCK(p);
>+		PROC_ITIMLOCK(p);
> 		if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL],
> 		    tick * cnt) == 0)
> 			flags |= TDF_ALRMPEND | TDF_ASTPENDING;
>-		PROC_SUNLOCK(p);
>+		PROC_ITIMUNLOCK(p);
> 	}
> 	if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
>-		PROC_SLOCK(p);
>+		PROC_ITIMLOCK(p);
> 		if (itimerdecr(&pstats->p_timer[ITIMER_PROF],
> 		    tick * cnt) == 0)
> 			flags |= TDF_PROFPEND | TDF_ASTPENDING;
>-		PROC_SUNLOCK(p);
>+		PROC_ITIMUNLOCK(p);
> 	}
> 	thread_lock(td);
> 	sched_tick(cnt);
>Index: sys/kern/kern_descrip.c
>===================================================================
>--- sys/kern/kern_descrip.c	(revision 285633)
>+++ sys/kern/kern_descrip.c	(working copy)
>@@ -1874,7 +1874,7 @@
> 	return (&newfdp->fd_fd);
> }
> 
>-static struct filedesc *
>+struct filedesc *
> fdhold(struct proc *p)
> {
> 	struct filedesc *fdp;
>@@ -1887,7 +1887,7 @@
> 	return (fdp);
> }
> 
>-static void
>+void
> fddrop(struct filedesc *fdp)
> {
> 	struct filedesc0 *fdp0;
>Index: sys/kern/kern_event.c
>===================================================================
>--- sys/kern/kern_event.c	(revision 285633)
>+++ sys/kern/kern_event.c	(working copy)
>@@ -731,6 +731,13 @@
> int
> sys_kqueue(struct thread *td, struct kqueue_args *uap)
> {
>+
>+	return (kern_kqueue(td, 0));
>+}
>+
>+int
>+kern_kqueue(struct thread *td, int flags)
>+{
> 	struct filedesc *fdp;
> 	struct kqueue *kq;
> 	struct file *fp;
>@@ -737,7 +744,7 @@
> 	int fd, error;
> 
> 	fdp = td->td_proc->p_fd;
>-	error = falloc(td, &fp, &fd, 0);
>+	error = falloc(td, &fp, &fd, flags);
> 	if (error)
> 		goto done2;
> 
>@@ -863,12 +870,9 @@
> kern_kevent(struct thread *td, int fd, int nchanges, int nevents,
>     struct kevent_copyops *k_ops, const struct timespec *timeout)
> {
>-	struct kevent keva[KQ_NEVENTS];
>-	struct kevent *kevp, *changes;
>-	struct kqueue *kq;
>+	cap_rights_t rights;
> 	struct file *fp;
>-	cap_rights_t rights;
>-	int i, n, nerrors, error;
>+	int error;
> 
> 	cap_rights_init(&rights);
> 	if (nchanges > 0)
>@@ -879,9 +883,24 @@
> 	if (error != 0)
> 		return (error);
> 
>+	error = kern_kevent_fp(td, fp, nchanges, nevents, k_ops, timeout);
>+	fdrop(fp, td);
>+
>+	return (error);
>+}
>+
>+int
>+kern_kevent_fp(struct thread *td, struct file *fp, int nchanges, int nevents,
>+    struct kevent_copyops *k_ops, const struct timespec *timeout)
>+{
>+	struct kevent keva[KQ_NEVENTS];
>+	struct kevent *kevp, *changes;
>+	struct kqueue *kq;
>+	int i, n, nerrors, error;
>+
> 	error = kqueue_acquire(fp, &kq);
> 	if (error != 0)
>-		goto done_norel;
>+		return (error);
> 
> 	nerrors = 0;
> 
>@@ -921,8 +940,6 @@
> 	error = kqueue_scan(kq, nevents, k_ops, timeout, keva, td);
> done:
> 	kqueue_release(kq, 0);
>-done_norel:
>-	fdrop(fp, td);
> 	return (error);
> }
> 
>Index: sys/kern/kern_exit.c
>===================================================================
>--- sys/kern/kern_exit.c	(revision 285633)
>+++ sys/kern/kern_exit.c	(working copy)
>@@ -660,7 +660,9 @@
> 	/*
> 	 * Save our children's rusage information in our exit rusage.
> 	 */
>+	PROC_STATLOCK(p);
> 	ruadd(&p->p_ru, &p->p_rux, &p->p_stats->p_cru, &p->p_crux);
>+	PROC_STATUNLOCK(p);
> 
> 	/*
> 	 * Make sure the scheduler takes this thread out of its tables etc.
>@@ -1043,8 +1045,6 @@
> 		return (0);
> 	}
> 
>-	PROC_SLOCK(p);
>-
> 	if (siginfo != NULL) {
> 		bzero(siginfo, sizeof(*siginfo));
> 		siginfo->si_errno = 0;
>@@ -1091,7 +1091,9 @@
> 	if (wrusage != NULL) {
> 		rup = &wrusage->wru_self;
> 		*rup = p->p_ru;
>+		PROC_STATLOCK(p);
> 		calcru(p, &rup->ru_utime, &rup->ru_stime);
>+		PROC_STATUNLOCK(p);
> 
> 		rup = &wrusage->wru_children;
> 		*rup = p->p_stats->p_cru;
>@@ -1099,10 +1101,10 @@
> 	}
> 
> 	if (p->p_state == PRS_ZOMBIE) {
>+		PROC_SLOCK(p);
> 		proc_reap(td, p, status, options);
> 		return (-1);
> 	}
>-	PROC_SUNLOCK(p);
> 	PROC_UNLOCK(p);
> 	return (1);
> }
>Index: sys/kern/kern_mutex.c
>===================================================================
>--- sys/kern/kern_mutex.c	(revision 285633)
>+++ sys/kern/kern_mutex.c	(working copy)
>@@ -989,6 +989,9 @@
> 	blocked_lock.mtx_lock = 0xdeadc0de;	/* Always blocked. */
> 	mtx_init(&proc0.p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
> 	mtx_init(&proc0.p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE);
>+	mtx_init(&proc0.p_statmtx, "pstatl", NULL, MTX_SPIN);
>+	mtx_init(&proc0.p_itimmtx, "pitiml", NULL, MTX_SPIN);
>+	mtx_init(&proc0.p_profmtx, "pprofl", NULL, MTX_SPIN);
> 	mtx_init(&devmtx, "cdev", NULL, MTX_DEF);
> 	mtx_lock(&Giant);
> }
>Index: sys/kern/kern_proc.c
>===================================================================
>--- sys/kern/kern_proc.c	(revision 285633)
>+++ sys/kern/kern_proc.c	(working copy)
>@@ -229,6 +229,9 @@
> 	bzero(&p->p_mtx, sizeof(struct mtx));
> 	mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
> 	mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE);
>+	mtx_init(&p->p_statmtx, "pstatl", NULL, MTX_SPIN);
>+	mtx_init(&p->p_itimmtx, "pitiml", NULL, MTX_SPIN);
>+	mtx_init(&p->p_profmtx, "pprofl", NULL, MTX_SPIN);
> 	cv_init(&p->p_pwait, "ppwait");
> 	cv_init(&p->p_dbgwait, "dbgwait");
> 	TAILQ_INIT(&p->p_threads);	     /* all threads in proc */
>@@ -871,11 +874,11 @@
> 	kp->ki_fibnum = p->p_fibnum;
> 	kp->ki_start = p->p_stats->p_start;
> 	timevaladd(&kp->ki_start, &boottime);
>-	PROC_SLOCK(p);
>+	PROC_STATLOCK(p);
> 	rufetch(p, &kp->ki_rusage);
> 	kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
> 	calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
>-	PROC_SUNLOCK(p);
>+	PROC_STATUNLOCK(p);
> 	calccru(p, &kp->ki_childutime, &kp->ki_childstime);
> 	/* Some callers want child times in a single value. */
> 	kp->ki_childtime = kp->ki_childstime;
>@@ -940,7 +943,7 @@
> 	PROC_LOCK_ASSERT(p, MA_OWNED);
> 
> 	if (preferthread)
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 	thread_lock(td);
> 	if (td->td_wmesg != NULL)
> 		strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
>@@ -1007,7 +1010,7 @@
> 	kp->ki_sigmask = td->td_sigmask;
> 	thread_unlock(td);
> 	if (preferthread)
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> }
> 
> /*
>Index: sys/kern/kern_racct.c
>===================================================================
>--- sys/kern/kern_racct.c	(revision 285633)
>+++ sys/kern/kern_racct.c	(working copy)
>@@ -1215,11 +1215,11 @@
> 
> 			microuptime(&wallclock);
> 			timevalsub(&wallclock, &p->p_stats->p_start);
>-			PROC_SLOCK(p);
>+			PROC_STATLOCK(p);
> 			FOREACH_THREAD_IN_PROC(p, td)
> 				ruxagg(p, td);
> 			runtime = cputick2usec(p->p_rux.rux_runtime);
>-			PROC_SUNLOCK(p);
>+			PROC_STATUNLOCK(p);
> #ifdef notyet
> 			KASSERT(runtime >= p->p_prev_runtime,
> 			    ("runtime < p_prev_runtime"));
>Index: sys/kern/kern_resource.c
>===================================================================
>--- sys/kern/kern_resource.c	(revision 285633)
>+++ sys/kern/kern_resource.c	(working copy)
>@@ -631,11 +631,11 @@
> 	 */
> 	if (p->p_cpulimit == RLIM_INFINITY)
> 		return;
>-	PROC_SLOCK(p);
>+	PROC_STATLOCK(p);
> 	FOREACH_THREAD_IN_PROC(p, td) {
> 		ruxagg(p, td);
> 	}
>-	PROC_SUNLOCK(p);
>+	PROC_STATUNLOCK(p);
> 	if (p->p_rux.rux_runtime > p->p_cpulimit * cpu_tickrate()) {
> 		lim_rlimit(p, RLIMIT_CPU, &rlim);
> 		if (p->p_rux.rux_runtime >= rlim.rlim_max * cpu_tickrate()) {
>@@ -847,7 +847,7 @@
> 	uint64_t runtime, u;
> 
> 	PROC_LOCK_ASSERT(p, MA_OWNED);
>-	PROC_SLOCK_ASSERT(p, MA_OWNED);
>+	PROC_STATLOCK_ASSERT(p, MA_OWNED);
> 	/*
> 	 * If we are getting stats for the current process, then add in the
> 	 * stats that this thread has accumulated in its current time slice.
>@@ -879,7 +879,7 @@
> 	uint64_t runtime, u;
> 
> 	p = td->td_proc;
>-	PROC_SLOCK_ASSERT(p, MA_OWNED);
>+	PROC_STATLOCK_ASSERT(p, MA_OWNED);
> 	THREAD_LOCK_ASSERT(td, MA_OWNED);
> 	/*
> 	 * If we are getting stats for the current thread, then add in the
>@@ -1015,11 +1015,11 @@
> 		break;
> 
> 	case RUSAGE_THREAD:
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 		thread_lock(td);
> 		rufetchtd(td, rup);
> 		thread_unlock(td);
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> 		break;
> 
> 	default:
>@@ -1066,7 +1066,7 @@
> {
> 
> 	THREAD_LOCK_ASSERT(td, MA_OWNED);
>-	PROC_SLOCK_ASSERT(td->td_proc, MA_OWNED);
>+	PROC_STATLOCK_ASSERT(td->td_proc, MA_OWNED);
> 	rux->rux_runtime += td->td_incruntime;
> 	rux->rux_uticks += td->td_uticks;
> 	rux->rux_sticks += td->td_sticks;
>@@ -1096,7 +1096,7 @@
> {
> 	struct thread *td;
> 
>-	PROC_SLOCK_ASSERT(p, MA_OWNED);
>+	PROC_STATLOCK_ASSERT(p, MA_OWNED);
> 
> 	*ru = p->p_ru;
> 	if (p->p_numthreads > 0)  {
>@@ -1117,10 +1117,10 @@
>     struct timeval *sp)
> {
> 
>-	PROC_SLOCK(p);
>+	PROC_STATLOCK(p);
> 	rufetch(p, ru);
> 	calcru(p, up, sp);
>-	PROC_SUNLOCK(p);
>+	PROC_STATUNLOCK(p);
> }
> 
> /*
>Index: sys/kern/kern_thr.c
>===================================================================
>--- sys/kern/kern_thr.c	(revision 285633)
>+++ sys/kern/kern_thr.c	(working copy)
>@@ -162,12 +162,6 @@
> 
> 	p = td->td_proc;
> 
>-	/* Have race condition but it is cheap. */
>-	if (p->p_numthreads >= max_threads_per_proc) {
>-		++max_threads_hits;
>-		return (EPROCLIM);
>-	}
>-
> 	if (rtp != NULL) {
> 		switch(rtp->type) {
> 		case RTP_PRIO_REALTIME:
>@@ -195,11 +189,9 @@
> #endif
> 
> 	/* Initialize our td */
>-	newtd = thread_alloc(0);
>-	if (newtd == NULL) {
>-		error = ENOMEM;
>+	error = kern_thr_alloc(p, 0, &newtd);
>+	if (error)
> 		goto fail;
>-	}
> 
> 	cpu_set_upcall(newtd, td);
> 
>@@ -306,10 +298,7 @@
> sys_thr_exit(struct thread *td, struct thr_exit_args *uap)
>     /* long *state */
> {
>-	struct proc *p;
> 
>-	p = td->td_proc;
>-
> 	/* Signal userland that it can free the stack. */
> 	if ((void *)uap->state != NULL) {
> 		suword_lwpid(uap->state, 1);
>@@ -316,6 +305,16 @@
> 		kern_umtx_wake(td, uap->state, INT_MAX, 0);
> 	}
> 
>+	return (kern_thr_exit(td));
>+}
>+
>+int
>+kern_thr_exit(struct thread *td)
>+{
>+	struct proc *p;
>+
>+	p = td->td_proc;
>+
> 	rw_wlock(&tidhash_lock);
> 
> 	PROC_LOCK(p);
>@@ -559,3 +558,20 @@
> 	PROC_UNLOCK(p);
> 	return (error);
> }
>+
>+int
>+kern_thr_alloc(struct proc *p, int pages, struct thread **ntd)
>+{
>+
>+	/* Have race condition but it is cheap. */
>+	if (p->p_numthreads >= max_threads_per_proc) {
>+		++max_threads_hits;
>+		return (EPROCLIM);
>+	}
>+
>+	*ntd = thread_alloc(pages);
>+	if (*ntd == NULL)
>+		return (ENOMEM);
>+
>+	return (0);
>+}
>Index: sys/kern/kern_thread.c
>===================================================================
>--- sys/kern/kern_thread.c	(revision 285633)
>+++ sys/kern/kern_thread.c	(working copy)
>@@ -45,6 +45,7 @@
> #include <sys/smp.h>
> #include <sys/sched.h>
> #include <sys/sleepqueue.h>
>+#include <sys/sysent.h>
> #include <sys/selinfo.h>
> #include <sys/turnstile.h>
> #include <sys/ktr.h>
>@@ -472,6 +473,9 @@
> 		PMC_SWITCH_CONTEXT(td, PMC_FN_CSW_OUT);
> #endif
> 	PROC_UNLOCK(p);
>+	PROC_STATLOCK(p);
>+	thread_lock(td);
>+	PROC_SUNLOCK(p);
> 
> 	/* Do the same timestamp bookkeeping that mi_switch() would do. */
> 	new_switchtime = cpu_ticks();
>@@ -486,9 +490,8 @@
> 	td->td_ru.ru_nvcsw++;
> 	ruxagg(p, td);
> 	rucollect(&p->p_ru, &td->td_ru);
>+	PROC_STATUNLOCK(p);
> 
>-	thread_lock(td);
>-	PROC_SUNLOCK(p);
> 	td->td_state = TDS_INACTIVE;
> #ifdef WITNESS
> 	witness_thread_exit(td);
>@@ -882,6 +885,12 @@
> 		 */
> 		if ((p->p_flag & P_SINGLE_EXIT) && (p->p_singlethread != td)) {
> 			PROC_UNLOCK(p);
>+			/*
>+			 * Let thread to do cleanup work before die.
>+			 */
>+			if (__predict_false(p->p_sysent->sv_thread_detach != NULL))
>+				(p->p_sysent->sv_thread_detach)(td);
>+
> 			tidhash_remove(td);
> 			PROC_LOCK(p);
> 			tdsigcleanup(td);
>Index: sys/kern/kern_time.c
>===================================================================
>--- sys/kern/kern_time.c	(revision 285633)
>+++ sys/kern/kern_time.c	(working copy)
>@@ -273,10 +273,10 @@
> 	uint64_t runtime;
> 	struct rusage ru;
> 
>-	PROC_SLOCK(targetp);
>+	PROC_STATLOCK(targetp);
> 	rufetch(targetp, &ru);
> 	runtime = targetp->p_rux.rux_runtime;
>-	PROC_SUNLOCK(targetp);
>+	PROC_STATUNLOCK(targetp);
> 	cputick2timespec(runtime, ats);
> }
> 
>@@ -325,17 +325,17 @@
> 		break;
> 	case CLOCK_VIRTUAL:
> 		PROC_LOCK(p);
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 		calcru(p, &user, &sys);
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> 		PROC_UNLOCK(p);
> 		TIMEVAL_TO_TIMESPEC(&user, ats);
> 		break;
> 	case CLOCK_PROF:
> 		PROC_LOCK(p);
>-		PROC_SLOCK(p);
>+		PROC_STATLOCK(p);
> 		calcru(p, &user, &sys);
>-		PROC_SUNLOCK(p);
>+		PROC_STATUNLOCK(p);
> 		PROC_UNLOCK(p);
> 		timevaladd(&user, &sys);
> 		TIMEVAL_TO_TIMESPEC(&user, ats);
>@@ -695,9 +695,9 @@
> 				timevalsub(&aitv->it_value, &ctv);
> 		}
> 	} else {
>-		PROC_SLOCK(p);
>+		PROC_ITIMLOCK(p);
> 		*aitv = p->p_stats->p_timer[which];
>-		PROC_SUNLOCK(p);
>+		PROC_ITIMUNLOCK(p);
> 	}
> 	return (0);
> }
>@@ -779,10 +779,10 @@
> 		    aitv->it_value.tv_usec != 0 &&
> 		    aitv->it_value.tv_usec < tick)
> 			aitv->it_value.tv_usec = tick;
>-		PROC_SLOCK(p);
>+		PROC_ITIMLOCK(p);
> 		*oitv = p->p_stats->p_timer[which];
> 		p->p_stats->p_timer[which] = *aitv;
>-		PROC_SUNLOCK(p);
>+		PROC_ITIMUNLOCK(p);
> 	}
> 	return (0);
> }
>Index: sys/kern/p1003_1b.c
>===================================================================
>--- sys/kern/p1003_1b.c	(revision 285633)
>+++ sys/kern/p1003_1b.c	(working copy)
>@@ -130,16 +130,29 @@
> 		targettd = FIRST_THREAD_IN_PROC(targetp);
> 	}
> 
>-	e = p_cansched(td, targetp);
>-	if (e == 0) {
>-		e = ksched_setparam(ksched, targettd,
>-			(const struct sched_param *)&sched_param);
>-	}
>+	e = kern_sched_setparam(td, targettd, &sched_param);
> 	PROC_UNLOCK(targetp);
> 	return (e);
> }
> 
> int
>+kern_sched_setparam(struct thread *td, struct thread *targettd,
>+    struct sched_param *param)
>+{
>+	struct proc *targetp;
>+	int error;
>+
>+	targetp = targettd->td_proc;
>+	PROC_LOCK_ASSERT(targetp, MA_OWNED);
>+
>+	error = p_cansched(td, targetp);
>+	if (error == 0)
>+		error = ksched_setparam(ksched, targettd,
>+		    (const struct sched_param *)param);
>+	return (error);
>+}
>+
>+int
> sys_sched_getparam(struct thread *td, struct sched_getparam_args *uap)
> {
> 	int e;
>@@ -159,10 +172,7 @@
> 		targettd = FIRST_THREAD_IN_PROC(targetp);
> 	}
> 
>-	e = p_cansee(td, targetp);
>-	if (e == 0) {
>-		e = ksched_getparam(ksched, targettd, &sched_param);
>-	}
>+	e = kern_sched_getparam(td, targettd, &sched_param);
> 	PROC_UNLOCK(targetp);
> 	if (e == 0)
> 		e = copyout(&sched_param, uap->param, sizeof(sched_param));
>@@ -170,6 +180,22 @@
> }
> 
> int
>+kern_sched_getparam(struct thread *td, struct thread *targettd,
>+    struct sched_param *param)
>+{
>+	struct proc *targetp;
>+	int error;
>+
>+	targetp = targettd->td_proc;
>+	PROC_LOCK_ASSERT(targetp, MA_OWNED);
>+
>+	error = p_cansee(td, targetp);
>+	if (error == 0)
>+		error = ksched_getparam(ksched, targettd, param);
>+	return (error);
>+}
>+
>+int
> sys_sched_setscheduler(struct thread *td, struct sched_setscheduler_args *uap)
> {
> 	int e;
>@@ -177,11 +203,6 @@
> 	struct thread *targettd;
> 	struct proc *targetp;
> 
>-	/* Don't allow non root user to set a scheduler policy. */
>-	e = priv_check(td, PRIV_SCHED_SET);
>-	if (e)
>-		return (e);
>-
> 	e = copyin(uap->param, &sched_param, sizeof(sched_param));
> 	if (e)
> 		return (e);
>@@ -197,16 +218,35 @@
> 		targettd = FIRST_THREAD_IN_PROC(targetp);
> 	}
> 
>-	e = p_cansched(td, targetp);
>-	if (e == 0) {
>-		e = ksched_setscheduler(ksched, targettd,
>-			uap->policy, (const struct sched_param *)&sched_param);
>-	}
>+	e = kern_sched_setscheduler(td, targettd, uap->policy,
>+	    &sched_param);
> 	PROC_UNLOCK(targetp);
> 	return (e);
> }
> 
> int
>+kern_sched_setscheduler(struct thread *td, struct thread *targettd,
>+    int policy, struct sched_param *param)
>+{
>+	struct proc *targetp;
>+	int error;
>+
>+	targetp = targettd->td_proc;
>+	PROC_LOCK_ASSERT(targetp, MA_OWNED);
>+
>+	/* Don't allow non root user to set a scheduler policy. */
>+	error = priv_check(td, PRIV_SCHED_SET);
>+	if (error)
>+		return (error);
>+
>+	error = p_cansched(td, targetp);
>+	if (error == 0)
>+		error = ksched_setscheduler(ksched, targettd, policy,
>+		    (const struct sched_param *)param);
>+	return (error);
>+}
>+
>+int
> sys_sched_getscheduler(struct thread *td, struct sched_getscheduler_args *uap)
> {
> 	int e, policy;
>@@ -224,17 +264,31 @@
> 		targettd = FIRST_THREAD_IN_PROC(targetp);
> 	}
> 
>-	e = p_cansee(td, targetp);
>-	if (e == 0) {
>-		e = ksched_getscheduler(ksched, targettd, &policy);
>+	e = kern_sched_getscheduler(td, targettd, &policy);
>+	PROC_UNLOCK(targetp);
>+	if (e == 0)
> 		td->td_retval[0] = policy;
>-	}
>-	PROC_UNLOCK(targetp);
> 
> 	return (e);
> }
> 
> int
>+kern_sched_getscheduler(struct thread *td, struct thread *targettd,
>+    int *policy)
>+{
>+	struct proc *targetp;
>+	int error;
>+
>+	targetp = targettd->td_proc;
>+	PROC_LOCK_ASSERT(targetp, MA_OWNED);
>+
>+	error = p_cansee(td, targetp);
>+	if (error == 0)
>+		error = ksched_getscheduler(ksched, targettd, policy);
>+	return (error);
>+}
>+
>+int
> sys_sched_yield(struct thread *td, struct sched_yield_args *uap)
> {
> 
>@@ -296,13 +350,26 @@
> 		targettd = FIRST_THREAD_IN_PROC(targetp);
> 	}
> 
>-	e = p_cansee(td, targetp);
>-	if (e == 0)
>-		e = ksched_rr_get_interval(ksched, targettd, ts);
>+	e = kern_sched_rr_get_interval_td(td, targettd, ts);
> 	PROC_UNLOCK(targetp);
> 	return (e);
> }
> 
>+int
>+kern_sched_rr_get_interval_td(struct thread *td, struct thread *targettd,
>+    struct timespec *ts)
>+{
>+	struct proc *p;
>+	int error;
>+
>+	p = targettd->td_proc;
>+	PROC_LOCK_ASSERT(p, MA_OWNED);
>+
>+	error = p_cansee(td, p);
>+	if (error == 0)
>+		error = ksched_rr_get_interval(ksched, targettd, ts);
>+	return (error);
>+}
> #endif
> 
> static void
>Index: sys/kern/subr_prof.c
>===================================================================
>--- sys/kern/subr_prof.c	(revision 285633)
>+++ sys/kern/subr_prof.c	(working copy)
>@@ -421,12 +421,12 @@
> 	}
> 	PROC_LOCK(p);
> 	upp = &td->td_proc->p_stats->p_prof;
>-	PROC_SLOCK(p);
>+	PROC_PROFLOCK(p);
> 	upp->pr_off = uap->offset;
> 	upp->pr_scale = uap->scale;
> 	upp->pr_base = uap->samples;
> 	upp->pr_size = uap->size;
>-	PROC_SUNLOCK(p);
>+	PROC_PROFUNLOCK(p);
> 	startprofclock(p);
> 	PROC_UNLOCK(p);
> 
>@@ -466,15 +466,15 @@
> 	if (ticks == 0)
> 		return;
> 	prof = &td->td_proc->p_stats->p_prof;
>-	PROC_SLOCK(td->td_proc);
>+	PROC_PROFLOCK(td->td_proc);
> 	if (pc < prof->pr_off ||
> 	    (i = PC_TO_INDEX(pc, prof)) >= prof->pr_size) {
>-		PROC_SUNLOCK(td->td_proc);
>+		PROC_PROFUNLOCK(td->td_proc);
> 		return;			/* out of range; ignore */
> 	}
> 
> 	addr = prof->pr_base + i;
>-	PROC_SUNLOCK(td->td_proc);
>+	PROC_PROFUNLOCK(td->td_proc);
> 	if ((v = fuswintr(addr)) == -1 || suswintr(addr, v + ticks) == -1) {
> 		td->td_profil_addr = pc;
> 		td->td_profil_ticks = ticks;
>@@ -509,15 +509,15 @@
> 	}
> 	p->p_profthreads++;
> 	prof = &p->p_stats->p_prof;
>-	PROC_SLOCK(p);
>+	PROC_PROFLOCK(p);
> 	if (pc < prof->pr_off ||
> 	    (i = PC_TO_INDEX(pc, prof)) >= prof->pr_size) {
>-		PROC_SUNLOCK(p);
>+		PROC_PROFUNLOCK(p);
> 		goto out;
> 	}
> 
> 	addr = prof->pr_base + i;
>-	PROC_SUNLOCK(p);
>+	PROC_PROFUNLOCK(p);
> 	PROC_UNLOCK(p);
> 	if (copyin(addr, &v, sizeof(v)) == 0) {
> 		v += ticks;
>Index: sys/mips/mips/elf_machdep.c
>===================================================================
>--- sys/mips/mips/elf_machdep.c	(revision 285633)
>+++ sys/mips/mips/elf_machdep.c	(working copy)
>@@ -83,6 +83,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = syscallnames,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> static Elf64_Brandinfo freebsd_brand_info = {
>@@ -139,6 +140,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = syscallnames,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> static Elf32_Brandinfo freebsd_brand_info = {
>Index: sys/mips/mips/freebsd32_machdep.c
>===================================================================
>--- sys/mips/mips/freebsd32_machdep.c	(revision 285633)
>+++ sys/mips/mips/freebsd32_machdep.c	(working copy)
>@@ -106,6 +106,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = freebsd32_syscallnames,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(elf32_sysvec, &elf32_freebsd_sysvec);
> 
>@@ -418,12 +419,6 @@
> 		sfp = (struct sigframe32 *)((vm_offset_t)(td->td_frame->sp - 
> 		    sizeof(struct sigframe32)) & ~(sizeof(__int64_t) - 1));
> 
>-	/* Translate the signal if appropriate */
>-	if (p->p_sysent->sv_sigtbl) {
>-		if (sig <= p->p_sysent->sv_sigsize)
>-			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-	}
>-
> 	/* Build the argument list for the signal handler. */
> 	td->td_frame->a0 = sig;
> 	td->td_frame->a2 = (register_t)(intptr_t)&sfp->sf_uc;
>Index: sys/mips/mips/pm_machdep.c
>===================================================================
>--- sys/mips/mips/pm_machdep.c	(revision 285633)
>+++ sys/mips/mips/pm_machdep.c	(working copy)
>@@ -133,12 +133,6 @@
> 		sfp = (struct sigframe *)((vm_offset_t)(regs->sp - 
> 		    sizeof(struct sigframe)) & ~(sizeof(__int64_t) - 1));
> 
>-	/* Translate the signal if appropriate */
>-	if (p->p_sysent->sv_sigtbl) {
>-		if (sig <= p->p_sysent->sv_sigsize)
>-			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-	}
>-
> 	/* Build the argument list for the signal handler. */
> 	regs->a0 = sig;
> 	regs->a2 = (register_t)(intptr_t)&sfp->sf_uc;
>Index: sys/modules/Makefile
>===================================================================
>--- sys/modules/Makefile	(revision 285633)
>+++ sys/modules/Makefile	(working copy)
>@@ -197,6 +197,8 @@
> 	${_linprocfs} \
> 	${_linsysfs} \
> 	${_linux} \
>+	${_linux_common} \
>+	${_linux64} \
> 	lmc \
> 	lpt \
> 	mac_biba \
>@@ -741,6 +743,8 @@
> _linprocfs=	linprocfs
> _linsysfs=	linsysfs
> _linux=		linux
>+_linux64=	linux64
>+_linux_common=	linux_common
> _mly=		mly
> .if ${MK_OFED} != "no" || defined(ALL_MODULES)
> _mlx4=		mlx4
>Index: sys/modules/linprocfs/Makefile
>===================================================================
>--- sys/modules/linprocfs/Makefile	(revision 285633)
>+++ sys/modules/linprocfs/Makefile	(working copy)
>@@ -5,11 +5,6 @@
> KMOD=	linprocfs
> SRCS=	vnode_if.h \
> 	device_if.h bus_if.h \
>-	linprocfs.c \
>-	opt_compat.h
>+	linprocfs.c
> 
>-.if ${MACHINE_CPUARCH} == "amd64"
>-CFLAGS+=-DCOMPAT_LINUX32
>-.endif
>-
> .include <bsd.kmod.mk>
>Index: sys/modules/linsysfs/Makefile
>===================================================================
>--- sys/modules/linsysfs/Makefile	(revision 285633)
>+++ sys/modules/linsysfs/Makefile	(working copy)
>@@ -5,11 +5,6 @@
> KMOD=	linsysfs
> SRCS=	vnode_if.h \
> 	device_if.h bus_if.h  pci_if.h \
>-	linsysfs.c \
>-	opt_compat.h
>+	linsysfs.c
> 
>-.if ${MACHINE_CPUARCH} == "amd64"
>-CFLAGS+=-DCOMPAT_LINUX32
>-.endif
>-
> .include <bsd.kmod.mk>
>Index: sys/modules/linux/Makefile
>===================================================================
>--- sys/modules/linux/Makefile	(revision 285633)
>+++ sys/modules/linux/Makefile	(working copy)
>@@ -7,15 +7,18 @@
> 
> .PATH: ${.CURDIR}/../../compat/linux ${.CURDIR}/../../${MACHINE_CPUARCH}/linux${SFX}
> 
>+VDSO=	linux${SFX}_vdso
>+
> KMOD=	linux
>-SRCS=	linux_fork.c linux${SFX}_dummy.c linux_emul.c linux_file.c \
>+SRCS=	linux_fork.c linux${SFX}_dummy.c linux_file.c linux_event.c \
> 	linux_futex.c linux_getcwd.c linux_ioctl.c linux_ipc.c \
>-	linux${SFX}_machdep.c linux_mib.c linux_misc.c linux_signal.c \
>+	linux${SFX}_machdep.c linux_misc.c linux_signal.c \
> 	linux_socket.c linux_stats.c linux_sysctl.c linux${SFX}_sysent.c \
>-	linux${SFX}_sysvec.c linux_uid16.c linux_util.c linux_time.c \
>-	linux_timer.c \
>-	opt_inet6.h opt_compat.h opt_kdtrace.h opt_posix.h opt_usb.h \
>-	vnode_if.h device_if.h bus_if.h assym.s
>+	linux${SFX}_sysvec.c linux_uid16.c linux_time.c \
>+	linux_timer.c linux_vdso.c \
>+	opt_inet6.h opt_compat.h opt_posix.h opt_usb.h vnode_if.h \
>+	device_if.h bus_if.h assym.s \
>+	linux${SFX}_support.s
> DPSRCS=	linux${SFX}_genassym.c
> 
> # XXX: for assym.s
>@@ -24,45 +27,62 @@
> SRCS+=	opt_apic.h
> .endif
> 
>-OBJS=	linux${SFX}_locore.o linux${SFX}_support.o
>+OBJS=	${VDSO}.so
> 
> .if ${MACHINE_CPUARCH} == "i386"
>-SRCS+=	linux_ptrace.c imgact_linux.c opt_cpu.h
>+SRCS+=	linux_ptrace.c imgact_linux.c linux_util.c linux_mib.c \
>+	linux_emul.c opt_cpu.h linux.c
> .endif
> 
>+.if ${MACHINE_CPUARCH} == "i386"
> EXPORT_SYMS=
> EXPORT_SYMS+=	linux_emul_path
> EXPORT_SYMS+=	linux_get_osname
> EXPORT_SYMS+=	linux_get_osrelease
>-EXPORT_SYMS+=	linux_ifname
> EXPORT_SYMS+=	linux_ioctl_register_handler
> EXPORT_SYMS+=	linux_ioctl_unregister_handler
>+.endif
> 
>-CLEANFILES=	linux${SFX}_assym.h linux${SFX}_genassym.o
>+CLEANFILES=	linux${SFX}_assym.h linux${SFX}_genassym.o linux${SFX}_locore.o
> 
> linux${SFX}_assym.h: linux${SFX}_genassym.o
>-.if exists(@)
>-linux${SFX}_assym.h: @/kern/genassym.sh
>-.endif
>-	sh @/kern/genassym.sh linux${SFX}_genassym.o > ${.TARGET}
>+	sh ${SYSDIR}/kern/genassym.sh linux${SFX}_genassym.o > ${.TARGET}
> 
>-linux${SFX}_locore.o: linux${SFX}_locore.s linux${SFX}_assym.h
>-	${CC} -c -x assembler-with-cpp -DLOCORE ${CFLAGS} \
>+linux${SFX}_locore.o: linux${SFX}_assym.h assym.s
>+	${CC} -x assembler-with-cpp -DLOCORE -m32 -shared -s			\
>+	-pipe -I. -I${SYSDIR} -Werror -Wall -fno-common -nostdinc -nostdlib	\
>+	-fno-omit-frame-pointer							\
>+	-Wl,-T${.CURDIR}/../../${MACHINE_CPUARCH}/linux${SFX}/${VDSO}.lds.s	\
>+	-Wl,-soname=${VDSO}.so.1,--eh-frame-hdr,-fPIC,-warn-common		\
> 	    ${.IMPSRC} -o ${.TARGET}
> 
>-linux${SFX}_support.o: linux${SFX}_support.s assym.s linux${SFX}_assym.h
>+linux${SFX}_support.o: linux${SFX}_assym.h assym.s
> 	${CC} -c -x assembler-with-cpp -DLOCORE ${CFLAGS} \
> 	    ${.IMPSRC} -o ${.TARGET}
> 
>-linux${SFX}_genassym.o: linux${SFX}_genassym.c linux.h @ machine x86
>+.if ${MACHINE_CPUARCH} == "amd64"
>+${VDSO}.so: linux${SFX}_locore.o
>+	${OBJCOPY} --input binary --output elf64-x86-64-freebsd			\
>+	    --binary-architecture i386 linux${SFX}_locore.o ${.TARGET}
>+.else
>+${VDSO}.so: linux${SFX}_locore.o
>+	${OBJCOPY} --input binary --output elf32-i386-freebsd			\
>+	    --binary-architecture i386 linux${SFX}_locore.o ${.TARGET}
>+.endif
>+
>+linux${SFX}_genassym.o:
> 	${CC} -c ${CFLAGS:N-fno-common} ${.IMPSRC}
> 
> .if !defined(KERNBUILDDIR)
>-opt_inet6.h:
>-	echo "#define INET6 1" > ${.TARGET}
> .if defined(KTR)
> CFLAGS+=	-DKTR
> .endif
>+.if defined(DEBUG)
>+CFLAGS+=	-DDEBUG
> .endif
>+.if defined(DEBUG)
>+CFLAGS+=	-DDEBUG
>+.endif
>+.endif
> 
> .include <bsd.kmod.mk>
>Index: sys/modules/linux64/Makefile
>===================================================================
>--- sys/modules/linux64/Makefile	(revision 0)
>+++ sys/modules/linux64/Makefile	(working copy)
>@@ -0,0 +1,55 @@
>+# $FreeBSD$
>+
>+.PATH: ${.CURDIR}/../../compat/linux ${.CURDIR}/../../${MACHINE_ARCH}/linux
>+
>+VDSO=	linux_vdso
>+
>+KMOD=	linux64
>+SRCS=	linux_fork.c linux_dummy.c linux_file.c linux_event.c \
>+	linux_futex.c linux_getcwd.c linux_ioctl.c linux_ipc.c \
>+	linux_machdep.c linux_misc.c linux_signal.c \
>+	linux_socket.c linux_stats.c linux_sysctl.c linux_sysent.c \
>+	linux_sysvec.c linux_time.c linux_vdso.c linux_timer.c \
>+	opt_inet6.h opt_compat.h opt_kdtrace.h opt_posix.h opt_usb.h \
>+	vnode_if.h device_if.h bus_if.h assym.s \
>+	linux_support.s
>+DPSRCS=	linux_genassym.c
>+
>+# XXX: for assym.s
>+SRCS+=  opt_kstack_pages.h opt_nfs.h opt_apic.h opt_hwpmc_hooks.h
>+
>+CLEANFILES=	linux_assym.h linux_genassym.o linux_locore.o
>+
>+OBJS=	${VDSO}.so
>+
>+linux_assym.h: linux_genassym.o
>+	sh ${SYSDIR}/kern/genassym.sh linux_genassym.o > ${.TARGET}
>+
>+linux_locore.o: linux_locore.s linux_assym.h
>+	${CC} -x assembler-with-cpp -DLOCORE -shared -mcmodel=small	\
>+	-pipe -I. -I${SYSDIR} -Werror -Wall -fno-common -nostdinc 	\
>+	-Wl,-T${.CURDIR}/../../${MACHINE_CPUARCH}/linux/${VDSO}.lds.s	\
>+	-Wl,-soname=${VDSO}.so.1,-fPIC,-warn-common -nostdlib		\
>+	    ${.IMPSRC} -o ${.TARGET}
>+
>+${VDSO}.so: linux_locore.o
>+	${OBJCOPY} --input binary --output elf64-x86-64-freebsd		\
>+	    -S -g --binary-architecture i386:x86-64 linux_locore.o ${.TARGET}
>+
>+linux_support.o: assym.s linux_assym.h
>+	${CC} -c -x assembler-with-cpp -DLOCORE ${CFLAGS} \
>+	    ${.IMPSRC} -o ${.TARGET}
>+
>+linux_genassym.o:
>+	${CC} -c ${CFLAGS:N-fno-common} ${.IMPSRC}
>+
>+.if !defined(KERNBUILDDIR)
>+.if defined(DEBUG)
>+CFLAGS+=-DDEBUG
>+.endif
>+.if defined(KTR)
>+CFLAGS+=-DKTR
>+.endif
>+.endif
>+
>+.include <bsd.kmod.mk>
>Index: sys/modules/linux_common/Makefile
>===================================================================
>--- sys/modules/linux_common/Makefile	(revision 0)
>+++ sys/modules/linux_common/Makefile	(working copy)
>@@ -0,0 +1,25 @@
>+# $FreeBSD$
>+
>+.PATH: ${.CURDIR}/../../compat/linux
>+
>+KMOD=	linux_common
>+SRCS=	linux_common.c linux_mib.c linux_util.c linux_emul.c \
>+	linux.c opt_compat.h device_if.h vnode_if.h bus_if.h
>+
>+EXPORT_SYMS=
>+EXPORT_SYMS+=	linux_emul_path
>+EXPORT_SYMS+=	linux_ioctl_register_handler
>+EXPORT_SYMS+=	linux_ioctl_unregister_handler
>+EXPORT_SYMS+=	linux_get_osname
>+EXPORT_SYMS+=	linux_get_osrelease
>+
>+.if !defined(KERNBUILDDIR)
>+.if defined(DEBUG)
>+CFLAGS+=-DDEBUG
>+.endif
>+.if defined(KTR)
>+CFLAGS+=-DKTR
>+.endif
>+.endif
>+
>+.include <bsd.kmod.mk>
>Index: sys/modules/pseudofs/Makefile
>===================================================================
>--- sys/modules/pseudofs/Makefile	(revision 285633)
>+++ sys/modules/pseudofs/Makefile	(working copy)
>@@ -23,4 +23,10 @@
> 		pfs_enable	\
> 		pfs_destroy
> 
>+.if !defined(KERNBUILDDIR)
>+.if defined(PSEUDOFS_TRACE)
>+CFLAGS+=-DPSEUDOFS_TRACE
>+.endif
>+.endif
>+
> .include <bsd.kmod.mk>
>Index: sys/powerpc/powerpc/elf32_machdep.c
>===================================================================
>--- sys/powerpc/powerpc/elf32_machdep.c	(revision 285633)
>+++ sys/powerpc/powerpc/elf32_machdep.c	(working copy)
>@@ -107,6 +107,7 @@
> 	.sv_shared_page_base = FREEBSD32_SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(elf32_sysvec, &elf32_freebsd_sysvec);
> 
>Index: sys/powerpc/powerpc/elf64_machdep.c
>===================================================================
>--- sys/powerpc/powerpc/elf64_machdep.c	(revision 285633)
>+++ sys/powerpc/powerpc/elf64_machdep.c	(working copy)
>@@ -83,6 +83,7 @@
> 	.sv_shared_page_base = SHAREDPAGE,
> 	.sv_shared_page_len = PAGE_SIZE,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> INIT_SYSENTVEC(elf64_sysvec, &elf64_freebsd_sysvec);
> 
>Index: sys/powerpc/powerpc/exec_machdep.c
>===================================================================
>--- sys/powerpc/powerpc/exec_machdep.c	(revision 285633)
>+++ sys/powerpc/powerpc/exec_machdep.c	(working copy)
>@@ -231,12 +231,6 @@
> 	}
> 
> 	/*
>-	 * Translate the signal if appropriate (Linux emu ?)
>-	 */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
>-	/*
> 	 * Save the floating-point state, if necessary, then copy it.
> 	 */
> 	/* XXX */
>Index: sys/sparc64/sparc64/elf_machdep.c
>===================================================================
>--- sys/sparc64/sparc64/elf_machdep.c	(revision 285633)
>+++ sys/sparc64/sparc64/elf_machdep.c	(working copy)
>@@ -87,6 +87,7 @@
> 	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
> 	.sv_syscallnames = syscallnames,
> 	.sv_schedtail	= NULL,
>+	.sv_trap	= NULL,
> };
> 
> static Elf64_Brandinfo freebsd_brand_info = {
>Index: sys/sparc64/sparc64/machdep.c
>===================================================================
>--- sys/sparc64/sparc64/machdep.c	(revision 285633)
>+++ sys/sparc64/sparc64/machdep.c	(working copy)
>@@ -658,10 +658,6 @@
> 
> 	fp = (struct frame *)sfp - 1;
> 
>-	/* Translate the signal if appropriate. */
>-	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
>-		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
>-
> 	/* Build the argument list for the signal handler. */
> 	tf->tf_out[0] = sig;
> 	tf->tf_out[2] = (register_t)&sfp->sf_uc;
>Index: sys/sys/file.h
>===================================================================
>--- sys/sys/file.h	(revision 285633)
>+++ sys/sys/file.h	(working copy)
>@@ -65,6 +65,7 @@
> #define	DTYPE_PTS	10	/* pseudo teletype master device */
> #define	DTYPE_DEV	11	/* Device specific fd type */
> #define	DTYPE_PROCDESC	12	/* process descriptor */
>+#define	DTYPE_LINUXEFD	13	/* emulation eventfd type */
> 
> #ifdef _KERNEL
> 
>Index: sys/sys/filedesc.h
>===================================================================
>--- sys/sys/filedesc.h	(revision 285633)
>+++ sys/sys/filedesc.h	(working copy)
>@@ -156,6 +156,8 @@
> int	fdcheckstd(struct thread *td);
> void	fdclose(struct filedesc *fdp, struct file *fp, int idx, struct thread *td);
> void	fdcloseexec(struct thread *td);
>+void	fddrop(struct filedesc *fdp);
>+struct	filedesc *fdhold(struct proc *p);
> struct	filedesc *fdcopy(struct filedesc *fdp);
> void	fdunshare(struct thread *td);
> void	fdescfree(struct thread *td);
>Index: sys/sys/proc.h
>===================================================================
>--- sys/sys/proc.h	(revision 285633)
>+++ sys/sys/proc.h	(working copy)
>@@ -148,6 +148,8 @@
>  *      q - td_contested lock
>  *      r - p_peers lock
>  *      t - thread lock
>+ *	u - process stat lock
>+ *	w - process timer lock
>  *      x - created at fork, only changes during single threading in exec
>  *      y - created at first aio, doesn't change until exit or exec at which
>  *          point we are single-threaded and only curthread changes it
>@@ -183,14 +185,14 @@
>  * userland asks for rusage info.  Backwards compatibility prevents putting
>  * this directly in the user-visible rusage struct.
>  *
>- * Locking for p_rux: (cj) means (j) for p_rux and (c) for p_crux.
>+ * Locking for p_rux: (cu) means (u) for p_rux and (c) for p_crux.
>  * Locking for td_rux: (t) for all fields.
>  */
> struct rusage_ext {
>-	uint64_t	rux_runtime;    /* (cj) Real time. */
>-	uint64_t	rux_uticks;     /* (cj) Statclock hits in user mode. */
>-	uint64_t	rux_sticks;     /* (cj) Statclock hits in sys mode. */
>-	uint64_t	rux_iticks;     /* (cj) Statclock hits in intr mode. */
>+	uint64_t	rux_runtime;    /* (cu) Real time. */
>+	uint64_t	rux_uticks;     /* (cu) Statclock hits in user mode. */
>+	uint64_t	rux_sticks;     /* (cu) Statclock hits in sys mode. */
>+	uint64_t	rux_iticks;     /* (cu) Statclock hits in intr mode. */
> 	uint64_t	rux_uu;         /* (c) Previous user time in usec. */
> 	uint64_t	rux_su;         /* (c) Previous sys time in usec. */
> 	uint64_t	rux_tu;         /* (c) Previous total time in usec. */
>@@ -320,6 +322,7 @@
> 	struct vm_page	**td_ma;	/* (k) uio pages held */
> 	int		td_ma_cnt;	/* (k) size of *td_ma */
> 	void		*td_su;		/* (k) FFS SU private */
>+	void		*td_emuldata;	/* Emulator state data */
> };
> 
> struct mtx *thread_lock_block(struct thread *);
>@@ -509,6 +512,9 @@
> 	LIST_ENTRY(proc) p_sibling;	/* (e) List of sibling processes. */
> 	LIST_HEAD(, proc) p_children;	/* (e) Pointer to list of children. */
> 	struct mtx	p_mtx;		/* (n) Lock for this struct. */
>+	struct mtx	p_statmtx;	/* Lock for the stats */
>+	struct mtx	p_itimmtx;	/* Lock for the virt/prof timers */
>+	struct mtx	p_profmtx;	/* Lock for the profiling */
> 	struct ksiginfo *p_ksi;	/* Locked by parent proc lock */
> 	sigqueue_t	p_sigqueue;	/* (c) Sigs not delivered to a td. */
> #define p_siglist	p_sigqueue.sq_signals
>@@ -520,7 +526,7 @@
> 	u_int		p_swtick;	/* (c) Tick when swapped in or out. */
> 	struct itimerval p_realtimer;	/* (c) Alarm timer. */
> 	struct rusage	p_ru;		/* (a) Exit information. */
>-	struct rusage_ext p_rux;	/* (cj) Internal resource usage. */
>+	struct rusage_ext p_rux;	/* (cu) Internal resource usage. */
> 	struct rusage_ext p_crux;	/* (c) Internal child resource usage. */
> 	int		p_profthreads;	/* (c) Num threads in addupc_task. */
> 	volatile int	p_exitthreads;	/* (j) Number of threads exiting */
>@@ -612,6 +618,18 @@
> #define	PROC_SUNLOCK(p)	mtx_unlock_spin(&(p)->p_slock)
> #define	PROC_SLOCK_ASSERT(p, type)	mtx_assert(&(p)->p_slock, (type))
> 
>+#define	PROC_STATLOCK(p)	mtx_lock_spin(&(p)->p_statmtx)
>+#define	PROC_STATUNLOCK(p)	mtx_unlock_spin(&(p)->p_statmtx)
>+#define	PROC_STATLOCK_ASSERT(p, type)	mtx_assert(&(p)->p_statmtx, (type))
>+
>+#define	PROC_ITIMLOCK(p)	mtx_lock_spin(&(p)->p_itimmtx)
>+#define	PROC_ITIMUNLOCK(p)	mtx_unlock_spin(&(p)->p_itimmtx)
>+#define	PROC_ITIMLOCK_ASSERT(p, type)	mtx_assert(&(p)->p_itimmtx, (type))
>+
>+#define	PROC_PROFLOCK(p)	mtx_lock_spin(&(p)->p_profmtx)
>+#define	PROC_PROFUNLOCK(p)	mtx_unlock_spin(&(p)->p_profmtx)
>+#define	PROC_PROFLOCK_ASSERT(p, type)	mtx_assert(&(p)->p_profmtx, (type))
>+
> /* These flags are kept in p_flag. */
> #define	P_ADVLOCK	0x00001	/* Process may hold a POSIX advisory lock. */
> #define	P_CONTROLT	0x00002	/* Has a controlling terminal. */
>Index: sys/sys/resourcevar.h
>===================================================================
>--- sys/sys/resourcevar.h	(revision 285633)
>+++ sys/sys/resourcevar.h	(working copy)
>@@ -47,21 +47,22 @@
>  * Locking key:
>  *      b - created at fork, never changes
>  *      c - locked by proc mtx
>- *      j - locked by proc slock
>  *      k - only accessed by curthread
>+ *      w - locked by proc itim lock
>+ *	w2 - locked by proc prof lock
>  */
> struct pstats {
> #define	pstat_startzero	p_cru
> 	struct	rusage p_cru;		/* Stats for reaped children. */
>-	struct	itimerval p_timer[3];	/* (j) Virtual-time timers. */
>+	struct	itimerval p_timer[3];	/* (w) Virtual-time timers. */
> #define	pstat_endzero	pstat_startcopy
> 
> #define	pstat_startcopy	p_prof
> 	struct uprof {			/* Profile arguments. */
>-		caddr_t	pr_base;	/* (c + j) Buffer base. */
>-		u_long	pr_size;	/* (c + j) Buffer size. */
>-		u_long	pr_off;		/* (c + j) PC offset. */
>-		u_long	pr_scale;	/* (c + j) PC scaling. */
>+		caddr_t	pr_base;	/* (c + w2) Buffer base. */
>+		u_long	pr_size;	/* (c + w2) Buffer size. */
>+		u_long	pr_off;		/* (c + w2) PC offset. */
>+		u_long	pr_scale;	/* (c + w2) PC scaling. */
> 	} p_prof;
> #define	pstat_endcopy	p_start
> 	struct	timeval p_start;	/* (b) Starting time. */
>Index: sys/sys/syscallsubr.h
>===================================================================
>--- sys/sys/syscallsubr.h	(revision 285633)
>+++ sys/sys/syscallsubr.h	(working copy)
>@@ -55,6 +55,7 @@
> struct sockaddr;
> struct stat;
> struct thr_param;
>+struct sched_param;
> struct __wrusage;
> 
> int	kern___getcwd(struct thread *td, char *buf, enum uio_seg bufseg,
>@@ -125,6 +126,10 @@
> int	kern_jail_set(struct thread *td, struct uio *options, int flags);
> int	kern_kevent(struct thread *td, int fd, int nchanges, int nevents,
> 	    struct kevent_copyops *k_ops, const struct timespec *timeout);
>+int	kern_kevent_fp(struct thread *td, struct file *fp, int nchanges,
>+	    int nevents, struct kevent_copyops *k_ops,
>+	    const struct timespec *timeout);
>+int	kern_kqueue(struct thread *td, int flags);
> int	kern_kldload(struct thread *td, const char *file, int *fileid);
> int	kern_kldstat(struct thread *td, int fileid, struct kld_file_stat *stat);
> int	kern_kldunload(struct thread *td, int fileid, int flags);
>@@ -193,8 +198,18 @@
> int	kern_rmdir(struct thread *td, char *path, enum uio_seg pathseg);
> int	kern_rmdirat(struct thread *td, int fd, char *path,
> 	    enum uio_seg pathseg);
>+int	kern_sched_getparam(struct thread *td, struct thread *targettd,
>+	    struct sched_param *param);
>+int	kern_sched_getscheduler(struct thread *td, struct thread *targettd,
>+	    int *policy);
>+int	kern_sched_setparam(struct thread *td, struct thread *targettd,
>+	    struct sched_param *param);
>+int	kern_sched_setscheduler(struct thread *td, struct thread *targettd,
>+	    int policy, struct sched_param *param);
> int	kern_sched_rr_get_interval(struct thread *td, pid_t pid,
> 	    struct timespec *ts);
>+int	kern_sched_rr_get_interval_td(struct thread *td, struct thread *targettd,
>+	    struct timespec *ts);
> int	kern_semctl(struct thread *td, int semid, int semnum, int cmd,
> 	    union semun *arg, register_t *rval);
> int	kern_select(struct thread *td, int nd, fd_set *fd_in, fd_set *fd_ou,
>@@ -244,6 +259,8 @@
> int	kern_ktimer_gettime(struct thread *td, int timer_id,
> 	    struct itimerspec *val);
> int	kern_ktimer_getoverrun(struct thread *td, int timer_id);
>+int	kern_thr_alloc(struct proc *, int pages, struct thread **);
>+int	kern_thr_exit(struct thread *td);
> int	kern_thr_new(struct thread *td, struct thr_param *param);
> int	kern_thr_suspend(struct thread *td, struct timespec *tsp);
> int	kern_truncate(struct thread *td, char *path, enum uio_seg pathseg,
>Index: sys/sys/sysent.h
>===================================================================
>--- sys/sys/sysent.h	(revision 285633)
>+++ sys/sys/sysent.h	(working copy)
>@@ -130,6 +130,8 @@
> 	uint32_t	sv_timekeep_gen;
> 	void		*sv_shared_page_obj;
> 	void		(*sv_schedtail)(struct thread *);
>+	void		(*sv_thread_detach)(struct thread *);
>+	int		(*sv_trap)(struct thread *, struct trapframe *);
> };
> 
> #define	SV_ILP32	0x000100
>@@ -138,9 +140,11 @@
> #define	SV_AOUT		0x008000
> #define	SV_SHP		0x010000
> 
>+#define	SV_IS_MASK	0x007f00
> #define	SV_ABI_MASK	0xff
> #define	SV_PROC_FLAG(p, x)	((p)->p_sysent->sv_flags & (x))
> #define	SV_PROC_ABI(p)		((p)->p_sysent->sv_flags & SV_ABI_MASK)
>+#define	SV_PROC_IS(p)		((p)->p_sysent->sv_flags & SV_IS_MASK)
> #define	SV_CURPROC_FLAG(x)	SV_PROC_FLAG(curproc, x)
> #define	SV_CURPROC_ABI()	SV_PROC_ABI(curproc)
> /* same as ELFOSABI_XXX, to prevent header pollution */
>Index: usr.bin/kdump/Makefile
>===================================================================
>--- usr.bin/kdump/Makefile	(revision 285633)
>+++ usr.bin/kdump/Makefile	(working copy)
>@@ -3,10 +3,6 @@
> 
> .include <bsd.own.mk>
> 
>-.if (${MACHINE_ARCH} == "amd64")
>-SFX=		32
>-.endif
>-
> .PATH: ${.CURDIR}/../ktrace
> 
> PROG=		kdump
>@@ -25,6 +21,9 @@
> .if (${MACHINE_ARCH} == "amd64" || ${MACHINE_ARCH} == "i386")
> CLEANFILES+=	linux_syscalls.c
> .endif
>+.if (${MACHINE_ARCH} == "amd64")
>+CLEANFILES+=	linux32_syscalls.c
>+.endif
> 
> ioctl.c: mkioctls
> 	env MACHINE=${MACHINE} CPP="${CPP}" \
>@@ -38,7 +37,11 @@
> 	sh ${.CURDIR}/mksubr ${DESTDIR}/usr/include >${.TARGET}
> .if (${MACHINE_ARCH} == "amd64" || ${MACHINE_ARCH} == "i386")
> 	sh ${.CURDIR}/../../sys/kern/makesyscalls.sh \
>-	    ${.CURDIR}/../../sys/${MACHINE_ARCH}/linux${SFX}/syscalls.master ${.CURDIR}/linux_syscalls.conf
>+	    ${.CURDIR}/../../sys/${MACHINE_ARCH}/linux/syscalls.master ${.CURDIR}/linux_syscalls.conf
> .endif
>+.if (${MACHINE_ARCH} == "amd64")
>+	sh ${.CURDIR}/../../sys/kern/makesyscalls.sh \
>+	    ${.CURDIR}/../../sys/${MACHINE_ARCH}/linux32/syscalls.master ${.CURDIR}/linux32_syscalls.conf
>+.endif
> 
> .include <bsd.prog.mk>
>Index: usr.bin/kdump/kdump.c
>===================================================================
>--- usr.bin/kdump/kdump.c	(revision 285633)
>+++ usr.bin/kdump/kdump.c	(working copy)
>@@ -139,8 +139,8 @@
> 
> #if defined(__amd64__) || defined(__i386__)
> 
>-void linux_ktrsyscall(struct ktr_syscall *);
>-void linux_ktrsysret(struct ktr_sysret *);
>+void linux_ktrsyscall(struct ktr_syscall *, u_int);
>+void linux_ktrsysret(struct ktr_sysret *, u_int);
> extern const char *linux_syscallnames[];
> 
> #include <linux_syscalls.c>
>@@ -165,6 +165,13 @@
> };
> #endif
> 
>+#if defined(__amd64__)
>+extern const char *linux32_syscallnames[];
>+#include <linux32_syscalls.c>
>+static int nlinux32_syscalls = sizeof(linux32_syscallnames) / \
>+				sizeof(linux32_syscallnames[0]);
>+#endif
>+
> struct proc_info
> {
> 	TAILQ_ENTRY(proc_info)	info;
>@@ -331,7 +338,8 @@
> 		case KTR_SYSCALL:
> #if defined(__amd64__) || defined(__i386__)
> 			if ((sv_flags & SV_ABI_MASK) == SV_ABI_LINUX)
>-				linux_ktrsyscall((struct ktr_syscall *)m);
>+				linux_ktrsyscall((struct ktr_syscall *)m,
>+				    sv_flags);
> 			else
> #endif
> 				ktrsyscall((struct ktr_syscall *)m, sv_flags);
>@@ -339,7 +347,8 @@
> 		case KTR_SYSRET:
> #if defined(__amd64__) || defined(__i386__)
> 			if ((sv_flags & SV_ABI_MASK) == SV_ABI_LINUX)
>-				linux_ktrsysret((struct ktr_sysret *)m);
>+				linux_ktrsysret((struct ktr_sysret *)m, 
>+				    sv_flags);
> 			else
> #endif
> 				ktrsysret((struct ktr_sysret *)m, sv_flags);
>@@ -1890,16 +1899,27 @@
> }
> 
> #if defined(__amd64__) || defined(__i386__)
>+
>+#if defined(__amd64__)
>+#define	NLINUX_SYSCALLS(v)		((v) & SV_ILP32 ?		\
>+	    nlinux32_syscalls : nlinux_syscalls)
>+#define	LINUX_SYSCALLNAMES(v, i)	((v) & SV_ILP32 ?		\
>+	    linux32_syscallnames[i] : linux_syscallnames[i])
>+#else
>+#define	NLINUX_SYSCALLS(v)		(nlinux_syscalls)
>+#define	LINUX_SYSCALLNAMES(v, i)	(linux_syscallnames[i])
>+#endif
>+
> void
>-linux_ktrsyscall(struct ktr_syscall *ktr)
>+linux_ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags)
> {
> 	int narg = ktr->ktr_narg;
> 	register_t *ip;
> 
>-	if (ktr->ktr_code >= nlinux_syscalls || ktr->ktr_code < 0)
>+	if (ktr->ktr_code >= NLINUX_SYSCALLS(sv_flags) || ktr->ktr_code < 0)
> 		printf("[%d]", ktr->ktr_code);
> 	else {
>-		printf("%s", linux_syscallnames[ktr->ktr_code]);
>+		printf("%s", LINUX_SYSCALLNAMES(sv_flags, ktr->ktr_code));
> 		if (syscallno)
> 			printf("[%d]", ktr->ktr_code);
> 	}
>@@ -1914,16 +1934,16 @@
> }
> 
> void
>-linux_ktrsysret(struct ktr_sysret *ktr)
>+linux_ktrsysret(struct ktr_sysret *ktr, u_int sv_flags)
> {
> 	register_t ret = ktr->ktr_retval;
> 	int error = ktr->ktr_error;
> 	int code = ktr->ktr_code;
> 
>-	if (code >= nlinux_syscalls || code < 0)
>+	if (code >= NLINUX_SYSCALLS(sv_flags) || code < 0)
> 		printf("[%d] ", code);
> 	else {
>-		printf("%s", linux_syscallnames[code]);
>+		printf("%s ", LINUX_SYSCALLNAMES(sv_flags, code));
> 		if (syscallno)
> 			printf("[%d]", code);
> 		printf(" ");
>Index: usr.bin/kdump/linux32_syscalls.conf
>===================================================================
>--- usr.bin/kdump/linux32_syscalls.conf	(revision 0)
>+++ usr.bin/kdump/linux32_syscalls.conf	(working copy)
>@@ -0,0 +1,11 @@
>+# $FreeBSD$
>+sysnames="linux32_syscalls.c"
>+sysproto="/dev/null"
>+sysproto_h=_LINUX32_SYSPROTO_H_
>+syshdr="/dev/null"
>+syssw="/dev/null"
>+sysmk="/dev/null"
>+syscallprefix="LINUX32_SYS_"
>+switchname="/dev/null"
>+namesname="linux32_syscallnames"
>+systrace="/dev/null"

Actions: View | Diff

Attachments on bug 201299: 158638 | 158849 | 158855 | 162629