FreeBSD Bugzilla – Attachment 158855 Details for
Bug 201299
Merge Linux Emulation (lemul) to stable/10 branch for 10.2-RELEASE
Home
|
New
|
Browse
|
Search
|
[?]
|
Reports
|
Help
|
New Account
|
Log In
Remember
[x]
|
Forgot Password
Login:
[x]
[patch]
patch: fixed and rerolled with svn
lemul-10-rerolled.diff (text/plain), 819.52 KB, created by
Nikolai Lifanov
on 2015-07-16 15:39:53 UTC
(
hide
)
Description:
patch: fixed and rerolled with svn
Filename:
MIME Type:
Creator:
Nikolai Lifanov
Created:
2015-07-16 15:39:53 UTC
Size:
819.52 KB
patch
obsolete
>Index: sys/amd64/amd64/elf_machdep.c >=================================================================== >--- sys/amd64/amd64/elf_machdep.c (revision 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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, <imeout, 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, <imeout); >+ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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(<s, &ts); >+ return (copyout(<s, 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, <s, sizeof(lts)); >+ if (error) >+ return (error); >+ error = linux_to_native_timespec(&uts, <s); >+ 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(<s, &uts); >+ error = copyout(<s, 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, <s, sizeof(lts)); >+ if (error) >+ return (error); >+ error = linux_to_native_timespec(&uts, <s); >+ 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(<s, &uts); >+ error = copyout(<s, 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 = <mvl; >+ 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, <s, sizeof(struct l_timespec)); >+ if (error != 0) >+ return (error); >+ error = linux_to_native_timespec(&ts, <s); >+ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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.amd64 >=================================================================== >--- sys/conf/files.amd64 (revision 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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 285634) >+++ 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"
<b>You cannot view the attachment while viewing its details because your browser does not support IFRAMEs. <a href="attachment.cgi?id=158855">View the attachment on a separate page</a>.</b>
View Attachment As Diff
View Attachment As Raw
Actions:
View
|
Diff
Attachments on
bug 201299
:
158638
|
158849
| 158855 |
162629