Index: sys/amd64/linux/Makefile =================================================================== --- /dev/null +++ sys/amd64/linux/Makefile @@ -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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux.h @@ -0,0 +1,671 @@ +/*- + * 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 + +/* + * 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 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 17 /* 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; +}; + +/* + * 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 64 +#define LINUX_NBPW 64 +#define LINUX_NSIG_WORDS (LINUX_NSIG / LINUX_NBPW) + +/* 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 + +/* primitives to manipulate sigset_t */ + +#define LINUX_SIGEMPTYSET(set) \ + do { \ + (set).__bits[0] = 0; \ + } while(0) + +#define LINUX_SIGISMEMBER(set, sig) \ + (1UL & ((set).__bits[0] >> _SIG_IDX(sig))) + +#define LINUX_SIGADDSET(set, sig) \ + (set).__bits[0] = 1UL << _SIG_IDX(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 struct { + l_ulong __bits[LINUX_NSIG_WORDS]; +} l_sigset_t; + +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; +}; + +/* + * 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_RDLCK 0 +#define LINUX_F_WRLCK 1 +#define LINUX_F_UNLCK 2 + +/* + * 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_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; + 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_CLOCK_REALTIME 0 +#define LINUX_CLOCK_MONOTONIC 1 +#define LINUX_CLOCK_PROCESS_CPUTIME_ID 2 +#define LINUX_CLOCK_THREAD_CPUTIME_ID 3 +#define LINUX_CLOCK_REALTIME_HR 4 +#define LINUX_CLOCK_MONOTONIC_HR 5 + + +#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_ */ \ No newline at end of file Index: sys/amd64/linux/linux_dummy.c =================================================================== --- /dev/null +++ sys/amd64/linux/linux_dummy.c @@ -0,0 +1,154 @@ +/*- + * 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 +__FBSDID("$FreeBSD$"); + +#include "opt_compat.h" +#include "opt_kdtrace.h" + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +/* 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_create); +DUMMY(epoll_ctl_old); +DUMMY(epoll_wait_old); +DUMMY(remap_file_pages); +DUMMY(semtimedop); +DUMMY(epoll_ctl); +DUMMY(epoll_wait); +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(ppoll); +DUMMY(unshare); +DUMMY(splice); +DUMMY(tee); +DUMMY(sync_file_range); +DUMMY(vmsplice); +DUMMY(move_pages); +DUMMY(utimensat); +DUMMY(epoll_pwait); +DUMMY(signalfd); +DUMMY(timerfd); +DUMMY(eventfd); +DUMMY(fallocate); +DUMMY(timerfd_settime); +DUMMY(timerfd_gettime); +DUMMY(signalfd4); +DUMMY(eventfd2); +DUMMY(epoll_create1); +DUMMY(inotify_init1); +DUMMY(preadv); +DUMMY(pwritev); +DUMMY(rt_tsigqueueinfo); +DUMMY(perf_event_open); +DUMMY(recvmmsg); +DUMMY(fanotify_init); +DUMMY(fanotify_mark); +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); +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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_genassym.c @@ -0,0 +1,15 @@ +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include + +#include +#include + +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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_ipc64.h @@ -0,0 +1,142 @@ +/*- + * Copyright (c) 2002 Maxim Sobolev + * 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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_locore.s @@ -0,0 +1,123 @@ +/* $FreeBSD$ */ + +#include "linux_assym.h" /* system definitions */ +#include /* miscellaneous asm macros */ + +#include /* 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 + + + .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 + + +#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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_machdep.c @@ -0,0 +1,585 @@ +/*- + * 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 +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +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; + 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); +} + +void +linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss) +{ + int b, l; + + SIGEMPTYSET(*bss); + for (l = 1; l <= LINUX_NSIG; l++) { + if (LINUX_SIGISMEMBER(*lss, l)) { + if (l <= LINUX_SIGTBLSZ) + b = linux_to_bsd_signal[_SIG_IDX(l)]; + else + b = 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 <= LINUX_NSIG; b++) { + if (SIGISMEMBER(*bss, b)) { + if (b <= LINUX_SIGTBLSZ) + l = bsd_to_linux_signal[_SIG_IDX(b)]; + else + l = b; + if (l) + LINUX_SIGADDSET(*lss, l); + } + } +} + +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 + + options = (args->options & (WNOHANG | WUNTRACED)); + /* WLINUXCLONE should be equal to __WCLONE, but we make sure */ + if (args->options & __WCLONE) + options |= WLINUXCLONE; + + 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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_proto.h @@ -0,0 +1,1636 @@ +/* + * System call prototypes. + * + * DO NOT EDIT-- this file is automatically generated. + * $FreeBSD$ + * created from FreeBSD + */ + +#ifndef _LINUX_SYSPROTO_H_ +#define _LINUX_SYSPROTO_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include + +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_uint *)]; l_uint * status; char status_r_[PADR_(l_uint *)]; + 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 { + register_t dummy; +}; +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 { + register_t dummy; +}; +struct linux_epoll_ctl_args { + register_t dummy; +}; +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)]; + char flag_l_[PADL_(l_int)]; l_int flag; char flag_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 { + register_t dummy; +}; +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 { + register_t dummy; +}; +struct linux_epoll_pwait_args { + register_t dummy; +}; +struct linux_signalfd_args { + register_t dummy; +}; +struct linux_timerfd_args { + register_t dummy; +}; +struct linux_eventfd_args { + register_t dummy; +}; +struct linux_fallocate_args { + register_t dummy; +}; +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 { + register_t dummy; +}; +struct linux_epoll_create1_args { + register_t dummy; +}; +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 { + register_t dummy; +}; +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 { + register_t dummy; +}; +struct linux_sendmmsg_args { + register_t dummy; +}; +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_NULL +#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_NULL +#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_NULL +#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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_support.s @@ -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 /* 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 + xchgq %rdi,(%rsi) + movq %rdi,(%rdx) + xorq %rax,%rax + 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 + xaddq %rdi,(%rsi) + movq %rdi,(%rdx) + xorq %rax,%rax + 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 + movq (%rsi),%rax +1: movq %rax,%rcx + orq %rdi,%rcx +#ifdef SMP + lock +#endif + cmpxchgq %rcx,(%rsi) + jnz 1b + movq %rax,(%rdx) + xorq %rax,%rax + 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 + movq (%rsi),%rax +1: movq %rax,%rcx + andq %rdi,%rcx +#ifdef SMP + lock +#endif + cmpxchgq %rcx,(%rsi) + jnz 1b + movq %rax,(%rdx) + xorq %rax,%rax + 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 + movq (%rsi),%rax +1: movq %rax,%rcx + xorq %rdi,%rcx +#ifdef SMP + lock +#endif + cmpxchgq %rcx,(%rsi) + jnz 1b + movq %rax,(%rdx) + xorq %rax,%rax + movq %rax,PCB_ONFAULT(%r8) + ret Index: sys/amd64/linux/linux_syscall.h =================================================================== --- /dev/null +++ sys/amd64/linux/linux_syscall.h @@ -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 313 Index: sys/amd64/linux/linux_syscalls.c =================================================================== --- /dev/null +++ sys/amd64/linux/linux_syscalls.c @@ -0,0 +1,324 @@ +/* + * 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 */ +}; Index: sys/amd64/linux/linux_sysent.c =================================================================== --- /dev/null +++ sys/amd64/linux/linux_sysent.c @@ -0,0 +1,334 @@ +/* + * System call switch table. + * + * DO NOT EDIT-- this file is automatically generated. + * $FreeBSD$ + * created from FreeBSD + */ + +#include +#include +#include +#include +#include +#include + +#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 */ + { 0, (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 */ + { 0, (sy_call_t *)linux_epoll_wait, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 232 = linux_epoll_wait */ + { 0, (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 */ + { 0, (sy_call_t *)linux_ppoll, AUE_NULL, 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 */ + { 0, (sy_call_t *)linux_utimensat, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 280 = linux_utimensat */ + { 0, (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 */ + { 0, (sy_call_t *)linux_eventfd, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 284 = linux_eventfd */ + { 0, (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 */ + { 0, (sy_call_t *)linux_eventfd2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 290 = linux_eventfd2 */ + { 0, (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 */ + { 0, (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 */ + { 0, (sy_call_t *)linux_syncfs, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 306 = linux_syncfs */ + { 0, (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 */ +}; Index: sys/amd64/linux/linux_systrace_args.c =================================================================== --- /dev/null +++ sys/amd64/linux/linux_systrace_args.c @@ -0,0 +1,6621 @@ +/* + * 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_uint * */ + 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: { + *n_args = 0; + 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: { + *n_args = 0; + break; + } + /* linux_epoll_ctl */ + case 233: { + *n_args = 0; + 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 */ + iarg[3] = p->flag; /* l_int */ + *n_args = 4; + 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: { + *n_args = 0; + 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: { + *n_args = 0; + break; + } + /* linux_epoll_pwait */ + case 281: { + *n_args = 0; + break; + } + /* linux_signalfd */ + case 282: { + *n_args = 0; + break; + } + /* linux_timerfd */ + case 283: { + *n_args = 0; + break; + } + /* linux_eventfd */ + case 284: { + *n_args = 0; + break; + } + /* linux_fallocate */ + case 285: { + *n_args = 0; + 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: { + *n_args = 0; + break; + } + /* linux_epoll_create1 */ + case 291: { + *n_args = 0; + 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: { + *n_args = 0; + 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: { + *n_args = 0; + break; + } + /* linux_sendmmsg */ + case 307: { + *n_args = 0; + 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_uint *"; + 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: + 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: + break; + /* linux_epoll_ctl */ + case 233: + 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; + case 3: + 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: + 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: + break; + /* linux_epoll_pwait */ + case 281: + break; + /* linux_signalfd */ + case 282: + break; + /* linux_timerfd */ + case 283: + break; + /* linux_eventfd */ + case 284: + break; + /* linux_fallocate */ + case 285: + 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: + break; + /* linux_epoll_create1 */ + case 291: + 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: + 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: + break; + /* linux_sendmmsg */ + case 307: + 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: + /* 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: + /* linux_epoll_ctl */ + case 233: + /* 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: + /* 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: + /* linux_epoll_pwait */ + case 281: + /* linux_signalfd */ + case 282: + /* linux_timerfd */ + case 283: + /* linux_eventfd */ + case 284: + /* linux_fallocate */ + case 285: + /* 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: + /* linux_epoll_create1 */ + case 291: + /* 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: + /* 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: + /* linux_sendmmsg */ + case 307: + /* 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 =================================================================== --- /dev/null +++ sys/amd64/linux/linux_sysvec.c @@ -0,0 +1,942 @@ +/*- + * 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 +__FBSDID("$FreeBSD$"); + +#include "opt_compat.h" + +#define __ELF_WORD_SIZE 64 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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); + +/* + * 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 +}; + +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 */ + 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)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) { + PROC_LOCK(p); + sigexit(td, SIGILL); + } 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)); + 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; + struct proc *p; + + /* + * Calculate string base and vector table pointers. + */ + p = imgp->proc; + arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings; + destp = (caddr_t)arginfo - SPARE_USRSPACE - + roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *)); + + /* + * 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 if appropriate. */ + 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); +} + +struct sysentvec elf_linux_sysvec = { + .sv_size = LINUX_SYS_MAXSYSCALL, + .sv_table = linux_sysent, + .sv_mask = 0, + .sv_sigsize = LINUX_SIGTBLSZ, + .sv_sigtbl = bsd_to_linux_signal, + .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 +}; + +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); \ No newline at end of file Index: sys/amd64/linux/linux_vdso.lds.s =================================================================== --- /dev/null +++ sys/amd64/linux/linux_vdso.lds.s @@ -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 =================================================================== --- /dev/null +++ sys/amd64/linux/syscalls.conf @@ -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 =================================================================== --- /dev/null +++ sys/amd64/linux/syscalls.master @@ -0,0 +1,503 @@ + $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 +#include +#include +#include +#include +#include + +; 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_uint *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(void); } +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(void); } +233 AUE_NULL STD { int linux_epoll_ctl(void); } +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, l_int flag); } +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_NULL STD { int linux_ppoll(void); } +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_NULL STD { int linux_utimensat(void); } +281 AUE_NULL STD { int linux_epoll_pwait(void); } +282 AUE_NULL STD { int linux_signalfd(void); } +283 AUE_NULL STD { int linux_timerfd(void); } +284 AUE_NULL STD { int linux_eventfd(void); } +285 AUE_NULL STD { int linux_fallocate(void); } +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(void); } +291 AUE_NULL STD { int linux_epoll_create1(void); } +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(void); } +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_NULL STD { int linux_syncfs(void); } +307 AUE_NULL STD { int linux_sendmmsg(void); } +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); } Index: sys/modules/linux64/Makefile =================================================================== --- /dev/null +++ sys/modules/linux64/Makefile @@ -0,0 +1,58 @@ +# $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_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 +.if exists(@) +linux_assym.h: @/kern/genassym.sh +.endif + sh @/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@ -Werror -Wall -fno-common -nostdinc -nostdlib \ + -Wl,-T${.CURDIR}/../../${MACHINE_CPUARCH}/linux/${VDSO}.lds.s \ + -Wl,-soname=${VDSO}.so.1,-fPIC,-warn-common \ + ${.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